diff options
Diffstat (limited to 'lib/meta.c')
| -rw-r--r-- | lib/meta.c | 1058 |
1 files changed, 561 insertions, 497 deletions
@@ -19,8 +19,12 @@ \*************************/ static char meta_ops[] = ":.;(){}[=, "; -static char meta_firsts[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_"; -static char meta_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_0123456789"; +static char meta_firsts[] = + + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_"; +static char meta_chars[] = + + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_0123456789"; phon_t *phons = NULL; field_t *fields = NULL; @@ -31,30 +35,31 @@ instruct_t *instructs = NULL; static int isident(char *word) { - if (!strchr(meta_firsts, *word)) { - return 0; - } - while (*word) { - if (!strchr(meta_chars, *(word++))) { - return 0; - } + if (!strchr(meta_firsts, *word)) { + return 0; + } + while (*word) { + if (!strchr(meta_chars, *(word++))) { + return 0; } - return 1; + } + return 1; } /* La fonction getword pour le meta parser. Beaucoup plus simple que le parser normal. */ static char *getword(char *line, char *p) { - char o; + char o; - do { - o = *(p++) = *line; - line++; - } while ((*line) && (!strchr(meta_ops, o)) && (!strchr(meta_ops, *line))); - *p = '\0'; + do { + o = *(p++) = *line; + line++; + } while ((*line) && (!strchr(meta_ops, o)) + && (!strchr(meta_ops, *line))); + *p = '\0'; - return line; + return line; } /* La terrible fonction meta_parse_line. Elle lit une chaîne correspondant à une ligne du fichier texte d'entrée. @@ -63,481 +68,510 @@ découpage en sous routines. */ void meta_parse_line(char *line) { - char buffer[BUFSIZ], *first = NULL, m = 0, *p1 = NULL, *p2 = NULL, *Fnames[MAXF], *Fimplicits[MAXF], *Snames[MAXF], *Sinames[MAXF], gotname = 0, goteoi = 0, errbuff[BUFSIZ]; - phon_t *phon = NULL; - field_t *field = NULL; - pattern_t *pattern = NULL; - instruct_t *instruct = NULL; - metaexpr_t *metaexpr = NULL, *tmetaexpr, *tabmetaexpr[MAXM]; - int Fsizes[MAXF], Fvalues[MAXF], Itypes[MAXF], Etypes[MAXF], nbfields = 0, valid, i, nbimplicit = 0; - - if (*line == '#') { - return; - } - - sprintf(errbuff, _("Read line '%s'"), line); + char buffer[BUFSIZ], *first = NULL, m = 0, *p1 = NULL, *p2 = + NULL, *Fnames[MAXF], *Fimplicits[MAXF], *Snames[MAXF], + *Sinames[MAXF], gotname = 0, goteoi = 0, errbuff[BUFSIZ]; + phon_t *phon = NULL; + field_t *field = NULL; + pattern_t *pattern = NULL; + instruct_t *instruct = NULL; + metaexpr_t *metaexpr = NULL, *tmetaexpr, *tabmetaexpr[MAXM]; + int Fsizes[MAXF], Fvalues[MAXF], Itypes[MAXF], Etypes[MAXF], nbfields = + 0, valid, i, nbimplicit = 0; + + if (*line == '#') { + return; + } + + sprintf(errbuff, _("Read line '%s'"), line); + pushcontext(errbuff); + + while (*line) { + line = getword(line, buffer); + sprintf(errbuff, _("Analysing word '%s'"), buffer); pushcontext(errbuff); + if (!m) { + /* Premier mot lut de la chaîne */ + if (*line != ':') { + exception(1, _("Missing operator ':'")); + } + line++; + switch (buffer[0]) { + case 'F': + first = Estrdup(&buffer[1]); + m = 1; + break; + case 'P': + first = Estrdup(&buffer[1]); + pattern = (pattern_t *) + Emalloc(sizeof(pattern_t)); + pattern->name = first; + pattern->next = NULL; + m = 2; + break; + case 'p': + m = 3; + break; + case 'I': + m = 4; + break; + } + } else { + /* Nous avons lut le premier mot, nous savons ce qu'il faut faire. */ + switch (m) { + case 1: /* Champ */ + if (gotname) { + Fsizes[nbfields++] = char_to_number(buffer, &valid); + if (!valid) { + exception(1, _("Invalid number.")); + } + if (*line) { + if (*line != ';') { + exception(1, + _("Expecting ';' for field separator.")); + } + line++; + gotname = 0; + } else { + field = (field_t *) + Emalloc(sizeof(field_t)); + field->next = fields->next; + fields->next = field; + field->name = first; + field->names = (char **) + Emalloc(nbfields * sizeof(char *)); + + field->sizes = (int *) Emalloc(nbfields * sizeof(int)); + + for (i = 0; i < nbfields; i++) { + field->names[i] = Fnames[i]; + field->sizes[i] = Fsizes[i]; + } + field->nbr = nbfields; + } + } else { + if (*line != ',') { + exception(1, _("Expecting ',' for field separator.")); + } + line++; + Fnames[nbfields] = Estrdup(buffer); + gotname = 1; + } + break; + case 2: /* Pattern */ + if (*buffer == '[') { + tmetaexpr = (metaexpr_t *) + Emalloc(sizeof(metaexpr_t)); + tmetaexpr->name = NULL; + tmetaexpr->string = NULL; + tmetaexpr->left = metaexpr; + metaexpr = tmetaexpr; + } else { + tmetaexpr = (metaexpr_t *) + Emalloc(sizeof(metaexpr_t)); + tmetaexpr->left = tmetaexpr->right = NULL; + tmetaexpr->type = 0; + if (*buffer == '.') { + tmetaexpr->type = 1; + popcontext(); + line = getword(line, buffer); + sprintf(errbuff, _("Analysing word '%s'"), buffer); + pushcontext(errbuff); + } + if (!isident(buffer)) { + exception(1, _("Identifier incorrect.")); + } + tmetaexpr->name = Estrdup(buffer); + if (*line == '=') { + if (*(++line) != '.') { + exception(1, _("Error: Expecting a . after a =")); + } + popcontext(); + line = getword(++line, buffer); + sprintf(errbuff, _("Analysing word '%s'"), buffer); + pushcontext(errbuff); + if (!isident(buffer)) { + exception(1, _("Identifier incorrect.")); + } + tmetaexpr->string = Estrdup(buffer); + } else { + tmetaexpr->string = NULL; + } + + if (metaexpr) { + metaexpr->right = tmetaexpr; + } else { + metaexpr = tmetaexpr; + } + if (*line == ';' || !*line) { + tabmetaexpr[nbfields++] = metaexpr; + if (*line) + line++; + metaexpr = NULL; + } + if (!*line) { + pattern = (pattern_t *) + Emalloc(sizeof(pattern_t)); + pattern->next = patterns->next; + patterns->next = pattern; + pattern->name = first; + pattern->expr = (metaexpr_t **) + Emalloc(nbfields * sizeof(metaexpr_t *)); + for (i = 0; i < nbfields; i++) { + pattern->expr[i] = tabmetaexpr[i]; + } + pattern->nbr = nbfields; + } + } + break; + case 3: /* Phonème */ + if (p1) { + if (p2) { + exception(1, _("Extra parameters for field 'p'.")); + } else { + if (isident(buffer)) { + p2 = Estrdup(buffer); + } else { + exception(1, _("Identifier incorrect.")); + } + if (*line) { + exception(1, _("Unexpected char at end of line.")); + } - while (*line) { - line = getword(line, buffer); - sprintf(errbuff, _("Analysing word '%s'"), buffer); - pushcontext(errbuff); - if (!m) { - /* Premier mot lut de la chaîne */ - if (*line != ':') { - exception(1, _("Missing operator ':'")); + phon = (phon_t *) + Emalloc(sizeof(phon_t)); + phon->next = phons->next; + phons->next = phon; + phon->p1 = p1; + phon->p2 = p2; + } + } else { + if (isident(buffer)) { + p1 = Estrdup(buffer); + if (*line != '=') { + exception(1, + _ + ("Expecting operator '=' for field 'p'.")); } line++; - switch (buffer[0]) { - case 'F': - first = Estrdup(&buffer[1]); - m = 1; - break; - case 'P': - first = Estrdup(&buffer[1]); - pattern = (pattern_t *) Emalloc(sizeof(pattern_t)); - pattern->name = first; - pattern->next = NULL; - m = 2; - break; - case 'p': - m = 3; - break; - case 'I': - m = 4; - break; + } else { + exception(1, _("Identifier incorrect.")); + } + } + break; + case 4: /* Instruction */ + if (!goteoi) { + if (isident(buffer) || (*buffer == '.')) { + Etypes[nbfields] = 0; + if (*buffer == '.') { + Etypes[nbfields] = 1; + popcontext(); + line = getword(line, buffer); + sprintf(errbuff, _("Analysing word '%s'"), buffer); + pushcontext(errbuff); + } + Fnames[nbfields] = Estrdup(buffer); + if (*line == '=') { + if (*(++line) != '.') { + exception(1, _("Error: character . expected.")); + } + popcontext(); + line = getword(++line, buffer); + sprintf(errbuff, _("Analysing word '%s'"), buffer); + pushcontext(errbuff); + if (!isident(buffer)) { + exception(1, _("Identifier incorrect.")); + } + Snames[nbfields] = Estrdup(buffer); + } else { + Snames[nbfields] = NULL; + } + nbfields++; + if (*line == ';') { + goteoi = 1; + line++; } + } } else { - /* Nous avons lut le premier mot, nous savons ce qu'il faut faire. */ - switch (m) { - case 1: /* Champ */ - if (gotname) { - Fsizes[nbfields++] = char_to_number(buffer, &valid); - if (!valid) { - exception(1, _("Invalid number.")); - } - if (*line) { - if (*line != ';') { - exception(1, _("Expecting ';' for field separator.")); - } - line++; - gotname = 0; - } else { - field = (field_t *) Emalloc(sizeof(field_t)); - field->next = fields->next; - fields->next = field; - field->name = first; - field->names = (char **) Emalloc(nbfields * sizeof(char *)); - field->sizes = (int *) Emalloc(nbfields * sizeof(int)); - - for (i = 0; i < nbfields; i++) { - field->names[i] = Fnames[i]; - field->sizes[i] = Fsizes[i]; - } - field->nbr = nbfields; - } - } else { - if (*line != ',') { - exception(1, _("Expecting ',' for field separator.")); - } - line++; - Fnames[nbfields] = Estrdup(buffer); - gotname = 1; - } - break; - case 2: /* Pattern */ - if (*buffer == '[') { - tmetaexpr = (metaexpr_t *) Emalloc(sizeof(metaexpr_t)); - tmetaexpr->name = NULL; - tmetaexpr->string = NULL; - tmetaexpr->left = metaexpr; - metaexpr = tmetaexpr; - } else { - tmetaexpr = (metaexpr_t *) Emalloc(sizeof(metaexpr_t)); - tmetaexpr->left = tmetaexpr->right = NULL; - tmetaexpr->type = 0; - if (*buffer == '.') { - tmetaexpr->type = 1; - popcontext(); - line = getword(line, buffer); - sprintf(errbuff, _("Analysing word '%s'"), buffer); - pushcontext(errbuff); - } - if (!isident(buffer)) { - exception(1, _("Identifier incorrect.")); - } - tmetaexpr->name = Estrdup(buffer); - if (*line == '=') { - if (*(++line) != '.') { - exception(1, _("Error: Expecting a . after a =")); - } - popcontext(); - line = getword(++line, buffer); - sprintf(errbuff, _("Analysing word '%s'"), buffer); - pushcontext(errbuff); - if (!isident(buffer)) { - exception(1, _("Identifier incorrect.")); - } - tmetaexpr->string = Estrdup(buffer); - } else { - tmetaexpr->string = NULL; - } - - if (metaexpr) { - metaexpr->right = tmetaexpr; - } else { - metaexpr = tmetaexpr; - } - if (*line == ';' || !*line) { - tabmetaexpr[nbfields++] = metaexpr; - if (*line) - line++; - metaexpr = NULL; - } - if (!*line) { - pattern = (pattern_t *) Emalloc(sizeof(pattern_t)); - pattern->next = patterns->next; - patterns->next = pattern; - pattern->name = first; - pattern->expr = (metaexpr_t **) Emalloc(nbfields * sizeof(metaexpr_t *)); - for (i = 0; i < nbfields; i++) { - pattern->expr[i] = tabmetaexpr[i]; - } - pattern->nbr = nbfields; - } - } - break; - case 3: /* Phonème */ - if (p1) { - if (p2) { - exception(1, _("Extra parameters for field 'p'.")); - } else { - if (isident(buffer)) { - p2 = Estrdup(buffer); - } else { - exception(1, _("Identifier incorrect.")); - } - if (*line) { - exception(1, _("Unexpected char at end of line.")); - } - - phon = (phon_t *) Emalloc(sizeof(phon_t)); - phon->next = phons->next; - phons->next = phon; - phon->p1 = p1; - phon->p2 = p2; - } - } else { - if (isident(buffer)) { - p1 = Estrdup(buffer); - if (*line != '=') { - exception(1, _("Expecting operator '=' for field 'p'.")); - } - line++; - } else { - exception(1, _("Identifier incorrect.")); - } - } - break; - case 4: /* Instruction */ - if (!goteoi) { - if (isident(buffer) || (*buffer == '.')) { - Etypes[nbfields] = 0; - if (*buffer == '.') { - Etypes[nbfields] = 1; - popcontext(); - line = getword(line, buffer); - sprintf(errbuff, _("Analysing word '%s'"), buffer); - pushcontext(errbuff); - } - Fnames[nbfields] = Estrdup(buffer); - if (*line == '=') { - if (*(++line) != '.') { - exception(1, _("Error: character . expected.")); - } - popcontext(); - line = getword(++line, buffer); - sprintf(errbuff, _("Analysing word '%s'"), buffer); - pushcontext(errbuff); - if (!isident(buffer)) { - exception(1, _("Identifier incorrect.")); - } - Snames[nbfields] = Estrdup(buffer); - } else { - Snames[nbfields] = NULL; - } - nbfields++; - if (*line == ';') { - goteoi = 1; - line++; - } - } - } else { - if (!isident(buffer)) { - exception(1, _("Identifier incorrect.")); - } - Fimplicits[nbimplicit] = Estrdup(buffer); - if (*line != '=') { - exception(1, _("= expected after an implicit name")); - } - popcontext(); - line = getword(++line, buffer); - sprintf(errbuff, _("Analysing word '%s'"), buffer); - pushcontext(errbuff); - - if (*buffer == '.') { - Itypes[nbimplicit] = 1; - popcontext(); - line = getword(line, buffer); - sprintf(errbuff, _("Analysing word '%s'"), buffer); - pushcontext(errbuff); - if (!isident(buffer)) { - exception(1, _("Identifier incorrect")); - } - Sinames[nbimplicit] = Estrdup(buffer); - } else { - Sinames[nbimplicit] = NULL; - Itypes[nbimplicit] = 2; - Fvalues[nbimplicit] = char_to_number(buffer, &valid); - if (!valid) { - if (!isident(buffer)) { - exception(1, _("Identifier incorrect")); - } - Sinames[nbimplicit] = Estrdup(buffer); - Itypes[nbimplicit] = 0; - } - } - nbimplicit++; - - if (*line) { - if (*line != ';') { - exception(1, _("expecting ; as field separator")); - } - line++; - } else { - instruct = (instruct_t *) Emalloc(sizeof(instruct_t)); - instruct->next = instructs->next; - instructs->next = instruct; - instruct->names = (char **) Emalloc(nbfields * sizeof(char *)); - instruct->strings = (char **) Emalloc(nbfields * sizeof(char *)); - instruct->etypes = (int *) Emalloc(nbfields * sizeof(int)); - instruct->implicits = (char **) Emalloc(nbimplicit * sizeof(char *)); - instruct->ivalues = (int *) Emalloc(nbimplicit * sizeof(int)); - instruct->istrings = (char **) Emalloc(nbimplicit * sizeof(char *)); - instruct->itypes = (int *) Emalloc(nbimplicit * sizeof(int)); - - for (i = 0; i < nbfields; i++) { - instruct->names[i] = Fnames[i]; - instruct->strings[i] = Snames[i]; - instruct->etypes[i] = Etypes[i]; - } - instruct->nbexplicit = nbfields; - for (i = 0; i < nbimplicit; i++) { - instruct->implicits[i] = Fimplicits[i]; - instruct->ivalues[i] = Fvalues[i]; - instruct->istrings[i] = Sinames[i]; - instruct->itypes[i] = Itypes[i]; - } - instruct->nbimplicit = nbimplicit; - goteoi = 0; - } - } - break; + if (!isident(buffer)) { + exception(1, _("Identifier incorrect.")); + } + Fimplicits[nbimplicit] = Estrdup(buffer); + if (*line != '=') { + exception(1, _("= expected after an implicit name")); + } + popcontext(); + line = getword(++line, buffer); + sprintf(errbuff, _("Analysing word '%s'"), buffer); + pushcontext(errbuff); + + if (*buffer == '.') { + Itypes[nbimplicit] = 1; + popcontext(); + line = getword(line, buffer); + sprintf(errbuff, _("Analysing word '%s'"), buffer); + pushcontext(errbuff); + if (!isident(buffer)) { + exception(1, _("Identifier incorrect")); } + Sinames[nbimplicit] = Estrdup(buffer); + } else { + Sinames[nbimplicit] = NULL; + Itypes[nbimplicit] = 2; + Fvalues[nbimplicit] = char_to_number(buffer, &valid); + if (!valid) { + if (!isident(buffer)) { + exception(1, _("Identifier incorrect")); + } + Sinames[nbimplicit] = Estrdup(buffer); + Itypes[nbimplicit] = 0; + } + } + nbimplicit++; + + if (*line) { + if (*line != ';') { + exception(1, _("expecting ; as field separator")); + } + line++; + } else { + instruct = (instruct_t *) + Emalloc(sizeof(instruct_t)); + instruct->next = instructs->next; + instructs->next = instruct; + instruct->names = (char **) + Emalloc(nbfields * sizeof(char *)); + + instruct->strings = (char **) + Emalloc(nbfields * sizeof(char *)); + + instruct->etypes = + + (int *) Emalloc(nbfields * sizeof(int)); + instruct->implicits = (char **) + Emalloc(nbimplicit * sizeof(char *)); + + instruct->ivalues = (int *) + Emalloc(nbimplicit * sizeof(int)); + + instruct->istrings = (char **) + Emalloc(nbimplicit * sizeof(char *)); + + instruct->itypes = (int *) + Emalloc(nbimplicit * sizeof(int)); + + for (i = 0; i < nbfields; i++) { + instruct->names[i] = Fnames[i]; + instruct->strings[i] = Snames[i]; + instruct->etypes[i] = Etypes[i]; + } + instruct->nbexplicit = nbfields; + for (i = 0; i < nbimplicit; i++) { + instruct->implicits[i] = Fimplicits[i]; + instruct->ivalues[i] = Fvalues[i]; + instruct->istrings[i] = Sinames[i]; + instruct->itypes[i] = Itypes[i]; + } + instruct->nbimplicit = nbimplicit; + goteoi = 0; + } } - popcontext(); + break; + } } - popcontext(); + } + + popcontext(); } /* Initialiseur et destructeur du meta parser */ int meta_init(void) { - if (!(phons = (phon_t *) malloc(sizeof(phon_t)))) { - return -1; - } - phons->p1 = phons->p2 = NULL; - phons->next = NULL; - - if (!(fields = (field_t *) malloc(sizeof(field_t)))) { - return -1; - } - fields->name = NULL; - fields->names = NULL; - fields->sizes = NULL; - fields->next = NULL; - - if (!(patterns = (pattern_t *) malloc(sizeof(pattern_t)))) { - return -1; - } - patterns->name = NULL; - patterns->expr = NULL; - patterns->next = NULL; - - if (!(instructs = (instruct_t *) malloc(sizeof(instruct_t)))) { - return -1; - } - instructs->names = NULL; - instructs->strings = NULL; - instructs->etypes = NULL; - instructs->implicits = NULL; - instructs->ivalues = NULL; - instructs->istrings = NULL; - instructs->itypes = NULL; - - return 0; + if (!(phons = (phon_t *) malloc(sizeof(phon_t)))) { + return -1; + } + phons->p1 = phons->p2 = NULL; + phons->next = NULL; + + if (!(fields = (field_t *) malloc(sizeof(field_t)))) { + return -1; + } + fields->name = NULL; + fields->names = NULL; + fields->sizes = NULL; + fields->next = NULL; + + if (!(patterns = (pattern_t *) malloc(sizeof(pattern_t)))) { + return -1; + } + patterns->name = NULL; + patterns->expr = NULL; + patterns->next = NULL; + + if (!(instructs = (instruct_t *) malloc(sizeof(instruct_t)))) { + return -1; + } + instructs->names = NULL; + instructs->strings = NULL; + instructs->etypes = NULL; + instructs->implicits = NULL; + instructs->ivalues = NULL; + instructs->istrings = NULL; + instructs->itypes = NULL; + + return 0; } static void recurs_free_phon(phon_t * phon) { - if (phon->next) { - recurs_free_phon(phon->next); - } + if (phon->next) { + recurs_free_phon(phon->next); + } - free(phon->p1); - free(phon->p2); - free(phon); + free(phon->p1); + free(phon->p2); + free(phon); } static void recurs_free_field(field_t * field) { - int i; - - if (field->next) { - recurs_free_field(field->next); - } - - free(field->name); - for (i = 0; i < field->nbr; i++) { - free(field->names[i]); - } - free(field->names); - free(field->sizes); - free(field); + int i; + + if (field->next) { + recurs_free_field(field->next); + } + + free(field->name); + for (i = 0; i < field->nbr; i++) { + free(field->names[i]); + } + free(field->names); + free(field->sizes); + free(field); } static void recurs_free_metaexpr(metaexpr_t * metaexpr) { - if (metaexpr->left) { - recurs_free_metaexpr(metaexpr->left); - } + if (metaexpr->left) { + recurs_free_metaexpr(metaexpr->left); + } - if (metaexpr->right) { - recurs_free_metaexpr(metaexpr->right); - } + if (metaexpr->right) { + recurs_free_metaexpr(metaexpr->right); + } - if (metaexpr->name) { - free(metaexpr->name); - } + if (metaexpr->name) { + free(metaexpr->name); + } - if (metaexpr->string) { - free(metaexpr->string); - } + if (metaexpr->string) { + free(metaexpr->string); + } - free(metaexpr); + free(metaexpr); } static void recurs_free_pattern(pattern_t * pattern) { - int i; - - if (pattern->next) { - recurs_free_pattern(pattern->next); - } - - free(pattern->name); - for (i = 0; i < pattern->nbr; i++) { - recurs_free_metaexpr(pattern->expr[i]); - } - free(pattern->expr); - free(pattern); + int i; + + if (pattern->next) { + recurs_free_pattern(pattern->next); + } + + free(pattern->name); + for (i = 0; i < pattern->nbr; i++) { + recurs_free_metaexpr(pattern->expr[i]); + } + free(pattern->expr); + free(pattern); } static void recurs_free_instruct(instruct_t * instruct) { - int i; - - if (instruct->next) { - recurs_free_instruct(instruct->next); - } + int i; - for (i = 0; i < instruct->nbexplicit; i++) { - free(instruct->names[i]); - if (instruct->strings[i]) { - free(instruct->strings[i]); - } - } + if (instruct->next) { + recurs_free_instruct(instruct->next); + } - for (i = 0; i < instruct->nbimplicit; i++) { - free(instruct->implicits[i]); - free(instruct->istrings[i]); + for (i = 0; i < instruct->nbexplicit; i++) { + free(instruct->names[i]); + if (instruct->strings[i]) { + free(instruct->strings[i]); } - - free(instruct->names); - free(instruct->strings); - free(instruct->etypes); - free(instruct->implicits); - free(instruct->istrings); - free(instruct->itypes); - free(instruct); + } + + for (i = 0; i < instruct->nbimplicit; i++) { + free(instruct->implicits[i]); + free(instruct->istrings[i]); + } + + free(instruct->names); + free(instruct->strings); + free(instruct->etypes); + free(instruct->implicits); + free(instruct->istrings); + free(instruct->itypes); + free(instruct); } void meta_flush(void) { - if (phons->next) - recurs_free_phon(phons->next); - if (fields->next) - recurs_free_field(fields->next); - if (patterns->next) - recurs_free_pattern(patterns->next); - if (instructs->next) - recurs_free_instruct(instructs->next); - free(phons); - free(fields); - free(patterns); - free(instructs); - phons = NULL; - fields = NULL; - patterns = NULL; - instructs = NULL; + if (phons->next) + recurs_free_phon(phons->next); + if (fields->next) + recurs_free_field(fields->next); + if (patterns->next) + recurs_free_pattern(patterns->next); + if (instructs->next) + recurs_free_instruct(instructs->next); + free(phons); + free(fields); + free(patterns); + free(instructs); + phons = NULL; + fields = NULL; + patterns = NULL; + instructs = NULL; } int meta_load(char *n) { - FILE *f; - char buf[BUFSIZ], errctx[BUFSIZ], *p; - int i = 0; + FILE *f; + char buf[BUFSIZ], errctx[BUFSIZ], *p; + int i = 0; - pushcontext(_("Loading meta file")); - sprintf(errctx, _("Opening file '%s'"), n); - pushcontext(errctx); + pushcontext(_("Loading meta file")); + sprintf(errctx, _("Opening file '%s'"), n); + pushcontext(errctx); - if (!(f = fopen(n, "r"))) { - pushcontext(strerror(errno)); - return 1; + if (!(f = fopen(n, "r"))) { + pushcontext(strerror(errno)); + return 1; + } + popcontext(); + pushcontext(_("Reading file")); + while (fgets(buf, BUFSIZ, f)) { + sprintf(errctx, _("Reading line %i"), ++i); + pushcontext(errctx); + if ((p = strchr(buf, '\r'))) { + *p = '\0'; } - popcontext(); - pushcontext(_("Reading file")); - while (fgets(buf, BUFSIZ, f)) { - sprintf(errctx, _("Reading line %i"), ++i); - pushcontext(errctx); - if ((p = strchr(buf, '\r'))) { - *p = '\0'; - } - if ((p = strchr(buf, '\n'))) { - *p = '\0'; - } - meta_parse_line(buf); - popcontext(); + if ((p = strchr(buf, '\n'))) { + *p = '\0'; } + meta_parse_line(buf); popcontext(); - popcontext(); + } + popcontext(); + popcontext(); - fclose(f); - return 0; + fclose(f); + return 0; } #ifndef HAVE_CONFIG_H @@ -546,74 +580,104 @@ int meta_load(char *n) void main(void) { - phon_t *phon; - field_t *field; - pattern_t *pattern; - instruct_t *instruct; - int i; - - if (meta_init()) - exception(1, _("Meta parser init failed.")); - - meta_load("instructions.txt"); - - fprintf(stderr, "\nListe des phonèmes:\n"); - for (phon = phons->next; phon; phon = phon->next) { - fprintf(stderr, " o %s <===> %s\n", phon->p1, phon->p2); + phon_t *phon; + field_t *field; + pattern_t *pattern; + instruct_t *instruct; + int i; + + if (meta_init()) + exception(1, _("Meta parser init failed.")); + + meta_load("instructions.txt"); + + fprintf(stderr, "\nListe des phonèmes:\n"); + for (phon = phons->next; phon; phon = phon->next) { + fprintf(stderr, " o %s <===> %s\n", phon->p1, phon->p2); + } + + fprintf(stderr, "\nListe des champs:\n"); + for (field = fields->next; field; field = field->next) { + fprintf(stderr, " o Champ nommé %s, contenant %i parties:\n", + field->name, field->nbr); + for (i = 0; i < field->nbr; i++) { + fprintf(stderr, " + %s (%i bits)\n", field->names[i], + field->sizes[i]); } + } - fprintf(stderr, "\nListe des champs:\n"); - for (field = fields->next; field; field = field->next) { - fprintf(stderr, " o Champ nommé %s, contenant %i parties:\n", field->name, field->nbr); - for (i = 0; i < field->nbr; i++) { - fprintf(stderr, " + %s (%i bits)\n", field->names[i], field->sizes[i]); - } + fprintf(stderr, "\nListe des patterns:\n"); + for (pattern = patterns->next; pattern; pattern = pattern->next) { + fprintf(stderr, + " o Pattern nommée %s, contenant %i metaexpressions:\n", + pattern->name, pattern->nbr); + for (i = 0; i < pattern->nbr; i++) { + fprintf(stderr, " + %s (%s) type: %s\n", + pattern->expr[i]->name ? pattern-> + expr[i]->name : "Opérateur [", + pattern->expr[i]->string ? pattern-> + expr[i]->string : "Aucune chaîne associée", + pattern-> + expr[i]->type ? "Constante prédéfinie" : pattern->expr[i]-> + left ? "Binaire" : pattern-> + expr[i]->right ? "Unaire" : "Feuille"); + if (pattern->expr[i]->left) { + fprintf(stderr, + " - gauche: %s (%s) type: %s\n", + pattern->expr[i]->left->name ? pattern->expr[i]->left-> + name : "Opérateur [", + pattern->expr[i]->left->string ? pattern->expr[i]-> + left->string : "Aucune chaîne associée", + pattern->expr[i]-> + left->type ? "Constante prédéfinie" : "Feuille"); + } + if (pattern->expr[i]->right) { + fprintf(stderr, + " - droite: %s (%s) type: %s\n", + pattern->expr[i]->right->name ? pattern->expr[i]-> + right->name : "Opérateur [", + pattern->expr[i]->right->string ? pattern->expr[i]-> + right->string : "Aucune chaîne associée", + pattern->expr[i]-> + right->type ? "Constante prédéfinie" : "Feuille"); + } } - - fprintf(stderr, "\nListe des patterns:\n"); - for (pattern = patterns->next; pattern; pattern = pattern->next) { - fprintf(stderr, " o Pattern nommée %s, contenant %i metaexpressions:\n", pattern->name, pattern->nbr); - for (i = 0; i < pattern->nbr; i++) { - fprintf(stderr, " + %s (%s) type: %s\n", - pattern->expr[i]->name ? pattern->expr[i]->name : "Opérateur [", - pattern->expr[i]->string ? pattern->expr[i]->string : "Aucune chaîne associée", - pattern->expr[i]->type ? "Constante prédéfinie" : pattern->expr[i]->left ? "Binaire" : pattern->expr[i]->right ? "Unaire" : "Feuille"); - if (pattern->expr[i]->left) { - fprintf(stderr, " - gauche: %s (%s) type: %s\n", - pattern->expr[i]->left->name ? pattern->expr[i]->left->name : "Opérateur [", - pattern->expr[i]->left->string ? pattern->expr[i]->left->string : "Aucune chaîne associée", pattern->expr[i]->left->type ? "Constante prédéfinie" : "Feuille"); - } - if (pattern->expr[i]->right) { - fprintf(stderr, " - droite: %s (%s) type: %s\n", - pattern->expr[i]->right->name ? pattern->expr[i]->right->name : "Opérateur [", - pattern->expr[i]->right->string ? pattern->expr[i]->right->string : "Aucune chaîne associée", - pattern->expr[i]->right->type ? "Constante prédéfinie" : "Feuille"); - } - } + } + + fprintf(stderr, "\nListe des instructions:\n"); + for (instruct = instructs->next; instruct; instruct = instruct->next) { + fprintf(stderr, + " o Instruction contenant %i champs explicites et %i champs implicites.\n", + instruct->nbexplicit, instruct->nbimplicit); + fprintf(stderr, " => Champs explicites.\n"); + for (i = 0; i < instruct->nbexplicit; i++) { + fprintf(stderr, " + %s <= %s (type %s)\n", + instruct->names[i], + instruct-> + strings[i] ? instruct->strings[i] : + "Pas de chaîne associée", + instruct->etypes[i] ? "prédéfinit" : "direct"); } - - fprintf(stderr, "\nListe des instructions:\n"); - for (instruct = instructs->next; instruct; instruct = instruct->next) { - fprintf(stderr, " o Instruction contenant %i champs explicites et %i champs implicites.\n", instruct->nbexplicit, instruct->nbimplicit); - fprintf(stderr, " => Champs explicites.\n"); - for (i = 0; i < instruct->nbexplicit; i++) { - fprintf(stderr, " + %s <= %s (type %s)\n", - instruct->names[i], instruct->strings[i] ? instruct->strings[i] : "Pas de chaîne associée", instruct->etypes[i] ? "prédéfinit" : "direct"); - } - fprintf(stderr, " => Champs implicites.\n"); - for (i = 0; i < instruct->nbimplicit; i++) { - switch (instruct->itypes[i]) { - case 0: - fprintf(stderr, " + %s <= %s (type direct)\n", instruct->implicits[i], instruct->istrings[i]); - break; - case 1: - fprintf(stderr, " + %s <= %s (type prédéfinit)\n", instruct->implicits[i], instruct->istrings[i]); - break; - case 2: - fprintf(stderr, " + %s <= %i (type valeur)\n", instruct->implicits[i], instruct->ivalues[i]); - break; - } - } + fprintf(stderr, " => Champs implicites.\n"); + for (i = 0; i < instruct->nbimplicit; i++) { + switch (instruct->itypes[i]) { + case 0: + fprintf(stderr, + " + %s <= %s (type direct)\n", + instruct->implicits[i], instruct->istrings[i]); + break; + case 1: + fprintf(stderr, + " + %s <= %s (type prédéfinit)\n", + instruct->implicits[i], instruct->istrings[i]); + break; + case 2: + fprintf(stderr, + " + %s <= %i (type valeur)\n", + instruct->implicits[i], instruct->ivalues[i]); + break; + } } + } } #endif |