Indentation plus faible

1 files changed, 1879 insertions, 1725 deletions

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();
 }