From 5aed7634c8993e3366817c4b20fca1aa18eacf21 Mon Sep 17 00:00:00 2001 From: Pixel <> Date: Tue, 17 Apr 2001 04:05:52 +0000 Subject: Indentation plus faible --- lib/assembler.c | 3604 +++++++++++++++++++++++++++++-------------------------- 1 file changed, 1879 insertions(+), 1725 deletions(-) (limited to 'lib/assembler.c') diff --git a/lib/assembler.c b/lib/assembler.c index e3a49bf..0beb2df 100644 --- a/lib/assembler.c +++ b/lib/assembler.c @@ -21,42 +21,42 @@ static int process_file(char *); /* Les differentes structures de données nécessaires au traitement */ typedef struct expression_t { - int e_type; - int e_subtype; - Uint32 avalue; - char *symbol; - pattern_t *pattern; - int index; - int op; - struct expression_t *next, *prev, *child, *father; + int e_type; + int e_subtype; + Uint32 avalue; + char *symbol; + pattern_t *pattern; + int index; + int op; + struct expression_t *next, *prev, *child, *father; } expression_t; typedef struct bytestream_t { - unsigned long int Encoded; - int offset, segment, size; - char *Label; - expression_t *Expr; + unsigned long int Encoded; + int offset, segment, size; + char *Label; + expression_t *Expr; - struct bytestream_t *next; + struct bytestream_t *next; - int line, relog; - char *filename; + int line, relog; + char *filename; } bytestream_t; enum { - SEG_TEXT, - SEG_DATA, - SEG_BSS + SEG_TEXT, + SEG_DATA, + SEG_BSS }; enum { - E_STRING, - E_VALUE, - E_OPERATION, - E_LABEL, - E_INTERNAL, - E_PATTERN, - E_INSTRUCT + E_STRING, + E_VALUE, + E_OPERATION, + E_LABEL, + E_INTERNAL, + E_PATTERN, + E_INSTRUCT }; /* Nos variables globales */ @@ -76,52 +76,52 @@ int s_text = 0, s_data = 0, s_bss = 0; static void debug_print_expression(expression_t * e) { - if (!e) - return; - switch (e->e_subtype) { - case E_OPERATION: - switch (e->op) { - case OP_PLUS: - fprintf(stderr, "Operation plus\n"); - break; - case OP_MOINS: - fprintf(stderr, "Operation moins\n"); - break; - case OP_DECAL: - fprintf(stderr, "Operation decal\n"); - break; - case OP_DIRECT: - fprintf(stderr, "Operation direct\n"); - break; - default: - fprintf(stderr, "Operation diverse...\n"); - break; - } - debug_print_expression(e->child); - fprintf(stderr, "--\n"); - break; - case E_VALUE: - fprintf(stderr, "Valeur: %li\n", e->avalue); - break; - case E_LABEL: - fprintf(stderr, "Label: %s\n", e->symbol); - break; - case E_STRING: - fprintf(stderr, "String: %s\n", e->symbol); - break; - case E_PATTERN: - fprintf(stderr, "Pattern: %s, index %i\n", e->pattern->name, e->index); - break; - case E_INTERNAL: - fprintf(stderr, "Instruction interne: %s\n", e->symbol); - break; - case E_INSTRUCT: - fprintf(stderr, "Instruction: %s\n", e->symbol); - break; - } - if (e->next) { - debug_print_expression(e->next); + if (!e) + return; + switch (e->e_subtype) { + case E_OPERATION: + switch (e->op) { + case OP_PLUS: + fprintf(stderr, "Operation plus\n"); + break; + case OP_MOINS: + fprintf(stderr, "Operation moins\n"); + break; + case OP_DECAL: + fprintf(stderr, "Operation decal\n"); + break; + case OP_DIRECT: + fprintf(stderr, "Operation direct\n"); + break; + default: + fprintf(stderr, "Operation diverse...\n"); + break; } + debug_print_expression(e->child); + fprintf(stderr, "--\n"); + break; + case E_VALUE: + fprintf(stderr, "Valeur: %li\n", e->avalue); + break; + case E_LABEL: + fprintf(stderr, "Label: %s\n", e->symbol); + break; + case E_STRING: + fprintf(stderr, "String: %s\n", e->symbol); + break; + case E_PATTERN: + fprintf(stderr, "Pattern: %s, index %i\n", e->pattern->name, e->index); + break; + case E_INTERNAL: + fprintf(stderr, "Instruction interne: %s\n", e->symbol); + break; + case E_INSTRUCT: + fprintf(stderr, "Instruction: %s\n", e->symbol); + break; + } + if (e->next) { + debug_print_expression(e->next); + } } static expression_t *copy_expression(expression_t * e); @@ -130,574 +130,588 @@ static expression_t *copy_expression(expression_t * e); static bytestream_t *pushuninit(int size) { - bytestream_t *s; - - s = (bytestream_t *) Emalloc(sizeof(bytestream_t)); - s->next = NULL; - s->Encoded = 0; - s->segment = segment; - s->size = 1; - s->Label = NULL; - s->Expr = NULL; - - s->relog = 1; - - s->line = line; - s->filename = filenames[nestedinc - 1]; - - - switch (segment) { - case SEG_TEXT: - s->offset = s_text; - p_text->next = s; - p_text = s; - s_text += size; - break; - case SEG_DATA: - s->offset = s_data; - p_data->next = s; - p_data = s; - s_data += size; - break; - case SEG_BSS: - s->offset = s_bss; - p_bss->next = s; - p_bss = s; - s_bss += size; - break; - - } - - return s; + bytestream_t *s; + + s = (bytestream_t *) Emalloc(sizeof(bytestream_t)); + s->next = NULL; + s->Encoded = 0; + s->segment = segment; + s->size = 1; + s->Label = NULL; + s->Expr = NULL; + + s->relog = 1; + + s->line = line; + s->filename = filenames[nestedinc - 1]; + + + switch (segment) { + case SEG_TEXT: + s->offset = s_text; + p_text->next = s; + p_text = s; + s_text += size; + break; + case SEG_DATA: + s->offset = s_data; + p_data->next = s; + p_data = s; + s_data += size; + break; + case SEG_BSS: + s->offset = s_bss; + p_bss->next = s; + p_bss = s; + s_bss += size; + break; + + } + + return s; } static bytestream_t *pushdword(unsigned long int d, expression_t * e) { - bytestream_t *s; + bytestream_t *s; - if ((segment < 0) || (segment > 1)) { - exception(1, _("You have to be into the .text or the .data segment to define a value.")); - } + if ((segment < 0) || (segment > 1)) { + exception(1, + _ + ("You have to be into the .text or the .data segment to define a value.")); + } - s = pushuninit(1); - s->Encoded = d; - if (e) { - s->Expr = copy_expression(e); - } + s = pushuninit(1); + s->Encoded = d; + if (e) { + s->Expr = copy_expression(e); + } - return s; + return s; } static bytestream_t *pushlabel(char *label) { - bytestream_t *s; - char trouve; + bytestream_t *s; + char trouve; - s = pushuninit(0); - s->Label = Estrdup(label); - s->size = 0; + s = pushuninit(0); + s->Label = Estrdup(label); + s->size = 0; - NomVarToVar(label, labels, &trouve); + NomVarToVar(label, labels, &trouve); - if (trouve) { - exception(1, _("Label already defined")); - } + if (trouve) { + exception(1, _("Label already defined")); + } - InsererVarDansTab(&labels, CreerElement(label, s)); + InsererVarDansTab(&labels, CreerElement(label, s)); - return s; + return s; } static void pushstring(char *s) { - char marker = *s, tstring[6]; - int valid; + char marker = *s, tstring[6]; + int valid; - s++; + s++; - while ((*s) && (marker != *s)) { - if (*s == '\\') { - s++; - switch (*s) { - case '0': - pushdword('\0', NULL); - break; - case 'a': - pushdword('\a', NULL); - break; - case 'b': - pushdword('\b', NULL); - break; - case 'f': - pushdword('\f', NULL); - break; - case 'n': - pushdword('\n', NULL); - break; - case 'r': - pushdword('\r', NULL); - break; - case 't': - pushdword('\t', NULL); - break; - case 'v': - pushdword('\v', NULL); - break; - case '\'': - case '\"': - case '\\': - pushdword(*s, NULL); - break; - case 'x': - tstring[0] = '0'; - strncpy(tstring + 1, s, 4); - pushdword(char_to_number(tstring, &valid), NULL); - break; - } - } else { - pushdword(*s, NULL); - } - s++; + while ((*s) && (marker != *s)) { + if (*s == '\\') { + s++; + switch (*s) { + case '0': + pushdword('\0', NULL); + break; + case 'a': + pushdword('\a', NULL); + break; + case 'b': + pushdword('\b', NULL); + break; + case 'f': + pushdword('\f', NULL); + break; + case 'n': + pushdword('\n', NULL); + break; + case 'r': + pushdword('\r', NULL); + break; + case 't': + pushdword('\t', NULL); + break; + case 'v': + pushdword('\v', NULL); + break; + case '\'': + case '\"': + case '\\': + pushdword(*s, NULL); + break; + case 'x': + tstring[0] = '0'; + strncpy(tstring + 1, s, 4); + pushdword(char_to_number(tstring, &valid), NULL); + break; + } + } else { + pushdword(*s, NULL); } - pushdword(0, NULL); + s++; + } + pushdword(0, NULL); } static void pushstart(void) { - if (segment != SEG_TEXT) { - exception(1, _("You can't have the startpoint elsewhere than the .text segment")); - } - pushlabel("__start__"); + if (segment != SEG_TEXT) { + exception(1, + _ + ("You can't have the startpoint elsewhere than the .text segment")); + } + pushlabel("__start__"); } /* Nous recherchons si une string est une pattern "simple" (pas composée) */ static void look4pattern(pattern_t * patterns, expression_t * expression) { - int i; - - for (patterns = patterns->next; patterns; patterns = patterns->next) { - for (i = 0; i < patterns->nbr; i++) { - if (!(patterns->expr[i]->type || patterns->expr[i]->string || !patterns->expr[i]->name)) { - if (!strcasecmp(patterns->expr[i]->name, expression->symbol)) { - expression->e_subtype = E_PATTERN; - expression->pattern = patterns; - expression->index = i; - return; - } - } + int i; + + for (patterns = patterns->next; patterns; patterns = patterns->next) { + for (i = 0; i < patterns->nbr; i++) { + if (! + (patterns->expr[i]->type + || patterns->expr[i]->string || !patterns->expr[i]->name)) { + if (!strcasecmp(patterns->expr[i]->name, expression->symbol)) { + expression->e_subtype = E_PATTERN; + expression->pattern = patterns; + expression->index = i; + return; } + } } + } } /* Nous vérifions rapidement si la string en cours fait partie des instructions recensées */ static void look4instr(phon_t * phons, instruct_t * instructs, expression_t * e) { - char *stringtolook = e->symbol; + char *stringtolook = e->symbol; - for (phons = phons->next; phons; phons = phons->next) { - if (!strcasecmp(phons->p1, stringtolook)) { - stringtolook = phons->p2; - break; - } + for (phons = phons->next; phons; phons = phons->next) { + if (!strcasecmp(phons->p1, stringtolook)) { + stringtolook = phons->p2; + break; } + } - for (instructs = instructs->next; instructs; instructs = instructs->next) { - if (!strcasecmp(instructs->names[0], stringtolook)) { - e->e_subtype = E_INSTRUCT; - return; - } + for (instructs = instructs->next; instructs; instructs = instructs->next) { + if (!strcasecmp(instructs->names[0], stringtolook)) { + e->e_subtype = E_INSTRUCT; + return; } + } } /* Libère récursivement une expression */ static void free_expr(expression_t * e) { - if (e->child) { - free_expr(e->child); - } + if (e->child) { + free_expr(e->child); + } - if (e->next) { - free_expr(e->next); - } + if (e->next) { + free_expr(e->next); + } - if (e->symbol) { - free(e->symbol); - } + if (e->symbol) { + free(e->symbol); + } - free(e); + free(e); } /* Copie récursivement une expression */ static expression_t *copy_expression(expression_t * e) { - expression_t *t, *e_t; - char trouve; + expression_t *t, *e_t; + char trouve; - t = Emalloc(sizeof(expression_t)); - *t = *e; + t = Emalloc(sizeof(expression_t)); + *t = *e; - if (t->symbol) { - trouve = 0; - if (e->e_subtype == E_LABEL) { - e_t = (expression_t *) NomVarToVar(e->symbol, defines, &trouve); - } - if ((trouve) && (t->e_type = E_STRING)) { - free(t); - t = copy_expression(e_t); - return t; - } else { - t->symbol = Estrdup(t->symbol); - } + if (t->symbol) { + trouve = 0; + if (e->e_subtype == E_LABEL) { + e_t = (expression_t *) NomVarToVar(e->symbol, defines, &trouve); } - - if (t->child) { - t->child = copy_expression(t->child); + if ((trouve) && (t->e_type = E_STRING)) { + free(t); + t = copy_expression(e_t); + return t; + } else { + t->symbol = Estrdup(t->symbol); } + } - if (t->next) { - t->next = copy_expression(t->next); - } + if (t->child) { + t->child = copy_expression(t->child); + } - if (t->next) { - t->next->prev = t; - } + if (t->next) { + t->next = copy_expression(t->next); + } + + if (t->next) { + t->next->prev = t; + } - return t; + return t; } /* Cette fonction est appelée par le parseur. Elle rajoute un symbole sur la pile des expressions pour la ligne en cours */ void push_pile(char *a) { - int valid, number; - expression_t *e, *e_t; - char trouve; - static char err[BUFSIZ]; - - if (!wc) { - special = 0; - switch (downcase(*a)) { - case '.': - valid = 0; - special = 1; - switch (downcase(*(a + 1))) { - case 'd': - if (!(strcasecmp(a + 2, "ata"))) { - segment = SEG_DATA; - valid = 1; - wc++; - return; - } - break; - case 't': - if (!(strcasecmp(a + 2, "ext"))) { - segment = SEG_TEXT; - valid = 1; - wc++; - return; - } - break; - case 'b': - if (!(strcasecmp(a + 2, "ss"))) { - segment = SEG_BSS; - valid = 1; - wc++; - return; - } - break; - case 's': - if (!(strcasecmp(a + 2, "tart"))) { - pushstart(); - valid = 1; - wc++; - return; - } - break; - } - if (!valid) { - exception(1, _("Not a valid . directive")); - } - break; - case '#': - valid = 0; - switch (downcase(*(a + 1))) { - case 'd': - if (!(strcasecmp(a + 2, "efine"))) { - special = 2; - valid = 1; - } - wc++; - return; - case 'u': - if (!(strcasecmp(a + 2, "ndef"))) { - special = 3; - valid = 1; - } - wc++; - return; - case 'i': - if (!(strcasecmp(a + 2, "nclude"))) { - special = 4; - valid = 1; - } - wc++; - return; - } - if (!valid) { - exception(1, _("Not a valid # directive")); - } - break; - } - } + int valid, number; + expression_t *e, *e_t; + char trouve; + static char err[BUFSIZ]; - switch (special) { - case 1: /* Cas des directives . */ - exception(1, _("Error: extra parameters to a . directive.")); + if (!wc) { + special = 0; + switch (downcase(*a)) { + case '.': + valid = 0; + special = 1; + switch (downcase(*(a + 1))) { + case 'd': + if (!(strcasecmp(a + 2, "ata"))) { + segment = SEG_DATA; + valid = 1; + wc++; + return; + } break; - case 2: /* Cas de #define */ - if (wc == 1) { - defined = Estrdup(a); - break; + case 't': + if (!(strcasecmp(a + 2, "ext"))) { + segment = SEG_TEXT; + valid = 1; + wc++; + return; } - case 0: /* Cas normal */ - e = (expression_t *) Emalloc(sizeof(expression_t)); - if (!e_line) { - e_line = e_current = e; + break; + case 'b': + if (!(strcasecmp(a + 2, "ss"))) { + segment = SEG_BSS; + valid = 1; + wc++; + return; } - e->pattern = NULL; - number = char_to_number(a, &valid); - if (valid) { - e->e_type = E_VALUE; - e->e_subtype = E_VALUE; - e->avalue = number; - e->symbol = NULL; - } else { - trouve = 0; - if ((*a != '"') && (*a != '\'')) { - e_t = (expression_t *) NomVarToVar(a, defines, &trouve); - } - if (trouve) { - e = copy_expression(e_t); - } else { - e->e_type = E_STRING; - e->e_subtype = E_STRING; - e->avalue = 0; - e->symbol = Estrdup(a); - } + break; + case 's': + if (!(strcasecmp(a + 2, "tart"))) { + pushstart(); + valid = 1; + wc++; + return; } - e->op = -1; - if (wc) { - e->prev = e_current; - } else { - e->prev = NULL; + break; + } + if (!valid) { + exception(1, _("Not a valid . directive")); + } + break; + case '#': + valid = 0; + switch (downcase(*(a + 1))) { + case 'd': + if (!(strcasecmp(a + 2, "efine"))) { + special = 2; + valid = 1; + } + wc++; + return; + case 'u': + if (!(strcasecmp(a + 2, "ndef"))) { + special = 3; + valid = 1; } - e->next = NULL; - if (wc) { - e_current->next = e; + wc++; + return; + case 'i': + if (!(strcasecmp(a + 2, "nclude"))) { + special = 4; + valid = 1; } - e->father = NULL; - e->child = NULL; - - /* On prédevine le subtype sur quelques cas */ + wc++; + return; + } + if (!valid) { + exception(1, _("Not a valid # directive")); + } + break; + } + } + + switch (special) { + case 1: /* Cas des directives . */ + exception(1, _("Error: extra parameters to a . directive.")); + break; + case 2: /* Cas de #define */ + if (wc == 1) { + defined = Estrdup(a); + break; + } + case 0: /* Cas normal */ + e = (expression_t *) Emalloc(sizeof(expression_t)); + if (!e_line) { + e_line = e_current = e; + } + e->pattern = NULL; + number = char_to_number(a, &valid); + if (valid) { + e->e_type = E_VALUE; + e->e_subtype = E_VALUE; + e->avalue = number; + e->symbol = NULL; + } else { + trouve = 0; + if ((*a != '"') && (*a != '\'')) { + e_t = (expression_t *) NomVarToVar(a, defines, &trouve); + } + if (trouve) { + e = copy_expression(e_t); + } else { + e->e_type = E_STRING; + e->e_subtype = E_STRING; + e->avalue = 0; + e->symbol = Estrdup(a); + } + } + e->op = -1; + if (wc) { + e->prev = e_current; + } else { + e->prev = NULL; + } + e->next = NULL; + if (wc) { + e_current->next = e; + } + e->father = NULL; + e->child = NULL; - /* Cas des labels (en nom:) */ + /* On prédevine le subtype sur quelques cas */ - if ((wc == 0) && (a[strlen(a) - 1] == ':')) { - e->e_subtype = E_LABEL; - } + /* Cas des labels (en nom:) */ - /* Cas des pseudos instructions {DB, DW, DD, DS, DR} */ + if ((wc == 0) && (a[strlen(a) - 1] == ':')) { + e->e_subtype = E_LABEL; + } - if (wc <= 1) { + /* Cas des pseudos instructions {DB, DW, DD, DS, DR} */ + + if (wc <= 1) { + trouve = 0; + switch (downcase(*a)) { + case 'd': + if (!*(a + 2)) { + trouve = 1; + switch (downcase(*(a + 1))) { + case 'b': + e->op = 1; + break; + case 'w': + e->op = 2; + break; + case 'd': + e->op = 3; + break; + case 's': + e->op = 4; + break; + case 'r': + e->op = 5; + break; + default: trouve = 0; - switch (downcase(*a)) { - case 'd': - if (!*(a + 2)) { - trouve = 1; - switch (downcase(*(a + 1))) { - case 'b': - e->op = 1; - break; - case 'w': - e->op = 2; - break; - case 'd': - e->op = 3; - break; - case 's': - e->op = 4; - break; - case 'r': - e->op = 5; - break; - default: - trouve = 0; - } - } - } - if (trouve) { - e->e_subtype = E_INTERNAL; - if (e->prev) { - e->prev->e_subtype = E_LABEL; - } - } + } + } + } + if (trouve) { + e->e_subtype = E_INTERNAL; + if (e->prev) { + e->prev->e_subtype = E_LABEL; } + } + } - /* Cas des patterns */ + /* Cas des patterns */ - if (e->e_subtype == E_STRING) { - look4pattern(patterns, e); - } + if (e->e_subtype == E_STRING) { + look4pattern(patterns, e); + } - /* On regarde si cela n'est pas une instruction connue dans le meta langage */ + /* On regarde si cela n'est pas une instruction connue dans le meta langage */ - if (((wc == 0) && (e->e_subtype == E_STRING)) - || ((wc == 1) && (e->prev->e_subtype == E_LABEL))) { - look4instr(phons, instructs, e); - } + if (((wc == 0) && (e->e_subtype == E_STRING)) + || ((wc == 1) && (e->prev->e_subtype == E_LABEL))) { + look4instr(phons, instructs, e); + } - /* Dans tous les autres cas, nous considerons qu'il s'agit d'une référence à un label... */ + /* Dans tous les autres cas, nous considerons qu'il s'agit d'une référence à un label... */ - if (e->e_subtype == E_STRING) { - if (((e->symbol[0] != '\"') && (e->symbol[0] != '\'')) && (strcmp(e->symbol, "?"))) { - e->e_subtype = E_LABEL; - } - } + if (e->e_subtype == E_STRING) { + if (((e->symbol[0] != '\"') && (e->symbol[0] != '\'')) + && (strcmp(e->symbol, "?"))) { + e->e_subtype = E_LABEL; + } + } - e_current = e; - break; - case 3: /* Cas de #undef */ - if (wc != 1) { - exception(1, _("Too much arguments to #undef")); - } - NomVarToVar(a, defines, &trouve); - if (!trouve) { - exception(1, _("Defined symbol not found.")); - } - SupprimerDansTab(&defines, a); - break; - case 4: /* Cas de #include */ - if (wc != 1) { - exception(1, _("Too much arguments to #include")); - } - sprintf(err, _("Including file at line %i"), line); - pushcontext(err); - if (process_file(a)) { - exception(1, _("Error reading include file")); - } - popcontext(); - break; + e_current = e; + break; + case 3: /* Cas de #undef */ + if (wc != 1) { + exception(1, _("Too much arguments to #undef")); + } + NomVarToVar(a, defines, &trouve); + if (!trouve) { + exception(1, _("Defined symbol not found.")); } + SupprimerDansTab(&defines, a); + break; + case 4: /* Cas de #include */ + if (wc != 1) { + exception(1, _("Too much arguments to #include")); + } + sprintf(err, _("Including file at line %i"), line); + pushcontext(err); + if (process_file(a)) { + exception(1, _("Error reading include file")); + } + popcontext(); + break; + } - wc++; + wc++; } /* Cette fonction évalue l'expression en cours. */ static void evaluate(expression_t * e) { - expression_t *t, *u; - - if (e->e_subtype != E_OPERATION) - return; - - switch (e->op) { - case OP_PLUS: - case OP_MOINS: - case OP_MUL: - case OP_DIV: - case OP_MOD: - if ((e->child->e_subtype == E_VALUE) && (e->child->next->e_subtype == E_VALUE)) { - switch (e->op) { - case OP_PLUS: - e->avalue = e->child->avalue + e->child->next->avalue; - break; - case OP_MOINS: - e->avalue = e->child->avalue - e->child->next->avalue; - break; - case OP_MUL: - e->avalue = e->child->avalue * e->child->next->avalue; - break; - case OP_DIV: - if (!e->child->next->avalue) { - exception(1, _("Zero divide.")); - } - e->avalue = e->child->avalue / e->child->next->avalue; - break; - case OP_MOD: - if (!e->child->next->avalue) { - exception(1, _("Zero divide.")); - } - e->avalue = e->child->avalue % e->child->next->avalue; - break; - } - free(e->child->next); - free(e->child); - e->child = NULL; - e->e_type = e->e_subtype = E_VALUE; - } else { - /* un seul cas particulier supporté... */ - if (!((e->op == OP_PLUS) - || ((e->op == OP_MOINS) && (e->child->next->e_subtype = E_VALUE)))) { - exception(1, _("Error: unable to compute the immediate value")); - } - } + expression_t *t, *u; + + if (e->e_subtype != E_OPERATION) + return; + + switch (e->op) { + case OP_PLUS: + case OP_MOINS: + case OP_MUL: + case OP_DIV: + case OP_MOD: + if ((e->child->e_subtype == E_VALUE) + && (e->child->next->e_subtype == E_VALUE)) { + switch (e->op) { + case OP_PLUS: + e->avalue = e->child->avalue + e->child->next->avalue; break; - case OP_PLUS_UNARY: - case OP_MOINS_UNARY: - if (!e->child->e_subtype == E_VALUE) { - exception(1, _("Error: unable to compute the immediate value")); - } - e->avalue = (e->op == OP_MOINS_UNARY) ? -e->child->avalue : e->child->avalue; - free(e->child); - e->child = NULL; - e->e_type = e->e_subtype = E_VALUE; + case OP_MOINS: + e->avalue = e->child->avalue - e->child->next->avalue; + break; + case OP_MUL: + e->avalue = e->child->avalue * e->child->next->avalue; break; - case OP_FUNC_CALL: - if (strcasecmp(e->symbol, "diff")) { - exception(1, _("Function unknow")); + case OP_DIV: + if (!e->child->next->avalue) { + exception(1, _("Zero divide.")); } + e->avalue = e->child->avalue / e->child->next->avalue; break; - /* Jusqu'ici les évaluations étaient faciles. Nous allons attaquer la partie la plus ardue - de l'évaluation, celle de l'évaluation (disons plutôt de la simplification) des adresses */ - case OP_DECAL: - if ((e->child->e_subtype == E_LABEL) && (e->child->next->e_subtype == E_LABEL)) { - exception(1, _("Addresses addition not allowed")); + case OP_MOD: + if (!e->child->next->avalue) { + exception(1, _("Zero divide.")); } + e->avalue = e->child->avalue % e->child->next->avalue; + break; + } + free(e->child->next); + free(e->child); + e->child = NULL; + e->e_type = e->e_subtype = E_VALUE; + } else { + /* un seul cas particulier supporté... */ + if (!((e->op == OP_PLUS) + || ((e->op == OP_MOINS) + && (e->child->next->e_subtype = E_VALUE)))) { + exception(1, _("Error: unable to compute the immediate value")); + } + } + break; + case OP_PLUS_UNARY: + case OP_MOINS_UNARY: + if (!e->child->e_subtype == E_VALUE) { + exception(1, _("Error: unable to compute the immediate value")); + } + e->avalue = + (e->op == OP_MOINS_UNARY) ? -e->child->avalue : e->child->avalue; + free(e->child); + e->child = NULL; + e->e_type = e->e_subtype = E_VALUE; + break; + case OP_FUNC_CALL: + if (strcasecmp(e->symbol, "diff")) { + exception(1, _("Function unknow")); + } + break; + /* Jusqu'ici les évaluations étaient faciles. Nous allons attaquer la partie la plus ardue + de l'évaluation, celle de l'évaluation (disons plutôt de la simplification) des adresses */ + case OP_DECAL: + if ((e->child->e_subtype == E_LABEL) + && (e->child->next->e_subtype == E_LABEL)) { + exception(1, _("Addresses addition not allowed")); + } - if (e->child->e_subtype != E_LABEL) { - exception(1, _("You can only use the decal operator on labels")); - } + if (e->child->e_subtype != E_LABEL) { + exception(1, _("You can only use the decal operator on labels")); + } - if (e->child->next->e_subtype == E_OPERATION) { - if ((e->child->next->op != OP_MOINS) && (e->child->next->op != OP_PLUS)) { - exception(1, _("Address operation invalid")); - } - if ((e->child->next->op == OP_MOINS) && (e->child->next->child->next->e_subtype != E_VALUE)) { - exception(1, _("Address operation invalid")); - } - if (e->child->next->child->e_subtype == E_LABEL) { - exception(1, _("Addresses operations not allowed")); - } - if (e->child->next->child->e_subtype == e->child->next->child->next->e_subtype) { - exception(1, _("Expression too complex or invalid")); - } - /* On veut obtenir quelque chose sous la forme LABEL[VALUE + PATTERN] */ - if (e->child->next->child->e_subtype == E_PATTERN) { - t = e->child->next->child; - e->child->next->child = t->next; - t->next->prev = NULL; - t->next->next = t; - t->prev = t->next; - t->next = NULL; - } - } - break; - case OP_DIRECT: + if (e->child->next->e_subtype == E_OPERATION) { + if ((e->child->next->op != OP_MOINS) + && (e->child->next->op != OP_PLUS)) { + exception(1, _("Address operation invalid")); + } + if ((e->child->next->op == OP_MOINS) + && (e->child->next->child->next->e_subtype != E_VALUE)) { + exception(1, _("Address operation invalid")); + } + if (e->child->next->child->e_subtype == E_LABEL) { + exception(1, _("Addresses operations not allowed")); + } + if (e->child->next->child->e_subtype == + e->child->next->child->next->e_subtype) { + exception(1, _("Expression too complex or invalid")); + } + /* On veut obtenir quelque chose sous la forme LABEL[VALUE + PATTERN] */ + if (e->child->next->child->e_subtype == E_PATTERN) { + t = e->child->next->child; + e->child->next->child = t->next; + t->next->prev = NULL; + t->next->next = t; + t->prev = t->next; + t->next = NULL; + } + } + break; + case OP_DIRECT: /*******************************************************************\ | Le code qui suit est sans doute immonde mais il est nécessaire... | | Attention à la foret d'ifs, ça fait mal quand on s'y pert... | @@ -706,37 +720,38 @@ static void evaluate(expression_t * e) | Nous la modifierons au fur et a mesure de sorte à lui donner une | | forme canonique afin de pouvoir la traiter correctement plus tard | \*******************************************************************/ - switch (e->child->e_subtype) { - case E_OPERATION: - if (!((e->child->op == OP_PLUS) || (e->child->op == OP_MOINS))) { - exception(1, _("Address operation invalid")); - } - if ((e->child->child->e_subtype == E_LABEL) - && (e->child->child->next->e_subtype == E_LABEL)) { - exception(1, _("Addresses operations not allowed")); - } - if (e->child->child->next->e_subtype == E_LABEL) { - if (e->child->op == OP_MOINS) { - exception(1, _("Address type not supported")); - } - /* Sous la forme [A + LABEL], on inverse... */ - t = e->child->child; - e->child->child = t->next; - t->next->prev = NULL; - t->next->next = t; - t->prev = t->next; - t->next = NULL; - } - if (e->child->child->e_subtype == E_LABEL) { - if ((e->child->op != OP_PLUS) - && (e->child->child->next->e_subtype != E_VALUE)) { - exception(1, _("Address type not supported")); - } - } else { - if ((e->child->child->e_subtype == E_OPERATION) - && ((e->child->child->op == OP_PLUS) - || (e->child->child->op == OP_MOINS))) { - /* On est sous la forme [(A +- B) +- C], on inverse... */ + switch (e->child->e_subtype) { + case E_OPERATION: + if (!((e->child->op == OP_PLUS) + || (e->child->op == OP_MOINS))) { + exception(1, _("Address operation invalid")); + } + if ((e->child->child->e_subtype == E_LABEL) + && (e->child->child->next->e_subtype == E_LABEL)) { + exception(1, _("Addresses operations not allowed")); + } + if (e->child->child->next->e_subtype == E_LABEL) { + if (e->child->op == OP_MOINS) { + exception(1, _("Address type not supported")); + } + /* Sous la forme [A + LABEL], on inverse... */ + t = e->child->child; + e->child->child = t->next; + t->next->prev = NULL; + t->next->next = t; + t->prev = t->next; + t->next = NULL; + } + if (e->child->child->e_subtype == E_LABEL) { + if ((e->child->op != OP_PLUS) + && (e->child->child->next->e_subtype != E_VALUE)) { + exception(1, _("Address type not supported")); + } + } else { + if ((e->child->child->e_subtype == E_OPERATION) + && ((e->child->child->op == OP_PLUS) + || (e->child->child->op == OP_MOINS))) { + /* On est sous la forme [(A +- B) +- C], on inverse... */ /***********************************************\ | | @@ -762,427 +777,455 @@ static void evaluate(expression_t * e) | | \***********************************************/ - t = e->child->child->child->next; /* t pointe sur B */ + t = e->child->child->child->next; /* t pointe sur B */ - e->child->child->child->next = e->child; /* Op1 devient fils droit de Op2 */ - e->child->father = e->child->child; - e->child->prev = e->child->child->child; + e->child->child->child->next = e->child; /* Op1 devient fils droit de Op2 */ + e->child->father = e->child->child; + e->child->prev = e->child->child->child; - e->child = e->child->child; /* Fils de Direct devient Op2 */ - e->child->father = e; + e->child = e->child->child; /* Fils de Direct devient Op2 */ + e->child->father = e; - e->child->child->next->child = t; /* B devient fils gauche de Op1 */ - t->next = e->child->next; - t->next->prev = t; - t->father = t->next->father; - t->prev = NULL; + e->child->child->next->child = t; /* B devient fils gauche de Op1 */ + t->next = e->child->next; + t->next->prev = t; + t->father = t->next->father; + t->prev = NULL; - } - if ((t = e->child->child->next)->e_subtype == E_OPERATION) { - /* On est sous la forme [A +- (B +- C)], on vérifie l'intégrité de la sous opération. - Cela ne peut pas être [A - (B +- C)] car il faut que (B +- C) soit une valeur - immediate et donc aurait été calculé avant. */ - if (e->child->op == OP_MOINS) { - exception(1, _("Address type not supported")); - } - switch (e->child->child->e_subtype) { - /* quoique similiares, les trois cas suivant nécessitent trois traitements - différents */ - case E_LABEL: - /* On a donc [LABEL + (B +- C)], on va vérifier si C n'est pas une PATTERN, - et si c'est le cas, il ne faut pas que ce soit - C. Sinon nous ne devons - pas avoir de labels pour B ou C */ - - if ((e->child->child->next->child->next->e_subtype == E_PATTERN) && (e->child->child->next->op == OP_MOINS)) { - exception(1, _("Address type not supported")); - } - - if (e->child->child->next->child->e_subtype == E_LABEL) { - exception(1, _("Address addition not supported")); - } - - /* Si B et C sont du même type, on jette l'éponge... */ - - if (e->child->child->next->child->e_subtype == e->child->child->next->child->next->e_subtype) { - exception(1, _("Expression too complex or invalid")); - } - - /* Ok, si notre expression a réussi à franchir toutes ses étapes, c'est qu'elle - est correcte.... Enfin j'espère :) Je vais modifier l'expression de sorte a ce - qu'elle ait la forme [LABEL + (VALEUR +- PATTERN)] */ - - if ((t = e->child->child->next->child)->e_subtype == E_PATTERN) { - t->prev = t->next; - t->next = NULL; - t->prev->next = t; - t->prev->prev = NULL; - t->father->child = t->prev; - if (t->father->op == OP_MOINS) { - t->father->op = OP_PLUS; - t->prev->avalue = -t->prev->avalue; - } - } - break; - case E_PATTERN: - /* On a donc [PATTERN + (B +- C)], on va vérifier si C n'est pas un LABEL, - et si c'est le cas, il ne faut pas que ce soit - C. Sinon nous ne devons - pas avoir de patterns pour B ou C. */ - - if ((e->child->child->next->child->next->e_subtype == E_LABEL) && (e->child->child->next->op == OP_MOINS)) { - exception(1, _("Address type not supported")); - } - - if (e->child->child->next->child->e_subtype == E_PATTERN) { - exception(1, _("Expression invalid")); - } - - /* Si B et C sont du même type, on jette l'éponge... */ - - if (e->child->child->next->child->e_subtype == e->child->child->next->child->next->e_subtype) { - exception(1, _("Expression too complex or invalid")); - } - - /* Ok, si notre expression a réussi à franchir toutes ses étapes, c'est qu'elle - est correcte.... Enfin j'espère :) Je vais modifier l'expression de sorte a ce - qu'elle ait la forme [LABEL + (VALEUR +- PATTERN)] */ - - /* Pas mal de boulot ici... */ - if ((t = e->child->child->next->child)->e_subtype == E_LABEL) { - /* Nous avons [PATTERN + (LABEL +- VALEUR)], on inverse LABEL et VALEUR */ - t->prev = t->next; - t->next = NULL; - t->prev->next = t; - t->prev->prev = NULL; - t->father->child = t->prev; - if (t->father->op == OP_MOINS) { - t->father->op = OP_PLUS; - t->prev->avalue = -t->prev->avalue; - } - } - - /* Nous avons [PATTERN + (VALEUR + LABEL)] */ - - /* On bouge le LABEL */ - t = e->child->child->next->child->next; - t->father = e->child; - t->prev = NULL; - t->next = e->child->child->next; - - /* On bouge le PATTERN */ - t = e->child->child; - t->father = t->next; - t->prev = t->next->child; - t->next = NULL; - - /* On rétablit l'arbre correct */ - e->child->child = t->prev->next; - e->child->child->next->prev = e->child->child; - t->prev->next = t; - break; - case E_VALUE: - /* On a donc [VALUE + (B +- C)], si B ou C sont des valeurs, on intervient. */ - - if (e->child->child->next->child->e_subtype == E_VALUE) { - if (e->child->child->next->op == OP_MOINS) { - exception(1, _("Expression invalid")); - } - e->child->child->avalue += e->child->child->next->child->avalue; - t = e->child->child->next; - e->child->child->next = t->child->next; - free_expr(t); - /* Magie, on a attérit sur le cas [VALUE + qquechose] ... - On va pas s'embeter, on va réévaluer la chose :) */ - evaluate(e); - return; - } else if (e->child->child->next->child->next->e_subtype == E_VALUE) { - /* Quasiment la même chose qu'au dessus... */ - if (e->child->child->next->op == OP_MOINS) { - e->child->child->avalue -= e->child->child->next->child->avalue; - } else { - e->child->child->avalue += e->child->child->next->child->avalue; - } - t = e->child->child->next; - e->child->child->next = t->child; - free_expr(t); - evaluate(e); - return; - } else { - /* Si B et C sont du même type, on jette l'éponge... */ - - if (e->child->child->next->child->e_subtype == e->child->child->next->child->next->e_subtype) { - exception(1, _("Expression too complex or invalid")); - } - - /* Ok, si notre expression a réussi à franchir toutes ses étapes, c'est qu'elle - est correcte.... Enfin j'espère :) Je vais modifier l'expression de sorte a ce - qu'elle ait la forme [LABEL + (VALEUR +- PATTERN)] */ - - /* Pas mal de boulot ici... */ - if ((t = e->child->child->next->child)->e_subtype == E_PATTERN) { - /* Nous avons [VALEUR + (PATTERN + LABEL)], on inverse LABEL et PATTERN */ - t->prev = t->next; - t->next = NULL; - t->prev->next = t; - t->prev->prev = NULL; - t->father->child = t->prev; - if (t->father->op == OP_MOINS) { - t->father->op = OP_PLUS; - t->prev->avalue = -t->prev->avalue; - } - } - - /* Nous avons [VALEUR + (LABEL + PATTERN)] */ - - /* On bouge le LABEL */ - t = e->child->child->next->child; - t->father = e->child; - t->prev = NULL; - u = t->next; - t->next = e->child->child->next; - - /* On bouge la VALEUR */ - t = e->child->child; - t->father = t->next; - t->next = u; - t->prev = NULL; - - /* On rétablit l'arbre correct */ - e->child->child = u->prev; - e->child->child->next->prev = e->child->child; - e->child->child->next->child = t; - u->prev = t; - } - default: - /* Bon si l'on est ici, c'est pas bon signe non plus... */ - exception(1, _("Expression too complex")); - break; - } - } else { - /* Bon si l'on est ici, c'est que l'on est dans le cas [PATTERN + VALUE] - ou [VALUE + PATTERN]. On se met sur la forme [VALUE + PATTERN] */ - if (e->child->child->e_subtype == E_PATTERN) { - t = e->child->child; - e->child->child = t->next; - t->next->prev = NULL; - t->next->next = t; - t->prev = t->next; - t->next = NULL; - } - } + } + if ((t = e->child->child->next)->e_subtype == E_OPERATION) { + /* On est sous la forme [A +- (B +- C)], on vérifie l'intégrité de la sous opération. + Cela ne peut pas être [A - (B +- C)] car il faut que (B +- C) soit une valeur + immediate et donc aurait été calculé avant. */ + if (e->child->op == OP_MOINS) { + exception(1, _("Address type not supported")); + } + switch (e->child->child->e_subtype) { + /* quoique similiares, les trois cas suivant nécessitent trois traitements + différents */ + case E_LABEL: + /* On a donc [LABEL + (B +- C)], on va vérifier si C n'est pas une PATTERN, + et si c'est le cas, il ne faut pas que ce soit - C. Sinon nous ne devons + pas avoir de labels pour B ou C */ + + if ( + (e->child->child->next->child->next->e_subtype == + E_PATTERN) + && (e->child->child->next->op == OP_MOINS)) { + exception(1, _("Address type not supported")); } - /* Bon si on arrive ici sain et sauf, c'est que l'expression est sous la forme - canonique: [LABEL + A] avec A quelque chose de valide. On va donc transformer - l'expression en LABEL[A] */ - - t = e->child; - e->child = t->child; - e->child->father = e; - e->child->next->father = e; - if (t->op == OP_MOINS) { - /* On est sous la forme [LABEL - IMM], on met LABEL[-A] */ - e->child->next->avalue = -e->child->next->avalue; + + if (e->child->child->next->child->e_subtype == E_LABEL) { + exception(1, _("Address addition not supported")); + } + + /* Si B et C sont du même type, on jette l'éponge... */ + + if (e->child->child->next->child->e_subtype == + e->child->child->next->child->next->e_subtype) { + exception(1, + _("Expression too complex or invalid")); + } + + /* Ok, si notre expression a réussi à franchir toutes ses étapes, c'est qu'elle + est correcte.... Enfin j'espère :) Je vais modifier l'expression de sorte a ce + qu'elle ait la forme [LABEL + (VALEUR +- PATTERN)] */ + + if ( + (t = + e->child->child->next->child)->e_subtype == + E_PATTERN) { + t->prev = t->next; + t->next = NULL; + t->prev->next = t; + t->prev->prev = NULL; + t->father->child = t->prev; + if (t->father->op == OP_MOINS) { + t->father->op = OP_PLUS; + t->prev->avalue = -t->prev->avalue; + } } - free(t); - e->op = OP_DECAL; - break; /* case OPERATION */ - case E_LABEL: - /* On est sous la forme [LABEL], on va mettre sous la forme LABEL[0] */ - t = (expression_t *) Emalloc(sizeof(expression_t)); - t->e_type = t->e_subtype = E_VALUE; - t->avalue = 0; - t->symbol = NULL; - t->pattern = NULL; - t->next = t->child = NULL; - t->prev = e->child; - e->child->next = t; - t->father = e; - e->op = OP_DECAL; break; + case E_PATTERN: + /* On a donc [PATTERN + (B +- C)], on va vérifier si C n'est pas un LABEL, + et si c'est le cas, il ne faut pas que ce soit - C. Sinon nous ne devons + pas avoir de patterns pour B ou C. */ + + if ( + (e->child->child->next->child->next->e_subtype == + E_LABEL) + && (e->child->child->next->op == OP_MOINS)) { + exception(1, _("Address type not supported")); + } + + if (e->child->child->next->child->e_subtype == + E_PATTERN) { + exception(1, _("Expression invalid")); + } + + /* Si B et C sont du même type, on jette l'éponge... */ + + if (e->child->child->next->child->e_subtype == + e->child->child->next->child->next->e_subtype) { + exception(1, + _("Expression too complex or invalid")); + } + + /* Ok, si notre expression a réussi à franchir toutes ses étapes, c'est qu'elle + est correcte.... Enfin j'espère :) Je vais modifier l'expression de sorte a ce + qu'elle ait la forme [LABEL + (VALEUR +- PATTERN)] */ + + /* Pas mal de boulot ici... */ + if ( + (t = + e->child->child->next->child)->e_subtype == + E_LABEL) { + /* Nous avons [PATTERN + (LABEL +- VALEUR)], on inverse LABEL et VALEUR */ + t->prev = t->next; + t->next = NULL; + t->prev->next = t; + t->prev->prev = NULL; + t->father->child = t->prev; + if (t->father->op == OP_MOINS) { + t->father->op = OP_PLUS; + t->prev->avalue = -t->prev->avalue; + } + } + + /* Nous avons [PATTERN + (VALEUR + LABEL)] */ + + /* On bouge le LABEL */ + t = e->child->child->next->child->next; + t->father = e->child; + t->prev = NULL; + t->next = e->child->child->next; + + /* On bouge le PATTERN */ + t = e->child->child; + t->father = t->next; + t->prev = t->next->child; + t->next = NULL; + + /* On rétablit l'arbre correct */ + e->child->child = t->prev->next; + e->child->child->next->prev = e->child->child; + t->prev->next = t; + break; + case E_VALUE: + /* On a donc [VALUE + (B +- C)], si B ou C sont des valeurs, on intervient. */ + + if (e->child->child->next->child->e_subtype == E_VALUE) { + if (e->child->child->next->op == OP_MOINS) { + exception(1, _("Expression invalid")); + } + e->child->child->avalue += + e->child->child->next->child->avalue; + t = e->child->child->next; + e->child->child->next = t->child->next; + free_expr(t); + /* Magie, on a attérit sur le cas [VALUE + qquechose] ... + On va pas s'embeter, on va réévaluer la chose :) */ + evaluate(e); + return; + } else if (e->child->child->next->child-> + next->e_subtype == E_VALUE) { + /* Quasiment la même chose qu'au dessus... */ + if (e->child->child->next->op == OP_MOINS) { + e->child->child->avalue + -= e->child->child->next->child->avalue; + } else { + e->child->child->avalue + += e->child->child->next->child->avalue; + } + t = e->child->child->next; + e->child->child->next = t->child; + free_expr(t); + evaluate(e); + return; + } else { + /* Si B et C sont du même type, on jette l'éponge... */ + + if (e->child->child->next->child->e_subtype == + e->child->child->next->child->next->e_subtype) { + exception(1, + _ + ("Expression too complex or invalid")); + } + + /* Ok, si notre expression a réussi à franchir toutes ses étapes, c'est qu'elle + est correcte.... Enfin j'espère :) Je vais modifier l'expression de sorte a ce + qu'elle ait la forme [LABEL + (VALEUR +- PATTERN)] */ + + /* Pas mal de boulot ici... */ + if ( + (t = + e->child->child->next->child)->e_subtype == + E_PATTERN) { + /* Nous avons [VALEUR + (PATTERN + LABEL)], on inverse LABEL et PATTERN */ + t->prev = t->next; + t->next = NULL; + t->prev->next = t; + t->prev->prev = NULL; + t->father->child = t->prev; + if (t->father->op == OP_MOINS) { + t->father->op = OP_PLUS; + t->prev->avalue = -t->prev->avalue; + } + } + + /* Nous avons [VALEUR + (LABEL + PATTERN)] */ + + /* On bouge le LABEL */ + t = e->child->child->next->child; + t->father = e->child; + t->prev = NULL; + u = t->next; + t->next = e->child->child->next; + + /* On bouge la VALEUR */ + t = e->child->child; + t->father = t->next; + t->next = u; + t->prev = NULL; + + /* On rétablit l'arbre correct */ + e->child->child = u->prev; + e->child->child->next->prev = e->child->child; + e->child->child->next->child = t; + u->prev = t; + } + default: + /* Bon si l'on est ici, c'est pas bon signe non plus... */ + exception(1, _("Expression too complex")); + break; + } + } else { + /* Bon si l'on est ici, c'est que l'on est dans le cas [PATTERN + VALUE] + ou [VALUE + PATTERN]. On se met sur la forme [VALUE + PATTERN] */ + if (e->child->child->e_subtype == E_PATTERN) { + t = e->child->child; + e->child->child = t->next; + t->next->prev = NULL; + t->next->next = t; + t->prev = t->next; + t->next = NULL; + } } - break; + } + /* Bon si on arrive ici sain et sauf, c'est que l'expression est sous la forme + canonique: [LABEL + A] avec A quelque chose de valide. On va donc transformer + l'expression en LABEL[A] */ + + t = e->child; + e->child = t->child; + e->child->father = e; + e->child->next->father = e; + if (t->op == OP_MOINS) { + /* On est sous la forme [LABEL - IMM], on met LABEL[-A] */ + e->child->next->avalue = -e->child->next->avalue; + } + free(t); + e->op = OP_DECAL; + break; /* case OPERATION */ + case E_LABEL: + /* On est sous la forme [LABEL], on va mettre sous la forme LABEL[0] */ + t = (expression_t *) Emalloc(sizeof(expression_t)); + t->e_type = t->e_subtype = E_VALUE; + t->avalue = 0; + t->symbol = NULL; + t->pattern = NULL; + t->next = t->child = NULL; + t->prev = e->child; + e->child->next = t; + t->father = e; + e->op = OP_DECAL; + break; } + break; + } } /* Cette fonction est appelée depuis le parseur. Elle ajit sur la pile en effectuant une opération */ void act_pile(int o) { - expression_t *e, *e1, *e2; - int i, nbargs; - - e = Emalloc(sizeof(expression_t)); - e->pattern = NULL; - e->op = o; - e->avalue = 0; - e->symbol = NULL; - e->e_type = E_OPERATION; - e->e_subtype = E_OPERATION; - e->next = e->prev = e->father = e->child = NULL; - switch (o) { - case OP_NEST: - exception(1, _("Something wrong, nested operator called...")); - break; - case OP_PLUS: - case OP_MOINS: - case OP_MUL: - case OP_DIV: - case OP_MOD: - case OP_DECAL: - e1 = e_current->prev; - e2 = e_current; - if (e_current->prev->prev) { - e_current->prev->prev->next = NULL; - e_current = e1->prev; - } else { - e_current = NULL; - } - e1->prev = NULL; - e2->next = NULL; - e->child = e1; - e1->father = e2->father = e; - break; - case OP_PLUS_UNARY: - case OP_MOINS_UNARY: - case OP_DIRECT: - e1 = e_current; - if (e1->prev) { - e_current->prev->next = NULL; - e_current = e1->prev; - } else { - e_current = NULL; - } + expression_t *e, *e1, *e2; + int i, nbargs; + + e = Emalloc(sizeof(expression_t)); + e->pattern = NULL; + e->op = o; + e->avalue = 0; + e->symbol = NULL; + e->e_type = E_OPERATION; + e->e_subtype = E_OPERATION; + e->next = e->prev = e->father = e->child = NULL; + switch (o) { + case OP_NEST: + exception(1, _("Something wrong, nested operator called...")); + break; + case OP_PLUS: + case OP_MOINS: + case OP_MUL: + case OP_DIV: + case OP_MOD: + case OP_DECAL: + e1 = e_current->prev; + e2 = e_current; + if (e_current->prev->prev) { + e_current->prev->prev->next = NULL; + e_current = e1->prev; + } else { + e_current = NULL; + } + e1->prev = NULL; + e2->next = NULL; + e->child = e1; + e1->father = e2->father = e; + break; + case OP_PLUS_UNARY: + case OP_MOINS_UNARY: + case OP_DIRECT: + e1 = e_current; + if (e1->prev) { + e_current->prev->next = NULL; + e_current = e1->prev; + } else { + e_current = NULL; + } + e1->prev = NULL; + e->child = e1; + e1->father = e; + break; + case OP_FUNC_CALL: + e1 = e_current; + e_current->prev->next = NULL; + e_current = e1->prev; + nbargs = e1->avalue; + free(e1); + e1 = e2 = NULL; + for (i = 0; i < nbargs; i++) { + e1 = e_current; + e_current->prev->next = NULL; + e_current = e1->prev; + if (e2) { + e2->next = e1; + e2->prev = NULL; + e1->prev = e2; + } else { e1->prev = NULL; - e->child = e1; - e1->father = e; - break; - case OP_FUNC_CALL: - e1 = e_current; - e_current->prev->next = NULL; - e_current = e1->prev; - nbargs = e1->avalue; - free(e1); - e1 = e2 = NULL; - for (i = 0; i < nbargs; i++) { - e1 = e_current; - e_current->prev->next = NULL; - e_current = e1->prev; - if (e2) { - e2->next = e1; - e2->prev = NULL; - e1->prev = e2; - } else { - e1->prev = NULL; - } - e2 = e1; - } - - e2 = e_current; - if (e2->prev) { - e_current->prev->next = NULL; - e_current = e1->prev; - } - e->symbol = e2->symbol; - free(e2); - e->avalue = nbargs; - for (e2 = e1; e2; e2 = e2->next) { - e2->father = e; - } - e->child = e1; - break; - case OP_LPAREN: - exception(1, _("Something wrong, lparenthesis operator called...")); - break; - default: - exception(1, _("Something wrong, should never got here...")); - break; + } + e2 = e1; } - if (e_current) { - e_current->next = e; - e->prev = e_current; + e2 = e_current; + if (e2->prev) { + e_current->prev->next = NULL; + e_current = e1->prev; } - - e_current = e; - evaluate(e_current); + e->symbol = e2->symbol; + free(e2); + e->avalue = nbargs; + for (e2 = e1; e2; e2 = e2->next) { + e2->father = e; + } + e->child = e1; + break; + case OP_LPAREN: + exception(1, _("Something wrong, lparenthesis operator called...")); + break; + default: + exception(1, _("Something wrong, should never got here...")); + break; + } + + if (e_current) { + e_current->next = e; + e->prev = e_current; + } + + e_current = e; + evaluate(e_current); } /* Fonction d'initialisation de l'assembleur */ int assembler_init(void) { - Initialise(&defines); - if (!defines) - return 1; - Initialise(&labels); - if (!defines) - return 1; - if (!(p_text = text = (bytestream_t *) malloc(sizeof(bytestream_t)))) - return 1; - if (!(p_data = data = (bytestream_t *) malloc(sizeof(bytestream_t)))) - return 1; - if (!(p_bss = bss = (bytestream_t *) malloc(sizeof(bytestream_t)))) - return 1; - - text->next = data->next = bss->next = NULL; - text->size = data->size = bss->size = 0; - text->Label = data->Label = bss->Label = NULL; - - return 0; + Initialise(&defines); + if (!defines) + return 1; + Initialise(&labels); + if (!defines) + return 1; + if (!(p_text = text = (bytestream_t *) malloc(sizeof(bytestream_t)))) + return 1; + if (!(p_data = data = (bytestream_t *) malloc(sizeof(bytestream_t)))) + return 1; + if (!(p_bss = bss = (bytestream_t *) malloc(sizeof(bytestream_t)))) + return 1; + + text->next = data->next = bss->next = NULL; + text->size = data->size = bss->size = 0; + text->Label = data->Label = bss->Label = NULL; + + return 0; } /* Nous vérifions si l'expression peut correspondre à une pattern "complexe" (composée) */ static void super_pattern(pattern_t * patterns, expression_t * e) { - int i; - - if (!(e->e_subtype == E_OPERATION)) - return; - if (!((e->op == OP_DECAL) || (e->op == OP_DIRECT))) - return; - - for (patterns = patterns->next; patterns; patterns = patterns->next) { - for (i = 0; i < patterns->nbr; i++) { - if (!patterns->expr[i]->name) { - if (e->e_subtype == E_OPERATION) { - if (e->op == OP_DIRECT) { - if (!patterns->expr[i]->left) { - e->pattern = patterns; - e->index = i; - return; - } - } else { - if (patterns->expr[i]->left) { - e->pattern = patterns; - e->index = i; - return; - } - } - } + int i; + + if (!(e->e_subtype == E_OPERATION)) + return; + if (!((e->op == OP_DECAL) || (e->op == OP_DIRECT))) + return; + + for (patterns = patterns->next; patterns; patterns = patterns->next) { + for (i = 0; i < patterns->nbr; i++) { + if (!patterns->expr[i]->name) { + if (e->e_subtype == E_OPERATION) { + if (e->op == OP_DIRECT) { + if (!patterns->expr[i]->left) { + e->pattern = patterns; + e->index = i; + return; + } + } else { + if (patterns->expr[i]->left) { + e->pattern = patterns; + e->index = i; + return; + } + } + } + } else { + if (patterns->expr[i]->string) { + if (patterns->expr[i]->string[0] == 'O') { + if (e->e_subtype == E_OPERATION) { + if (((e->op == OP_DIRECT) + && (e->child->e_subtype == E_VALUE)) + || ((e->op == OP_DECAL) + && (e->child->next->e_subtype == E_VALUE))) { + e->pattern = patterns; + e->index = i; + return; + } } else { - if (patterns->expr[i]->string) { - if (patterns->expr[i]->string[0] == 'O') { - if (e->e_subtype == E_OPERATION) { - if (((e->op == OP_DIRECT) && (e->child->e_subtype == E_VALUE)) - || ((e->op == OP_DECAL) - && (e->child->next->e_subtype == E_VALUE))) { - e->pattern = patterns; - e->index = i; - return; - } - } else { - if (e->e_subtype == E_LABEL) { - e->pattern = patterns; - e->index = i; - return; - } - } - } - } + if (e->e_subtype == E_LABEL) { + e->pattern = patterns; + e->index = i; + return; + } } + } } + } } + } } /* Ces deux fonctions récursives croisées nous servent à déterminer su une expression est un label */ @@ -1191,556 +1234,614 @@ static int islabel(expression_t *); static int islabel2(expression_t * e) { - if (islabel(e)) - return 1; - if (e->next) { - return islabel2(e->next); - } - return 0; + if (islabel(e)) + return 1; + if (e->next) { + return islabel2(e->next); + } + return 0; } static int islabel(expression_t * e) { - if (e->e_subtype == E_LABEL) - return 1; - if (e->child) { - return islabel2(e->child); - } - return 0; + if (e->e_subtype == E_LABEL) + return 1; + if (e->child) { + return islabel2(e->child); + } + return 0; } /* Cette fonction cherche une instruction pouvant correspondre à l'expression. */ -static instruct_t *e_match_i(phon_t * phons, instruct_t * instructs, expression_t * e) +static instruct_t *e_match_i(phon_t * phons, instruct_t * instructs, + expression_t * e) { - char *stringtolook = e->symbol; - expression_t *t; - int i, go_out; - - for (t = e->next; t; t = t->next) { - if (!t->pattern) - super_pattern(patterns, t); - } - - for (phons = phons->next; phons; phons = phons->next) { - if (!strcasecmp(phons->p1, stringtolook)) { - stringtolook = phons->p2; - break; - } + char *stringtolook = e->symbol; + expression_t *t; + int i, go_out; + + for (t = e->next; t; t = t->next) { + if (!t->pattern) + super_pattern(patterns, t); + } + + for (phons = phons->next; phons; phons = phons->next) { + if (!strcasecmp(phons->p1, stringtolook)) { + stringtolook = phons->p2; + break; } + } #ifdef DEBUG - debug_print_expression(e); + debug_print_expression(e); #endif - for (instructs = instructs->next; instructs; instructs = instructs->next) { - t = e; - go_out = 0; - for (i = 0; (!go_out) && (i < instructs->nbexplicit); i++) { - if (!instructs->strings[i]) { - if (strcasecmp(instructs->names[i], i ? t->symbol : stringtolook)) { - go_out = 1; - } - } else { - switch (instructs->strings[i][0]) { - case 'P': - if (!t->pattern) { - go_out = 1; - } else { - if (strcasecmp(instructs->strings[i] + 1, t->pattern->name)) - go_out = 1; - } - break; - case 'C': - if ((t->e_subtype != E_VALUE) && (t->e_subtype != E_LABEL)) { - go_out = 1; - } - - if ((t->e_subtype == E_OPERATION) - && ((t->op == OP_PLUS) || (t->op == OP_MOINS))) { - if (((t->child->e_subtype == E_LABEL) - && (t->child->next->e_subtype == E_VALUE)) - || ((t->child->e_subtype == E_VALUE) - && (t->child->next->e_subtype == E_LABEL))) { - go_out = 0; - } - } - - if ((t->e_subtype == E_OPERATION) && (t->op == OP_FUNC_CALL)) { - go_out = 0; - } - - break; - case 'O': - /* C'est le cas le plus simple ou presque, il suffit de tout prendre */ - break; - default: - exception(1, _("Unknow predefined string into the meta language")); - } + for (instructs = instructs->next; instructs; instructs = instructs->next) { + t = e; + go_out = 0; + for (i = 0; (!go_out) && (i < instructs->nbexplicit); i++) { + if (!instructs->strings[i]) { + if (strcasecmp + (instructs->names[i], i ? t->symbol : stringtolook)) { + go_out = 1; + } + } else { + switch (instructs->strings[i][0]) { + case 'P': + if (!t->pattern) { + go_out = 1; + } else { + if (strcasecmp + (instructs->strings[i] + 1, + t->pattern->name)) go_out = 1; + } + break; + case 'C': + if ((t->e_subtype != E_VALUE) + && (t->e_subtype != E_LABEL)) { + go_out = 1; + } + + if ((t->e_subtype == E_OPERATION) + && ((t->op == OP_PLUS) + || (t->op == OP_MOINS))) { + if (((t->child->e_subtype == E_LABEL) + && (t->child->next->e_subtype == E_VALUE)) + || ((t->child->e_subtype == E_VALUE) + && (t->child->next->e_subtype == E_LABEL))) { + go_out = 0; } + } - if (!(t = t->next) && ((i + 1) < instructs->nbexplicit)) { - go_out = 1; - } - } + if ((t->e_subtype == E_OPERATION) + && (t->op == OP_FUNC_CALL)) { + go_out = 0; + } - if (!go_out && !t) { - break; + break; + case 'O': + /* C'est le cas le plus simple ou presque, il suffit de tout prendre */ + break; + default: + exception(1, + _ + ("Unknow predefined string into the meta language")); } + } + + if (!(t = t->next) && ((i + 1) < instructs->nbexplicit)) { + go_out = 1; + } } + + if (!go_out && !t) { + break; + } + } #ifdef DEBUG - if (instructs) { - fprintf(stderr, " o Instruction contenant %i champs explicites et %i champs implicites.\n", instructs->nbexplicit, instructs->nbimplicit); - fprintf(stderr, " => Champs explicites.\n"); - for (i = 0; i < instructs->nbexplicit; i++) { - fprintf(stderr, " + %s <= %s (type %s)\n", - instructs->names[i], instructs->strings[i] ? instructs->strings[i] : "Pas de chaîne associée", instructs->etypes[i] ? "prédéfinit" : "direct"); - } - fprintf(stderr, " => Champs implicites.\n"); - for (i = 0; i < instructs->nbimplicit; i++) { - switch (instructs->itypes[i]) { - case 0: - fprintf(stderr, " + %s <= %s (type direct)\n", instructs->implicits[i], instructs->istrings[i]); - break; - case 1: - fprintf(stderr, " + %s <= %s (type prédéfinit)\n", instructs->implicits[i], instructs->istrings[i]); - break; - case 2: - fprintf(stderr, " + %s <= %i (type valeur)\n", instructs->implicits[i], instructs->ivalues[i]); - break; - } - } + if (instructs) { + fprintf(stderr, + " o Instruction contenant %i champs explicites et %i champs implicites.\n", + instructs->nbexplicit, instructs->nbimplicit); + fprintf(stderr, " => Champs explicites.\n"); + for (i = 0; i < instructs->nbexplicit; i++) { + fprintf(stderr, " + %s <= %s (type %s)\n", + instructs->names[i], + instructs-> + strings[i] ? instructs->strings[i] : + "Pas de chaîne associée", + instructs->etypes[i] ? "prédéfinit" : "direct"); + } + fprintf(stderr, " => Champs implicites.\n"); + for (i = 0; i < instructs->nbimplicit; i++) { + switch (instructs->itypes[i]) { + case 0: + fprintf(stderr, + " + %s <= %s (type direct)\n", + instructs->implicits[i], instructs->istrings[i]); + break; + case 1: + fprintf(stderr, + " + %s <= %s (type prédéfinit)\n", + instructs->implicits[i], instructs->istrings[i]); + break; + case 2: + fprintf(stderr, + " + %s <= %i (type valeur)\n", + instructs->implicits[i], instructs->ivalues[i]); + break; + } } + } #endif - return instructs; + return instructs; } /* Cette fonction va évaluer une pattern et rajouter les variable dans la table de hachage correspondante */ static void evaluate_pattern(_TableauVariable * it, expression_t * e) { - metaexpr_t *m, *n; - expression_t *t; - int tv; - - if (!e->pattern) { - exception(1, _("Pattern not matching...")); - } - - m = e->pattern->expr[e->index]; - if (m->name) { + metaexpr_t *m, *n; + expression_t *t; + int tv; + + if (!e->pattern) { + exception(1, _("Pattern not matching...")); + } + + m = e->pattern->expr[e->index]; + if (m->name) { + if (m->string) { + if (m->type) { + if (strcmp(m->name, "I")) { + exception(1, + _("Unknow constant type in the meta language")); + } + if (e->e_subtype == E_VALUE) { + pushdword(e->avalue, NULL); + } else { + pushdword(0, e); + } + } else { if (m->string) { - if (m->type) { - if (strcmp(m->name, "I")) { - exception(1, _("Unknow constant type in the meta language")); - } - if (e->e_subtype == E_VALUE) { - pushdword(e->avalue, NULL); - } else { - pushdword(0, e); - } - } else { - if (m->string) { - if (m->string[0] != 'P') { - exception(1, _("Error in the metalanguage (pattern should be here if not a constant type)")); - } - t = (expression_t *) Emalloc(sizeof(expression_t)); - t->next = t->child = t->prev = t->father = NULL; - t->e_type = t->e_subtype = E_VALUE; - t->avalue = e->index; - t->symbol = NULL; - t->pattern = NULL; - InsererVarDansTab(it, CreerElement(m->name, t)); - } - } + if (m->string[0] != 'P') { + exception(1, + _ + ("Error in the metalanguage (pattern should be here if not a constant type)")); + } + t = (expression_t *) + Emalloc(sizeof(expression_t)); + t->next = t->child = t->prev = t->father = NULL; + t->e_type = t->e_subtype = E_VALUE; + t->avalue = e->index; + t->symbol = NULL; + t->pattern = NULL; + InsererVarDansTab(it, CreerElement(m->name, t)); } - } else { - n = m; - if (m->left) { /* Binaire */ - m = m->left; - if (m->string) { - if (m->type) { - if (strcmp(m->name, "I") || strcmp(m->string, "O")) { - exception(1, _("Unknow constant type in the meta language")); - } - tv = 0; - if (e->child->next->e_subtype == E_VALUE) { - tv = e->child->next->avalue; - } - if ((e->child->next->e_subtype == E_OPERATION) - && (e->child->next->child->e_subtype == E_VALUE)) { - tv = e->child->next->child->avalue; - } - pushdword(tv, e->child); - } else { - exception(1, _("Logical error in meta language")); - } + } + } + } else { + n = m; + if (m->left) { /* Binaire */ + m = m->left; + if (m->string) { + if (m->type) { + if (strcmp(m->name, "I") + || strcmp(m->string, "O")) { + exception(1, + _ + ("Unknow constant type in the meta language")); + } + tv = 0; + if (e->child->next->e_subtype == E_VALUE) { + tv = e->child->next->avalue; + } + if ((e->child->next->e_subtype == E_OPERATION) + && (e->child->next->child->e_subtype == E_VALUE)) { + tv = e->child->next->child->avalue; + } + pushdword(tv, e->child); + } else { + exception(1, _("Logical error in meta language")); + } + } + m = n; + m = m->right; + if (m->string) { + if (m->type) { + } else { + if (m->string) { + if (m->string[0] != 'P') { + exception(1, + _ + ("Error in the metalanguage (pattern should be here if not a constant type)")); } - m = n; - m = m->right; - if (m->string) { - if (m->type) { - } else { - if (m->string) { - if (m->string[0] != 'P') { - exception(1, _("Error in the metalanguage (pattern should be here if not a constant type)")); - } - t = (expression_t *) Emalloc(sizeof(expression_t)); - t->next = t->child = t->prev = t->father = NULL; - t->e_type = t->e_subtype = E_VALUE; - t->pattern = NULL; - if (e->child->next->e_subtype == E_PATTERN) { - t->avalue = e->child->next->index; - } else { - t->avalue = e->child->next->child->next->index; - } - t->symbol = NULL; - InsererVarDansTab(it, CreerElement(m->name, t)); - } else { - exception(1, _("Logical error in meta language")); - } - } + t = (expression_t *) + Emalloc(sizeof(expression_t)); + t->next = t->child = t->prev = t->father = NULL; + t->e_type = t->e_subtype = E_VALUE; + t->pattern = NULL; + if (e->child->next->e_subtype == E_PATTERN) { + t->avalue = e->child->next->index; + } else { + t->avalue = e->child->next->child->next->index; } - } else { /* Unaire */ - m = m->right; - if (m->string) { - if (m->type) { - exception(1, _("Logical error in meta language")); - } else { - if (m->string) { - if (m->string[0] != 'P') { - exception(1, _("Error in the metalanguage (pattern should be here if not a constant type)")); - } - t = (expression_t *) Emalloc(sizeof(expression_t)); - t->next = t->child = t->prev = t->father = NULL; - t->e_type = t->e_subtype = E_VALUE; - t->avalue = e->child->index; - t->symbol = NULL; - t->pattern = NULL; - InsererVarDansTab(it, CreerElement(m->name, t)); - } - } + t->symbol = NULL; + InsererVarDansTab(it, CreerElement(m->name, t)); + } else { + exception(1, _("Logical error in meta language")); + } + } + } + } else { /* Unaire */ + m = m->right; + if (m->string) { + if (m->type) { + exception(1, _("Logical error in meta language")); + } else { + if (m->string) { + if (m->string[0] != 'P') { + exception(1, + _ + ("Error in the metalanguage (pattern should be here if not a constant type)")); } + t = (expression_t *) + Emalloc(sizeof(expression_t)); + t->next = t->child = t->prev = t->father = NULL; + t->e_type = t->e_subtype = E_VALUE; + t->avalue = e->child->index; + t->symbol = NULL; + t->pattern = NULL; + InsererVarDansTab(it, CreerElement(m->name, t)); + } } + } } + } } /* Cette fonction va évaluer un champ et en renvoyer la valeur, à l'aide de la table de hachage passée en argument */ static int evaluate_field(_TableauVariable it, char *field, field_t * fields) { - int i, r, e, n; - char trouve; - expression_t *t; + int i, r, e, n; + char trouve; + expression_t *t; - for (fields = fields->next; fields; fields = fields->next) { - if (!strcmp(field + 1, fields->name)) { - break; - } + for (fields = fields->next; fields; fields = fields->next) { + if (!strcmp(field + 1, fields->name)) { + break; } - if (!(fields)) { - exception(1, _("Unknow field in metalanguage")); + } + if (!(fields)) { + exception(1, _("Unknow field in metalanguage")); + } + + r = 0; + n = 0; + for (i = 0; i < fields->nbr; i++) { + t = (expression_t *) NomVarToVar(fields->names[i], it, &trouve); + e = 0; + if (trouve) { + if (t->e_subtype != E_VALUE) { + exception(1, _("Can't evaluate directly expression")); + } + e = t->avalue; } - - r = 0; - n = 0; - for (i = 0; i < fields->nbr; i++) { - t = (expression_t *) NomVarToVar(fields->names[i], it, &trouve); - e = 0; - if (trouve) { - if (t->e_subtype != E_VALUE) { - exception(1, _("Can't evaluate directly expression")); - } - e = t->avalue; - } - n = fields->sizes[i]; - if ((e & ((1 << n) - 1)) != e) { - exception(1, _("Value too large for field")); - } - r = (r << n) | e; + n = fields->sizes[i]; + if ((e & ((1 << n) - 1)) != e) { + exception(1, _("Value too large for field")); } + r = (r << n) | e; + } - return r; + return r; } /* Fonction servant à effectuer une fin de ligne. Force l'évaluation complète de la ligne */ void asm_eol(void) { - instruct_t *instr; - expression_t *t; - int i; - char trouve; - _TableauVariable it; - bytestream_t *pi; - - switch (special) { - case 2: /* Cas de #define */ - InsererVarDansTab(&defines, CreerElement(defined, e_line)); - free(defined); - break; - case 1: /* Cas des directives . */ - case 3: /* Cas de #undef */ - case 4: /* Cas de #include */ - /* Rien à faire ici... tout est déjà fait dans la routine push_pile() */ - break; - case 0: /* Cas normal */ - /* C'est ici la bonne histoire... Il faut reconnaitre l'instruction */ + instruct_t *instr; + expression_t *t; + int i; + char trouve; + _TableauVariable it; + bytestream_t *pi; + + switch (special) { + case 2: /* Cas de #define */ + InsererVarDansTab(&defines, CreerElement(defined, e_line)); + free(defined); + break; + case 1: /* Cas des directives . */ + case 3: /* Cas de #undef */ + case 4: /* Cas de #include */ + /* Rien à faire ici... tout est déjà fait dans la routine push_pile() */ + break; + case 0: /* Cas normal */ + /* C'est ici la bonne histoire... Il faut reconnaitre l'instruction */ + e_current = e_line; + if (!(e_current)) + break; + /* Est-ce que le premier mot est un label terminant par ':' ? */ + if (e_current->e_subtype == E_LABEL) { + if (e_current->symbol[strlen(e_current->symbol) - 1] == ':') { + pushlabel(e_current->symbol); + e_line = e_current->next; + e_current->next = NULL; + free_expr(e_current); e_current = e_line; - if (!(e_current)) - break; - /* Est-ce que le premier mot est un label terminant par ':' ? */ - if (e_current->e_subtype == E_LABEL) { - if (e_current->symbol[strlen(e_current->symbol) - 1] == ':') { - pushlabel(e_current->symbol); - e_line = e_current->next; - e_current->next = NULL; - free_expr(e_current); - e_current = e_line; - } else { - /* C'est peut-être une instruction spéciale */ - if ((e_current->next) && (e_current->next->e_subtype == E_INTERNAL)) { - pushlabel(e_current->symbol); - e_line = e_current->next; - e_current->next = NULL; - free_expr(e_current); - e_current = e_line; - } else { - exception(1, _("Unknow instruction")); - } - } + } else { + /* C'est peut-être une instruction spéciale */ + if ((e_current->next) + && (e_current->next->e_subtype == E_INTERNAL)) { + pushlabel(e_current->symbol); + e_line = e_current->next; + e_current->next = NULL; + free_expr(e_current); + e_current = e_line; + } else { + exception(1, _("Unknow instruction")); } + } + } - switch (e_current->e_subtype) { - case E_INTERNAL: - switch (e_current->op) { - case 1: /* DB */ - case 2: /* DW */ - case 3: /* DD */ - do { - e_line = e_current->next; - e_current->next = NULL; - free_expr(e_current); - e_current = e_line; - if (!e_current) - break; - switch (e_current->e_subtype) { - case E_VALUE: - pushdword(e_current->avalue, NULL); - break; - case E_STRING: - if (!strcmp(e_current->symbol, "?")) { - exception(1, _("Unknow constant")); - } - pushuninit(1); - break; - case E_LABEL: - case E_OPERATION: - pushdword(0, e_current); - break; - default: - exception(1, _("Bad constant for an immediate value")); - } - } while (1); - break; - case 4: /* DS */ - do { - e_line = e_current->next; - e_current->next = NULL; - free_expr(e_current); - e_current = e_line; - if (!e_current) - break; - switch (e_current->e_subtype) { - case E_STRING: - pushstring(e_current->symbol); - break; - default: - exception(1, _("Bad constant for a string")); - } - } while (1); - break; - case 5: /* DR */ - do { - e_line = e_current->next; - e_current->next = NULL; - free_expr(e_current); - e_current = e_line; - if (!e_current) - break; - switch (e_current->e_subtype) { - case E_VALUE: - pushuninit(e_current->avalue); - break; - default: - exception(1, _("Bad array size")); - } - } while (1); - break; + switch (e_current->e_subtype) { + case E_INTERNAL: + switch (e_current->op) { + case 1: /* DB */ + case 2: /* DW */ + case 3: /* DD */ + do { + e_line = e_current->next; + e_current->next = NULL; + free_expr(e_current); + e_current = e_line; + if (!e_current) + break; + switch (e_current->e_subtype) { + case E_VALUE: + pushdword(e_current->avalue, NULL); + break; + case E_STRING: + if (!strcmp(e_current->symbol, "?")) { + exception(1, _("Unknow constant")); } + pushuninit(1); + break; + case E_LABEL: + case E_OPERATION: + pushdword(0, e_current); + break; + default: + exception(1, _("Bad constant for an immediate value")); + } + } while (1); + break; + case 4: /* DS */ + do { + e_line = e_current->next; + e_current->next = NULL; + free_expr(e_current); + e_current = e_line; + if (!e_current) + break; + switch (e_current->e_subtype) { + case E_STRING: + pushstring(e_current->symbol); break; - case E_INSTRUCT: - if (!e_current) - break; - if (segment != SEG_TEXT) { - exception(1, _("You can only have an instruction into a .text segment")); + default: + exception(1, _("Bad constant for a string")); + } + } while (1); + break; + case 5: /* DR */ + do { + e_line = e_current->next; + e_current->next = NULL; + free_expr(e_current); + e_current = e_line; + if (!e_current) + break; + switch (e_current->e_subtype) { + case E_VALUE: + pushuninit(e_current->avalue); + break; + default: + exception(1, _("Bad array size")); + } + } while (1); + break; + } + break; + case E_INSTRUCT: + if (!e_current) + break; + if (segment != SEG_TEXT) { + exception(1, + _ + ("You can only have an instruction into a .text segment")); + } + if (!(instr = e_match_i(phons, instructs, e_current))) { + exception(1, _("Unmatched instruction")); + } + + /* Operation cruciale: nous avons l'instruction qui correspond le mieux à notre + expression, on va tenter de l'évaluer */ + + pi = pushuninit(1); + + Initialise(&it); + for (i = 0; i < instr->nbexplicit; i++) { + if (instr->strings[i]) { + switch (instr->strings[i][0]) { + case 'C': + if (instr->etypes[i]) { + if (!strcmp(instr->names[i], "I")) { + if (e_current->e_subtype == E_VALUE) { + pushdword(e_current->avalue, 0); + } else { + pushdword(0, e_current); + } + } else { + exception(1, + _ + ("Unknow constant type in the meta language")); + } + } else { + InsererVarDansTab(&it, + CreerElement + (instr->names[i], e_current)); } - if (!(instr = e_match_i(phons, instructs, e_current))) { - exception(1, _("Unmatched instruction")); + break; + case 'O': + if (instr->etypes) { + if (!strcmp(instr->names[i], "I")) { + if (e_current->e_subtype == E_VALUE) { + pushdword(e_current->avalue, 0); + } else { + pushdword(0, e_current); + } + } else { + exception(1, + _ + ("Unknow constant type in the meta language")); + } } - - /* Operation cruciale: nous avons l'instruction qui correspond le mieux à notre - expression, on va tenter de l'évaluer */ - - pi = pushuninit(1); - - Initialise(&it); - for (i = 0; i < instr->nbexplicit; i++) { - if (instr->strings[i]) { - switch (instr->strings[i][0]) { - case 'C': - if (instr->etypes[i]) { - if (!strcmp(instr->names[i], "I")) { - if (e_current->e_subtype == E_VALUE) { - pushdword(e_current->avalue, 0); - } else { - pushdword(0, e_current); - } - } else { - exception(1, _("Unknow constant type in the meta language")); - } - } else { - InsererVarDansTab(&it, CreerElement(instr->names[i], e_current)); - } - break; - case 'O': - if (instr->etypes) { - if (!strcmp(instr->names[i], "I")) { - if (e_current->e_subtype == E_VALUE) { - pushdword(e_current->avalue, 0); - } else { - pushdword(0, e_current); - } - } else { - exception(1, _("Unknow constant type in the meta language")); - } - } - break; - case 'P': - t = (expression_t *) Emalloc(sizeof(expression_t)); - t->e_type = t->e_subtype = E_VALUE; - t->avalue = e_current->index; - t->child = t->next = NULL; - t->pattern = NULL; - t->symbol = NULL; - InsererVarDansTab(&it, CreerElement(instr->names[i], t)); + break; + case 'P': + t = (expression_t *) + Emalloc(sizeof(expression_t)); + t->e_type = t->e_subtype = E_VALUE; + t->avalue = e_current->index; + t->child = t->next = NULL; + t->pattern = NULL; + t->symbol = NULL; + InsererVarDansTab(&it, + CreerElement(instr->names[i], t)); #ifdef DEBUG - fprintf(stderr, "On a %s qui vaut %i\n", instr->names[i], e_current->index); + fprintf(stderr, + "On a %s qui vaut %i\n", + instr->names[i], e_current->index); #endif - evaluate_pattern(&it, e_current); - break; - default: - exception(1, _("Unknow constant type in the meta language")); - } - } - - e_line = e_current->next; - e_current->next = NULL; - free_expr(e_current); - e_current = e_line; - } + evaluate_pattern(&it, e_current); + break; + default: + exception(1, + _ + ("Unknow constant type in the meta language")); + } + } - for (i = 0; i < instr->nbimplicit; i++) { - switch (instr->itypes[i]) { - case 0: /* type direct */ - t = (expression_t *) NomVarToVar(instr->istrings[i], it, &trouve); - if (!trouve) { - t = (expression_t *) Emalloc(sizeof(expression_t)); - t->e_type = t->e_subtype = E_VALUE; - t->avalue = 0; - t->child = t->next = NULL; - t->pattern = NULL; - t->symbol = NULL; - } + e_line = e_current->next; + e_current->next = NULL; + free_expr(e_current); + e_current = e_line; + } + + for (i = 0; i < instr->nbimplicit; i++) { + switch (instr->itypes[i]) { + case 0: /* type direct */ + t = (expression_t *) + NomVarToVar(instr->istrings[i], it, &trouve); + if (!trouve) { + t = (expression_t *) + Emalloc(sizeof(expression_t)); + t->e_type = t->e_subtype = E_VALUE; + t->avalue = 0; + t->child = t->next = NULL; + t->pattern = NULL; + t->symbol = NULL; + } #ifdef DEBUG - fprintf(stderr, "On a %s qui vaut %i\n", instr->implicits[i], t->avalue); + fprintf(stderr, "On a %s qui vaut %i\n", + instr->implicits[i], t->avalue); #endif - InsererVarDansTab(&it, CreerElement(instr->implicits[i], t)); - break; - case 1: /* type prédéfinit */ - t = (expression_t *) Emalloc(sizeof(expression_t)); - t->e_type = t->e_subtype = E_VALUE; - if (instr->istrings[i][0] != 'F') { - exception(1, _("Logical error in meta language")); - } - t->avalue = evaluate_field(it, instr->istrings[i], fields);; - t->child = t->next = NULL; - t->pattern = NULL; - t->symbol = NULL; + InsererVarDansTab(&it, + CreerElement(instr->implicits[i], t)); + break; + case 1: /* type prédéfinit */ + t = (expression_t *) + Emalloc(sizeof(expression_t)); + t->e_type = t->e_subtype = E_VALUE; + if (instr->istrings[i][0] != 'F') { + exception(1, _("Logical error in meta language")); + } + t->avalue = evaluate_field(it, instr->istrings[i], fields);; + t->child = t->next = NULL; + t->pattern = NULL; + t->symbol = NULL; #ifdef DEBUG - fprintf(stderr, "On a %s qui vaut %i\n", instr->implicits[i], t->avalue); + fprintf(stderr, "On a %s qui vaut %i\n", + instr->implicits[i], t->avalue); #endif - InsererVarDansTab(&it, CreerElement(instr->implicits[i], t)); - break; - case 2: /* type valeur */ - t = (expression_t *) Emalloc(sizeof(expression_t)); - t->e_type = t->e_subtype = E_VALUE; - t->avalue = instr->ivalues[i]; - t->child = t->next = NULL; - t->pattern = NULL; - t->symbol = NULL; + InsererVarDansTab(&it, + CreerElement(instr->implicits[i], t)); + break; + case 2: /* type valeur */ + t = (expression_t *) + Emalloc(sizeof(expression_t)); + t->e_type = t->e_subtype = E_VALUE; + t->avalue = instr->ivalues[i]; + t->child = t->next = NULL; + t->pattern = NULL; + t->symbol = NULL; #ifdef DEBUG - fprintf(stderr, "On a %s qui vaut %i\n", instr->implicits[i], t->avalue); + fprintf(stderr, "On a %s qui vaut %i\n", + instr->implicits[i], t->avalue); #endif - InsererVarDansTab(&it, CreerElement(instr->implicits[i], t)); - break; - } - } - - pi->Encoded = evaluate_field(it, "FI", fields); - DetruitTab(&it); - break; - default: - exception(1, _("Unknow instruction")); - break; + InsererVarDansTab(&it, + CreerElement(instr->implicits[i], t)); + break; } + } - break; + pi->Encoded = evaluate_field(it, "FI", fields); + DetruitTab(&it); + break; + default: + exception(1, _("Unknow instruction")); + break; } - wc = 0; - special = 0; - e_current = e_line = NULL; + break; + } + + wc = 0; + special = 0; + e_current = e_line = NULL; } /* Ecrit un ou plusieurs mots dans le fichier spécifié, avec traitement des erreurs */ static void writeword(unsigned long int a, FILE * f, int n) { - int i; + int i; #ifdef DEBUG - fprintf(stderr, "ÉCriture de %08lX sur %i\n", a, fileno(f)); + fprintf(stderr, "ÉCriture de %08lX sur %i\n", a, fileno(f)); #endif - if (fwrite(&a, sizeof(unsigned long int), 1, f) != 1) { - if (ferror(f)) { - pushcontext(strerror(errno)); - } - exception(1, _("Error writing file")); + if (fwrite(&a, sizeof(unsigned long int), 1, f) != 1) { + if (ferror(f)) { + pushcontext(strerror(errno)); } + exception(1, _("Error writing file")); + } - for (i = 0; i < n - 1; i++) { - writeword(0, f, 1); - } + for (i = 0; i < n - 1; i++) { + writeword(0, f, 1); + } } /* Ecrit une chaine dans le fichier spécifié, avec traitement des erreurs */ static void writestring(char *string, FILE * f) { - for (; *string; string++) { - writeword(*string, f, 1); - } + for (; *string; string++) { + writeword(*string, f, 1); + } } /****************\ @@ -1763,24 +1864,24 @@ static void writestring(char *string, FILE * f) \****************//* Cette fonction ajoute un fichier à un autre */ void appendfile(FILE * f, char *name) { - unsigned long int a; - FILE *g; + unsigned long int a; + FILE *g; - if (!(g = fopen(name, "rb"))) { - pushcontext(strerror(errno)); - exception(1, _("Error writing file")); - } + if (!(g = fopen(name, "rb"))) { + pushcontext(strerror(errno)); + exception(1, _("Error writing file")); + } - while (fread(&a, sizeof(a), 1, g) == 1) { - writeword(a, f, 1); - } + while (fread(&a, sizeof(a), 1, g) == 1) { + writeword(a, f, 1); + } - if (ferror(f)) { - pushcontext(strerror(errno)); - exception(1, _("Error reading file")); - } + if (ferror(f)) { + pushcontext(strerror(errno)); + exception(1, _("Error reading file")); + } - fclose(g); + fclose(g); } /* Cette fonction est appelée pour signaler la fin du fichier. Elle va écrire tous les segments dans le fichier de sortie, @@ -1788,380 +1889,433 @@ void appendfile(FILE * f, char *name) void asm_eof(FILE * f) { - bytestream_t *t, *u; - FILE *f1, *f2; - int nbsymbols = 0, a, nbi = 0, nbe = 0; - char errctx[BUFSIZ], trouve; - bytestream_t *ttext = text, *tdata = data, *tbss = bss; - - pushcontext(_("Creating temporary files")); - if (!(f1 = fopen("__text__", "wb"))) { - pushcontext(strerror(errno)); - exception(1, _("Error writing file __text__")); - } - if (!(f2 = fopen("__symbols__", "wb"))) { - pushcontext(strerror(errno)); - exception(1, _("Error writing file __symbols__")); - } - popcontext(); - - pushcontext(_("Dumping memory into object file")); - - - /* Segment de texte */ - - pushcontext(_("Dumping text segment")); - for (ttext = ttext->next; ttext; ttext = ttext->next) { - sprintf(errctx, _("Processing word number %i coming from line %i of the file %s."), ttext->offset, ttext->line, ttext->filename); + bytestream_t *t, *u; + FILE *f1, *f2; + int nbsymbols = 0, a, nbi = 0, nbe = 0; + char errctx[BUFSIZ], trouve; + bytestream_t *ttext = text, *tdata = data, *tbss = bss; + + pushcontext(_("Creating temporary files")); + if (!(f1 = fopen("__text__", "wb"))) { + pushcontext(strerror(errno)); + exception(1, _("Error writing file __text__")); + } + if (!(f2 = fopen("__symbols__", "wb"))) { + pushcontext(strerror(errno)); + exception(1, _("Error writing file __symbols__")); + } + popcontext(); + + pushcontext(_("Dumping memory into object file")); + + + /* Segment de texte */ + + pushcontext(_("Dumping text segment")); + for (ttext = ttext->next; ttext; ttext = ttext->next) { + sprintf(errctx, + _ + ("Processing word number %i coming from line %i of the file %s."), + ttext->offset, ttext->line, ttext->filename); #ifdef DEBUG - fprintf(stderr, "%s\n", errctx); + fprintf(stderr, "%s\n", errctx); #endif - pushcontext(errctx); + pushcontext(errctx); - a = 0; + a = 0; - if (ttext->Expr) { - switch (ttext->Expr->e_subtype) { - case E_VALUE: - a = ttext->Expr->avalue; - break; - case E_LABEL: + if (ttext->Expr) { + switch (ttext->Expr->e_subtype) { + case E_VALUE: + a = ttext->Expr->avalue; + break; + case E_LABEL: #ifdef DEBUG - fprintf(stderr, "Symbole externe %s\n", ttext->Expr->symbol); + fprintf(stderr, "Symbole externe %s\n", ttext->Expr->symbol); #endif - a = ttext->Expr->avalue; - nbsymbols++; - writeword(1, f2, 1); - writeword(ttext->offset, f2, 1); - writeword(strlen(ttext->Expr->symbol), f2, 1); - writestring(ttext->Expr->symbol, f2); - nbe++; - break; - case E_OPERATION: - if (ttext->Expr->op == OP_DIRECT) { - if (ttext->Expr->child->e_subtype == E_VALUE) { - a = ttext->Expr->child->avalue; - break; - } - } - if (ttext->Expr->op == OP_DECAL) { - if ((ttext->Expr->child->e_subtype == E_LABEL) - && (ttext->Expr->child->next->e_subtype == E_VALUE)) { + a = ttext->Expr->avalue; + nbsymbols++; + writeword(1, f2, 1); + writeword(ttext->offset, f2, 1); + writeword(strlen(ttext->Expr->symbol), f2, 1); + writestring(ttext->Expr->symbol, f2); + nbe++; + break; + case E_OPERATION: + if (ttext->Expr->op == OP_DIRECT) { + if (ttext->Expr->child->e_subtype == E_VALUE) { + a = ttext->Expr->child->avalue; + break; + } + } + if (ttext->Expr->op == OP_DECAL) { + if ((ttext->Expr->child->e_subtype == E_LABEL) + && (ttext->Expr->child->next->e_subtype == E_VALUE)) { #ifdef DEBUG - fprintf(stderr, "Symbole externe %s\n", ttext->Expr->child->symbol); + fprintf(stderr, + "Symbole externe %s\n", + ttext->Expr->child->symbol); #endif - a = ttext->Expr->child->next->avalue; - nbsymbols++; - writeword(1, f2, 1); - writeword(ttext->offset, f2, 1); - writeword(strlen(ttext->Expr->child->symbol), f2, 1); - writestring(ttext->Expr->child->symbol, f2); - nbe++; - break; - } - } - if (ttext->Expr->op == OP_PLUS) { - if (((ttext->Expr->child->e_subtype == E_LABEL) - && (ttext->Expr->child->next->e_subtype == E_VALUE)) - || ((ttext->Expr->child->e_subtype == E_VALUE) - && (ttext->Expr->child->next->e_subtype == E_LABEL))) { - if (ttext->Expr->child->e_subtype == E_LABEL) { + a = ttext->Expr->child->next->avalue; + nbsymbols++; + writeword(1, f2, 1); + writeword(ttext->offset, f2, 1); + writeword(strlen(ttext->Expr->child->symbol), f2, 1); + writestring(ttext->Expr->child->symbol, f2); + nbe++; + break; + } + } + if (ttext->Expr->op == OP_PLUS) { + if (((ttext->Expr->child->e_subtype == E_LABEL) + && (ttext->Expr->child->next->e_subtype == E_VALUE)) + || ((ttext->Expr->child->e_subtype == E_VALUE) + && (ttext->Expr->child->next->e_subtype == + E_LABEL))) { + if (ttext->Expr->child->e_subtype == E_LABEL) { #ifdef DEBUG - fprintf(stderr, "Symbole externe %s\n", ttext->Expr->child->symbol); + fprintf(stderr, + "Symbole externe %s\n", + ttext->Expr->child->symbol); #endif - a = ttext->Expr->child->next->avalue; - nbsymbols++; - writeword(1, f2, 1); - writeword(ttext->offset, f2, 1); - writeword(strlen(ttext->Expr->child->symbol), f2, 1); - writestring(ttext->Expr->child->symbol, f2); - nbe++; - } else { + a = ttext->Expr->child->next->avalue; + nbsymbols++; + writeword(1, f2, 1); + writeword(ttext->offset, f2, 1); + writeword(strlen + (ttext->Expr->child->symbol), f2, 1); + writestring(ttext->Expr->child->symbol, f2); + nbe++; + } else { #ifdef DEBUG - fprintf(stderr, "Symbole externe %s\n", ttext->Expr->child->next->symbol); + fprintf(stderr, + "Symbole externe %s\n", + ttext->Expr->child->next->symbol); #endif - a = ttext->Expr->child->avalue; - nbsymbols++; - writeword(1, f2, 1); - writeword(ttext->offset, f2, 1); - writeword(strlen(ttext->Expr->child->next->symbol), f2, 1); - writestring(ttext->Expr->child->next->symbol, f2); - nbe++; - } - break; - } - } - if (ttext->Expr->op != OP_FUNC_CALL) { - exception(1, _("Can't evaluate expression for a direct value")); - } - if (strcmp(ttext->Expr->symbol, "diff")) { - exception(1, _("Can't evaluate expression for a direct value")); - } - if ((ttext->Expr->child->e_subtype != E_LABEL) - || (ttext->Expr->child->next->e_subtype != E_LABEL)) { - exception(1, _("Can only use the diff() function onto labels")); - } + a = ttext->Expr->child->avalue; + nbsymbols++; + writeword(1, f2, 1); + writeword(ttext->offset, f2, 1); + writeword(strlen + (ttext->Expr->child->next->symbol), f2, + 1); + writestring(ttext->Expr->child->next->symbol, f2); + nbe++; + } + break; + } + } + if (ttext->Expr->op != OP_FUNC_CALL) { + exception(1, + _ + ("Can't evaluate expression for a direct value")); + } + if (strcmp(ttext->Expr->symbol, "diff")) { + exception(1, + _ + ("Can't evaluate expression for a direct value")); + } + if ((ttext->Expr->child->e_subtype != E_LABEL) + || (ttext->Expr->child->next->e_subtype != E_LABEL)) { + exception(1, + _ + ("Can only use the diff() function onto labels")); + } - t = (bytestream_t *) NomVarToVar(ttext->Expr->child->symbol, labels, &trouve); - if (!trouve) { - exception(1, _("Can only evaluate a diff on local symbols")); - } - u = (bytestream_t *) NomVarToVar(ttext->Expr->child->next->symbol, labels, &trouve); - if (!trouve) { - exception(1, _("Can only evaluate a diff on local symbols")); - } + t = + (bytestream_t *) NomVarToVar(ttext->Expr->child->symbol, + labels, &trouve); + if (!trouve) { + exception(1, + _("Can only evaluate a diff on local symbols")); + } + u = + (bytestream_t *) + NomVarToVar(ttext->Expr->child->next->symbol, labels, + &trouve); + if (!trouve) { + exception(1, + _("Can only evaluate a diff on local symbols")); + } - if (t->segment != u->segment) { - exception(1, _("Can only evaluate a diff on symbols from the same segment")); - } + if (t->segment != u->segment) { + exception(1, + _ + ("Can only evaluate a diff on symbols from the same segment")); + } - a = t->offset - u->offset; - break; - default: - exception(1, _("Can't evaluate expression")); + a = t->offset - u->offset; + break; + default: + exception(1, _("Can't evaluate expression")); - } - } + } + } - a += ttext->Encoded; + a += ttext->Encoded; - if (ttext->size) { - writeword(a, f1, text->size); - } else { - if (ttext->Label) { - nbsymbols++; + if (ttext->size) { + writeword(a, f1, text->size); + } else { + if (ttext->Label) { + nbsymbols++; #ifdef DEBUG - fprintf(stderr, "Symbole interne %s\n", ttext->Label); + fprintf(stderr, "Symbole interne %s\n", ttext->Label); #endif - writeword(0, f2, 1); - writeword(ttext->offset, f2, 1); - if (ttext->Label[strlen(ttext->Label) - 1] == ':') { - ttext->Label[strlen(ttext->Label) - 1] = '\0'; - } - writeword(strlen(ttext->Label), f2, 1); - writestring(ttext->Label, f2); - nbi++; - } + writeword(0, f2, 1); + writeword(ttext->offset, f2, 1); + if (ttext->Label[strlen(ttext->Label) - 1] == ':') { + ttext->Label[strlen(ttext->Label) - 1] = '\0'; } - popcontext(); + writeword(strlen(ttext->Label), f2, 1); + writestring(ttext->Label, f2); + nbi++; + } } popcontext(); + } + popcontext(); - /* Segment de data */ + /* Segment de data */ - pushcontext(_("Dumping data segment")); - for (tdata = tdata->next; tdata; tdata = tdata->next) { - sprintf(errctx, _("Processing word number %i coming from line %i of the file %s."), tdata->offset, tdata->line, tdata->filename); + pushcontext(_("Dumping data segment")); + for (tdata = tdata->next; tdata; tdata = tdata->next) { + sprintf(errctx, + _ + ("Processing word number %i coming from line %i of the file %s."), + tdata->offset, tdata->line, tdata->filename); #ifdef DEBUG - fprintf(stderr, "%s\n", errctx); + fprintf(stderr, "%s\n", errctx); #endif - pushcontext(errctx); + pushcontext(errctx); - a = 0; + a = 0; - if (tdata->Expr) { - switch (tdata->Expr->e_subtype) { - case E_VALUE: - a = tdata->Expr->avalue; - break; - case E_LABEL: - a = tdata->Expr->avalue; + if (tdata->Expr) { + switch (tdata->Expr->e_subtype) { + case E_VALUE: + a = tdata->Expr->avalue; + break; + case E_LABEL: + a = tdata->Expr->avalue; #ifdef DEBUG - fprintf(stderr, "Symbole externe %s\n", tdata->Expr->child->symbol); + fprintf(stderr, "Symbole externe %s\n", + tdata->Expr->child->symbol); #endif - nbsymbols++; - writeword(3, f2, 1); - writeword(tdata->offset, f2, 1); - writeword(strlen(tdata->Expr->symbol), f2, 1); - writestring(tdata->Expr->symbol, f2); - nbe++; - break; - case E_OPERATION: - if (tdata->Expr->op != OP_FUNC_CALL) { - exception(1, _("Can't evaluate expression for a direct value")); - } - if (strcmp(tdata->Expr->symbol, "diff")) { - exception(1, _("Can't evaluate expression for a direct value")); - } - if ((tdata->Expr->child->e_subtype != E_LABEL) - || (tdata->Expr->child->next->e_subtype != E_LABEL)) { - exception(1, _("Can only use the diff() function onto labels")); - } + nbsymbols++; + writeword(3, f2, 1); + writeword(tdata->offset, f2, 1); + writeword(strlen(tdata->Expr->symbol), f2, 1); + writestring(tdata->Expr->symbol, f2); + nbe++; + break; + case E_OPERATION: + if (tdata->Expr->op != OP_FUNC_CALL) { + exception(1, + _ + ("Can't evaluate expression for a direct value")); + } + if (strcmp(tdata->Expr->symbol, "diff")) { + exception(1, + _ + ("Can't evaluate expression for a direct value")); + } + if ((tdata->Expr->child->e_subtype != E_LABEL) + || (tdata->Expr->child->next->e_subtype != E_LABEL)) { + exception(1, + _ + ("Can only use the diff() function onto labels")); + } - t = (bytestream_t *) NomVarToVar(tdata->Expr->child->symbol, labels, &trouve); - if (!trouve) { - exception(1, _("Can only evaluate a diff on local symbols")); - } - u = (bytestream_t *) NomVarToVar(tdata->Expr->child->next->symbol, labels, &trouve); - if (!trouve) { - exception(1, _("Can only evaluate a diff on local symbols")); - } + t = + (bytestream_t *) NomVarToVar(tdata->Expr->child->symbol, + labels, &trouve); + if (!trouve) { + exception(1, + _("Can only evaluate a diff on local symbols")); + } + u = + (bytestream_t *) + NomVarToVar(tdata->Expr->child->next->symbol, labels, + &trouve); + if (!trouve) { + exception(1, + _("Can only evaluate a diff on local symbols")); + } - if (t->segment != u->segment) { - exception(1, _("Can only evaluate a diff on symbols from the same segment")); - } + if (t->segment != u->segment) { + exception(1, + _ + ("Can only evaluate a diff on symbols from the same segment")); + } - a = t->offset - u->offset; - break; - default: - exception(1, _("Can't evaluate expression")); + a = t->offset - u->offset; + break; + default: + exception(1, _("Can't evaluate expression")); - } - } + } + } - a += tdata->Encoded; + a += tdata->Encoded; - if (tdata->size) { - writeword(a, f1, text->size); - } else { - if (tdata->Label) { - nbsymbols++; + if (tdata->size) { + writeword(a, f1, text->size); + } else { + if (tdata->Label) { + nbsymbols++; #ifdef DEBUG - fprintf(stderr, "Symbole interne %s\n", tdata->Label); + fprintf(stderr, "Symbole interne %s\n", tdata->Label); #endif - writeword(2, f2, 1); - writeword(tdata->offset, f2, 1); - writeword(strlen(tdata->Label), f2, 1); - writestring(tdata->Label, f2); - nbi++; - } - } - popcontext(); + writeword(2, f2, 1); + writeword(tdata->offset, f2, 1); + writeword(strlen(tdata->Label), f2, 1); + writestring(tdata->Label, f2); + nbi++; + } } popcontext(); + } + popcontext(); - fclose(f1); + fclose(f1); - /* Segment bss */ + /* Segment bss */ - pushcontext(_("Dumping bss segment")); - for (tbss = tbss->next; tbss; tbss = tbss->next) { - sprintf(errctx, _("Processing word number %i coming from line %i of the file %s."), tbss->offset, tbss->line, tbss->filename); - pushcontext(errctx); + pushcontext(_("Dumping bss segment")); + for (tbss = tbss->next; tbss; tbss = tbss->next) { + sprintf(errctx, + _ + ("Processing word number %i coming from line %i of the file %s."), + tbss->offset, tbss->line, tbss->filename); + pushcontext(errctx); - if (!tbss->size) { - if (tbss->Label) { - nbsymbols++; - writeword(4, f2, 1); + if (!tbss->size) { + if (tbss->Label) { + nbsymbols++; + writeword(4, f2, 1); #ifdef DEBUG - fprintf(stderr, "Symbole interne %s\n", tbss->Label); + fprintf(stderr, "Symbole interne %s\n", tbss->Label); #endif - writeword(tbss->offset, f2, 1); - writeword(strlen(tbss->Label), f2, 1); - writestring(tbss->Label, f2); - nbi++; - } - } - popcontext(); + writeword(tbss->offset, f2, 1); + writeword(strlen(tbss->Label), f2, 1); + writestring(tbss->Label, f2); + nbi++; + } } popcontext(); - popcontext(); - - writeword(0x4f424e4e, f, 1); - writeword(ftell(f2) + s_data + s_text + 7, f, 1); - t = (bytestream_t *) NomVarToVar("__start__", labels, &trouve); - if (trouve) { - writeword(t->offset, f, 1); - } else { - writeword(-1, f, 1); - } - - writeword(s_text, f, 1); - writeword(s_data, f, 1); - writeword(s_bss, f, 1); - writeword(ftell(f2) + 1, f, 1); - fclose(f2); - - writeword(nbsymbols, f, 1); - appendfile(f, "__symbols__"); - appendfile(f, "__text__"); - fclose(f); - - unlink("__symbols__"); - unlink("__text__"); - - fprintf(stderr, - _("Statistics: %i words of text, %i words of data, and %i words reserved.\n%i symbols generated with %i internal and %i external.\n"), s_text, s_data, s_bss, nbsymbols, nbi, nbe); + } + popcontext(); + popcontext(); + + writeword(0x4f424e4e, f, 1); + writeword(ftell(f2) + s_data + s_text + 7, f, 1); + t = (bytestream_t *) NomVarToVar("__start__", labels, &trouve); + if (trouve) { + writeword(t->offset, f, 1); + } else { + writeword(-1, f, 1); + } + + writeword(s_text, f, 1); + writeword(s_data, f, 1); + writeword(s_bss, f, 1); + writeword(ftell(f2) + 1, f, 1); + fclose(f2); + + writeword(nbsymbols, f, 1); + appendfile(f, "__symbols__"); + appendfile(f, "__text__"); + fclose(f); + + unlink("__symbols__"); + unlink("__text__"); + + fprintf(stderr, + _ + ("Statistics: %i words of text, %i words of data, and %i words reserved.\n%i symbols generated with %i internal and %i external.\n"), + s_text, s_data, s_bss, nbsymbols, nbi, nbe); } /* Diverses fonctions pour faire plein de free() partout */ static void delete_bytestream(bytestream_t * s) { - if (s->next) - delete_bytestream(s->next); - if (s->Label) - free(s->Label); - free(s); + if (s->next) + delete_bytestream(s->next); + if (s->Label) + free(s->Label); + free(s); } void assembler_flush(void) { - DetruitTab(&defines); - DetruitTab(&labels); - delete_bytestream(text); - delete_bytestream(data); - delete_bytestream(bss); + DetruitTab(&defines); + DetruitTab(&labels); + delete_bytestream(text); + delete_bytestream(data); + delete_bytestream(bss); } -/* Fonction générique qui va traiter un fichier entier */ static int process_file(char *name) +/* Fonction générique qui va traiter un fichier entier */ static int +process_file(char *name) { - FILE *f; - char buf[BUFSIZ], errctx[BUFSIZ], *p; - int i = 0; - - pushcontext(_("Loading file")); - sprintf(errctx, _("Opening file '%s'"), name); + FILE *f; + char buf[BUFSIZ], errctx[BUFSIZ], *p; + int i = 0; + + pushcontext(_("Loading file")); + sprintf(errctx, _("Opening file '%s'"), name); + pushcontext(errctx); + filenames[nestedinc++] = Estrdup(name); + if (!(f = fopen(name, "r"))) { + pushcontext(strerror(errno)); + return 1; + } + popcontext(); + + pushcontext(_("Reading file")); + while (fgets(buf, BUFSIZ, f)) { + sprintf(errctx, _("Reading line %i"), line = ++i); pushcontext(errctx); - filenames[nestedinc++] = Estrdup(name); - if (!(f = fopen(name, "r"))) { - pushcontext(strerror(errno)); - return 1; + if ((p = strchr(buf, '\r'))) { + *p = '\0'; } - popcontext(); - - pushcontext(_("Reading file")); - while (fgets(buf, BUFSIZ, f)) { - sprintf(errctx, _("Reading line %i"), line = ++i); - pushcontext(errctx); - if ((p = strchr(buf, '\r'))) { - *p = '\0'; - } - if ((p = strchr(buf, '\n'))) { - *p = '\0'; - } - parse_line(buf); - sprintf(errctx, _("Summering line %s"), buf); - pushcontext(errctx); - asm_eol(); - popcontext(); - popcontext(); + if ((p = strchr(buf, '\n'))) { + *p = '\0'; } - nestedinc--; + parse_line(buf); + sprintf(errctx, _("Summering line %s"), buf); + pushcontext(errctx); + asm_eol(); popcontext(); popcontext(); - fclose(f); - return 0; + } + nestedinc--; + popcontext(); + popcontext(); + fclose(f); + return 0; } /* Fonction d'api pour assembler un fichier d'entrée */ void assemble_file(char *iname, char *oname) { - FILE *f; - - fprintf(stderr, _("Assembling file %s...\n"), iname); - pushcontext(_("Opening output file")); - if (!(f = fopen(oname, "wb"))) { - pushcontext(strerror(errno)); - exception(1, _("Error writing output file")); - } - popcontext(); - - if (process_file(iname)) { - exception(1, _("Error reading file")); - } - pushcontext(_("Writing output file")); - fprintf(stderr, _("Generating output file %s...\n"), oname); - asm_eof(f); - popcontext(); + FILE *f; + + fprintf(stderr, _("Assembling file %s...\n"), iname); + pushcontext(_("Opening output file")); + if (!(f = fopen(oname, "wb"))) { + pushcontext(strerror(errno)); + exception(1, _("Error writing output file")); + } + popcontext(); + + if (process_file(iname)) { + exception(1, _("Error reading file")); + } + pushcontext(_("Writing output file")); + fprintf(stderr, _("Generating output file %s...\n"), oname); + asm_eof(f); + popcontext(); } -- cgit v1.2.3