?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update autotools files
[xorcyst.git] / astproc.c
blob08d4f5fdde2257d19f9a2716c8a81999bf509f1f
1 /*
2 * $Id: astproc.c,v 1.21 2007/11/11 22:35:22 khansen Exp $
3 * $Log: astproc.c,v $
4 * Revision 1.21 2007/11/11 22:35:22 khansen
5 * compile on mac
6 *
7 * Revision 1.20 2007/08/19 10:17:39 khansen
8 * allow symbols to be used without having been declared
9 *
10 * Revision 1.19 2007/08/12 18:58:12 khansen
11 * ability to generate pure 6502 binary (--pure-binary switch)
12 *
13 * Revision 1.18 2007/08/12 02:42:46 khansen
14 * prettify, const
15 *
16 * Revision 1.17 2007/08/09 22:06:10 khansen
17 * ability to pass in reference to local label as argument to macro
18 *
19 * Revision 1.16 2007/08/09 20:48:46 khansen
20 * disable buggy code that can cause crash
21 *
22 * Revision 1.15 2007/08/09 20:33:40 khansen
23 * progress
24 *
25 * Revision 1.14 2007/08/08 22:40:01 khansen
26 * improved symbol lookup, definitions must precede usage
27 *
28 * Revision 1.13 2007/07/22 13:33:26 khansen
29 * convert tabs to whitespaces
30 *
31 * Revision 1.12 2005/01/09 11:17:57 kenth
32 * xorcyst 1.4.5
33 * fixed bug in process_data(), merge_data()
34 * no longer truncation warning when fits in signed byte/word
35 *
36 * Revision 1.11 2005/01/05 02:28:13 kenth
37 * xorcyst 1.4.3
38 * support for anonymous unions
39 * fixed sizeof bug
40 *
41 * Revision 1.10 2004/12/29 21:44:41 kenth
42 * xorcyst 1.4.2
43 * static indexing, sizeof improved
44 *
45 * Revision 1.9 2004/12/25 02:22:35 kenth
46 * fixed bug in reduce_user_storage()
47 *
48 * Revision 1.8 2004/12/19 19:58:29 kenth
49 * xorcyst 1.4.0
50 *
51 * Revision 1.7 2004/12/18 16:57:39 kenth
52 * STORAGE_NODE(WORD/DWORD_DATATYPE) converts to BYTE
53 *
54 * Revision 1.6 2004/12/16 13:19:47 kenth
55 * xorcyst 1.3.5
56 *
57 * Revision 1.5 2004/12/14 01:49:05 kenth
58 * xorcyst 1.3.0
59 *
60 * Revision 1.4 2004/12/11 02:01:25 kenth
61 * added forward/backward branching
62 *
63 * Revision 1.3 2004/12/09 11:18:13 kenth
64 * added: warning, error node processing
65 *
66 * Revision 1.2 2004/12/06 04:52:24 kenth
67 * Major updates (xorcyst 1.1.0)
68 *
69 * Revision 1.1 2004/06/30 07:55:31 kenth
70 * Initial revision
71 *
72 */
73
74 /**
75 * (C) 2004 Kent Hansen
76 *
77 * The XORcyst is free software; you can redistribute it and/or modify
78 * it under the terms of the GNU General Public License as published by
79 * the Free Software Foundation; either version 2 of the License, or
80 * (at your option) any later version.
81 *
82 * The XORcyst is distributed in the hope that it will be useful,
83 * but WITHOUT ANY WARRANTY; without even the implied warranty of
84 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
85 * GNU General Public License for more details.
86 *
87 * You should have received a copy of the GNU General Public License
88 * along with The XORcyst; if not, write to the Free Software
89 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
90 */
91
92 /**
93 * This file contains functions that process the Abstract Syntax Tree (AST).
94 * After the assembly file has been parsed into an AST, a number of passes are
95 * made on it to process it and transform it. The functions here are
96 * concerned with things like
97 * - macro expansion
98 * - symbol table generation
99 * - equates substitution
100 * - constant folding
101 * - code and symbol validation
102 */
103
104 #include <stdlib.h>
105 #include <stdio.h>
106 #include <stdarg.h>
107 #include <string.h>
108 #include <assert.h>
109 #include "astproc.h"
110 #include "symtab.h"
111 #include "opcode.h"
112 #include "charmap.h"
113 #include "xasm.h"
114
115 #define IS_SIGNED_BYTE_VALUE(v) (((v) >= -128) && ((v) <= 127))
116 #define IS_UNSIGNED_BYTE_VALUE(v) (((v) >= 0) && ((v) <= 255))
117 #define IS_BYTE_VALUE(v) (IS_SIGNED_BYTE_VALUE(v) || IS_UNSIGNED_BYTE_VALUE(v))
118
119 #define IS_SIGNED_WORD_VALUE(v) (((v) >= -32768) && ((v) <= 32767))
120 #define IS_UNSIGNED_WORD_VALUE(v) (((v) >= 0) && ((v) <= 65535))
121 #define IS_WORD_VALUE(v) (IS_SIGNED_WORD_VALUE(v) || IS_UNSIGNED_WORD_VALUE(v))
122
123 /*---------------------------------------------------------------------------*/
124
125 /** Number of errors issued during processing. */
126 static int err_count = 0;
127
128 /** Number of warnings issued during processing. */
129 static int warn_count = 0;
130
131 /* Keeps track of number of global labels encountered. */
132 static int label_count = 0;
133
134 /* Keeps track of whether statement is in dataseg or codeseg. */
135 static int in_dataseg = 0;
136
137 /* Default symbol modifiers, i.e. ZEROPAGE_FLAG, PUBLIC_FLAG */
138 static int symbol_modifiers = 0;
139
140 /* Used when we are outputting pure 6502 binary */
141 static int dataseg_pc;
142 static int codeseg_pc;
143
144 /*---------------------------------------------------------------------------*/
145
146 /** Mapping from regular ASCII characters to custom character values.
147 * Used to transform .char arrays to regular .db arrays.
148 */
149 static unsigned char charmap[256];
150
151 /**
152 * Resets the custom character map.
153 * Every ASCII character is mapped to itself.
154 */
155 static void reset_charmap()
156 {
157 int i;
158 for (i=0; i<256; i++) {
159 charmap[i] = (char)i;
160 }
161 }
162
163 /*---------------------------------------------------------------------------*/
164 /* Forward/backward branching stuff */
165
166 struct tag_forward_branch_info {
167 astnode *refs[128];
168 int index; /* Index into refs */
169 int counter;
170 };
171
172 typedef struct tag_forward_branch_info forward_branch_info;
173
174 struct tag_backward_branch_info {
175 astnode *decl;
176 int counter;
177 };
178
179 typedef struct tag_backward_branch_info backward_branch_info;
180
181 #define BRANCH_MAX 8
182
183 static forward_branch_info forward_branch[BRANCH_MAX];
184
185 static backward_branch_info backward_branch[BRANCH_MAX];
186
187 /**
188 * Zaps forward/backward branch data.
189 */
190 static void branch_init()
191 {
192 int i, j;
193 for (i=0; i<BRANCH_MAX; i++) {
194 for (j=0; j<128; j++) {
195 forward_branch[i].refs[j] = NULL;
196 }
197 forward_branch[i].index = 0;
198 forward_branch[i].counter = 0;
199 backward_branch[i].decl = NULL;
200 backward_branch[i].counter = 0;
201 }
202 }
203
204 /*---------------------------------------------------------------------------*/
205
206 /**
207 * Issues an error.
208 * @param loc File location of error
209 * @param fmt printf-style format string
210 */
211 static void err(location loc, const char *fmt, ...)
212 {
213 va_list ap;
214 va_start(ap, fmt);
215
216 fprintf(stderr, "%s:", loc.file);
217 LOCATION_PRINT(stderr, loc);
218 fprintf(stderr, ": error: ");
219 vfprintf(stderr, fmt, ap);
220 fprintf(stderr, "\n");
221
222 va_end(ap);
223
224 err_count++;
225 }
226
227 /**
228 * Issues a warning.
229 * @param loc File location of warning
230 * @param fmt printf-style format string
231 */
232 static void warn(location loc, const char *fmt, ...)
233 {
234 va_list ap;
235 if (!xasm_args.no_warn) {
236 va_start(ap, fmt);
237 fprintf(stderr, "%s:", loc.file);
238 LOCATION_PRINT(stderr, loc);
239 fprintf(stderr, ": warning: ");
240 vfprintf(stderr, fmt, ap);
241 fprintf(stderr, "\n");
242 va_end(ap);
243 }
244
245 warn_count++;
246 }
247
248 /**
249 * Gets the number of errors encountered during processing.
250 * @return Number of errors
251 */
252 int astproc_err_count()
253 {
254 return err_count;
255 }
256
257 /*---------------------------------------------------------------------------*/
258
259 /**
260 * Gets the processor function for a node type from a map.
261 * Used by astproc_walk().
262 * @param type The node type
263 * @param map A mapping from node types to processor functions
264 */
265 static astnodeproc astproc_node_type_to_proc(astnode_type type, const astnodeprocmap *map)
266 {
267 for (; map->proc != NULL; map += 1) {
268 if (map->type == type) {
269 return map->proc;
270 }
271 }
272 return NULL;
273 }
274
275 /*---------------------------------------------------------------------------*/
276
277 /**
278 * Walks an abstract syntax tree recursively.
279 * @param n Node to walk
280 * @param arg Optional argument to pass to processor function
281 * @param map Mapping of node types to processor functions
282 */
283 static void astproc_walk_recursive(astnode *n, void *arg, const astnodeprocmap *map, astnode **next)
284 {
285 astnode *c;
286 astnode *t;
287 if (n == NULL) { return; }
288 astnodeproc p = astproc_node_type_to_proc(astnode_get_type(n), map);
289 if (p != NULL) {
290 if (!p(n, arg, next))
291 return; /* Don't walk children */
292 }
293 /* Walk the node's children recursively */
294 for (c=n->first_child; c != NULL; c = t) {
295 t = c->next_sibling; /* default next node */
296 astproc_walk_recursive(c, arg, map, &t);
297 }
298 }
299
300 /**
301 * Generic tree walker function.
302 * @param n Root
303 * @param arg General-purpose argument passed to each node handler function
304 * @param map Array of (nodetype, handler function) tuples
305 */
306 void astproc_walk(astnode *n, void *arg, const astnodeprocmap *map)
307 {
308 astnode *dummy;
309 astproc_walk_recursive(n, arg, map, &dummy);
310 }
311
312 /*---------------------------------------------------------------------------*/
313
314 /**
315 * Don't do any processing of this node or its children on this pass.
316 */
317 static int noop(astnode *n, void *arg, astnode **next)
318 {
319 return 0;
320 }
321
322 /**
323 * Substitutes an identifier node with subst_expr if the id is equal to subst_id.
324 * @param id A node of type IDENTIFIER_NODE
325 * @param arg Array of length 2, containing (expr, id) pair
326 */
327 static int substitute_id(astnode *id, void *arg, astnode **next)
328 {
329 /* arg is array containing expression and identifier */
330 astnode **array = (astnode **)arg;
331 astnode *subst_expr = array[0];
332 astnode *subst_id = array[1];
333 if (astnode_equal(id, subst_id)) {
334 /* They're equal, replace it by expression. */
335 astnode *cl = astnode_clone(subst_expr, id->loc);
336 /* ### Generalize: traverse all children, set the flag */
337 if (astnode_get_type(cl) == LOCAL_ID_NODE) {
338 cl->flags |= 0x80; /* don't globalize it */
339 }
340 astnode_replace(id, cl);
341 astnode_finalize(id);
342 *next = cl;
343 return 0;
344 } else {
345 return 1;
346 }
347 }
348
349 /**
350 * Substitutes expr for id in list.
351 * Used by macro expander to substitute a macro body parameter name with the
352 * actual expression used in the macro expansion.
353 * @param expr An expression
354 * @param id An identifier
355 * @param list A list of statements (macro body)
356 */
357 static void substitute_expr_for_id(astnode *expr, astnode *id, astnode *list)
358 {
359 /* Prepare argument to astproc_walk */
360 astnode *array[2];
361 array[0] = expr;
362 array[1] = id;
363 /* Table of callback functions for our purpose. */
364 static astnodeprocmap map[] = {
365 { IDENTIFIER_NODE, substitute_id },
366 { 0, NULL }
367 };
368 /* Do the walk. */
369 astproc_walk(list, array, map);
370 }
371
372 /*---------------------------------------------------------------------------*/
373
374 /**
375 * Globalizes a macro expanded local.
376 * This is done simply by concatenating the local label identifier with the
377 * global macro invocation counter.
378 * @param n A node of type LOCAL_LABEL_NODE or LOCAL_ID_NODE
379 * @param arg Namespace counter (int)
380 */
381 static int globalize_macro_expanded_local(astnode *n, void *arg, astnode **next)
382 {
383 /* Only globalize if it's a reference to a label defined in the macro */
384 if (!(n->flags & 0x80)) {
385 char str[16];
386 int count;
387 /* Make it global by appending the macro expansion counter to the id */
388 count = (int)arg;
389 snprintf(str, sizeof (str), "#%d", count);
390 if (astnode_is_type(n, LOCAL_LABEL_NODE)) {
391 /* LOCAL_LABEL_NODE, use label field */
392 n->label = realloc(n->label, strlen(n->label)+strlen(str)+1);
393 strcat(n->label, str);
394 } else {
395 /* LOCAL_ID_NODE, use ident field */
396 assert(astnode_is_type(n, LOCAL_ID_NODE));
397 n->ident = realloc(n->ident, strlen(n->ident)+strlen(str)+1);
398 strcat(n->ident, str);
399 }
400 }
401 return 1;
402 }
403
404 /**
405 * Globalizes all locals in the body of a macro expansion.
406 * Used by the macro expander to ensure that local labels in macro expansions
407 * are unique.
408 * @param exp_body The expanded macro body
409 * @param count Unique macro namespace counter
410 */
411 static void globalize_macro_expanded_locals(astnode *exp_body, int count)
412 {
413 /* Table of callback functions for our purpose. */
414 static astnodeprocmap map[] = {
415 { LOCAL_ID_NODE, globalize_macro_expanded_local },
416 { LOCAL_LABEL_NODE, globalize_macro_expanded_local },
417 { 0, NULL }
418 };
419 /* Do the walk. */
420 astproc_walk(exp_body, (void *)count, map);
421 }
422
423 /**
424 * Expands a macro; that is, replaces a macro invocation in the AST with the
425 * macro body. Substitutes parameter names for values.
426 * @param macro Must be a node of type MACRO_NODE
427 * @param arg Not used
428 */
429 static int expand_macro(astnode *macro, void *arg, astnode **next)
430 {
431 astnode *decl;
432 astnode *decl_body;
433 astnode *exp_body;
434 astnode *formals;
435 astnode *actuals;
436 astnode *id;
437 astnode *expr;
438 int i;
439 /* Keeps track of the current/total number of macro expansions */
440 static int macro_expansion_count = 0;
441
442 id = astnode_get_child(macro, 0);
443 assert(astnode_is_type(id, IDENTIFIER_NODE));
444 symtab_entry *e = symtab_lookup(id->ident);
445 if (e == NULL) {
446 err(macro->loc, "unknown macro or directive `%s'", id->ident);
447 astnode_remove(macro);
448 astnode_finalize(macro);
449 return 0;
450 }
451 else if (e->type != MACRO_SYMBOL) {
452 err(macro->loc, "cannot expand `%s'; not a macro", e->id);
453 astnode_remove(macro);
454 astnode_finalize(macro);
455 return 0;
456 }
457 else {
458 decl = (astnode *)e->def;
459 formals = astnode_get_child(decl, 1);
460 actuals = astnode_get_child(macro, 1);
461 if (astnode_get_child_count(formals) != astnode_get_child_count(actuals)) {
462 err(macro->loc, "macro `%s' does not take %d argument(s)", id->ident, astnode_get_child_count(actuals) );
463 astnode_remove(macro);
464 astnode_finalize(macro);
465 return 0;
466 }
467 /* Expand the body */
468 decl_body = astnode_get_child(decl, 2);
469 exp_body = astnode_clone(decl_body, macro->loc);
470 assert(astnode_get_type(exp_body) == LIST_NODE);
471 /* Substitute actuals for formals */
472 for (i=0; i<astnode_get_child_count(actuals); i++) {
473 /* The id to substitute */
474 id = astnode_get_child(formals, i);
475 /* The expression to substitute it with */
476 expr = astnode_get_child(actuals, i);
477 /* Do it! */
478 substitute_expr_for_id(expr, id, exp_body);
479 }
480 /* Make locals a bit more global */
481 globalize_macro_expanded_locals(exp_body, macro_expansion_count);
482 /* Replace MACRO_NODE by the macro body instance */
483 {
484 astnode *stmts = astnode_remove_children(exp_body);
485 astnode_replace(macro, stmts);
486 *next = stmts;
487 astnode_finalize(exp_body);
488 }
489
490 astnode_finalize(macro);
491 macro_expansion_count++;
492 }
493 return 0;
494 }
495
496 /*---------------------------------------------------------------------------*/
497
498 /**
499 * Does constant folding of expression.
500 * If the expression can be folded, the original expression is replaced by the
501 * new one, and the original expression is finalized.
502 * @param expr Expression
503 * @return Original expression, if couldn't fold, otherwise new, folded expression
504 */
505 astnode *astproc_fold_constants(astnode *expr)
506 {
507 astnode *folded;
508 astnode *lhs;
509 astnode *rhs;
510 if (expr == NULL) { return NULL; }
511 folded = NULL;
512 if (astnode_is_type(expr, ARITHMETIC_NODE)) {
513 /* Fold operands recursively */
514 lhs = astproc_fold_constants(LHS(expr));
515 rhs = astproc_fold_constants(RHS(expr));
516 switch (expr->oper) {
517 /* Binary ops */
518 case PLUS_OPERATOR:
519 case MINUS_OPERATOR:
520 case MUL_OPERATOR:
521 case DIV_OPERATOR:
522 case MOD_OPERATOR:
523 case AND_OPERATOR:
524 case OR_OPERATOR:
525 case XOR_OPERATOR:
526 case SHL_OPERATOR:
527 case SHR_OPERATOR:
528 case LT_OPERATOR:
529 case GT_OPERATOR:
530 case EQ_OPERATOR:
531 case NE_OPERATOR:
532 case LE_OPERATOR:
533 case GE_OPERATOR:
534 /* See if it can be folded */
535 if ( (astnode_is_type(lhs, INTEGER_NODE)) &&
536 (astnode_is_type(rhs, INTEGER_NODE)) ) {
537 /* Both sides are integer literals, so fold. */
538 switch (expr->oper) {
539 case PLUS_OPERATOR: folded = astnode_create_integer(lhs->integer + rhs->integer, expr->loc); break;
540 case MINUS_OPERATOR: folded = astnode_create_integer(lhs->integer - rhs->integer, expr->loc); break;
541 case MUL_OPERATOR: folded = astnode_create_integer(lhs->integer * rhs->integer, expr->loc); break;
542 case DIV_OPERATOR: folded = astnode_create_integer(lhs->integer / rhs->integer, expr->loc); break;
543 case MOD_OPERATOR: folded = astnode_create_integer(lhs->integer % rhs->integer, expr->loc); break;
544 case AND_OPERATOR: folded = astnode_create_integer(lhs->integer & rhs->integer, expr->loc); break;
545 case OR_OPERATOR: folded = astnode_create_integer(lhs->integer | rhs->integer, expr->loc); break;
546 case XOR_OPERATOR: folded = astnode_create_integer(lhs->integer ^ rhs->integer, expr->loc); break;
547 case SHL_OPERATOR: folded = astnode_create_integer(lhs->integer << rhs->integer, expr->loc); break;
548 case SHR_OPERATOR: folded = astnode_create_integer(lhs->integer >> rhs->integer, expr->loc); break;
549 case LT_OPERATOR: folded = astnode_create_integer(lhs->integer < rhs->integer, expr->loc); break;
550 case GT_OPERATOR: folded = astnode_create_integer(lhs->integer > rhs->integer, expr->loc); break;
551 case EQ_OPERATOR: folded = astnode_create_integer(lhs->integer == rhs->integer, expr->loc); break;
552 case NE_OPERATOR: folded = astnode_create_integer(lhs->integer != rhs->integer, expr->loc); break;
553 case LE_OPERATOR: folded = astnode_create_integer(lhs->integer <= rhs->integer, expr->loc); break;
554 case GE_OPERATOR: folded = astnode_create_integer(lhs->integer >= rhs->integer, expr->loc); break;
555
556 default:
557 fprintf(stderr, "internal error: operator not handled in astproc_fold_constants()\n");
558 assert(0);
559 folded = expr;
560 break;
561 }
562 if (folded != expr) {
563 /* Replace expression by folded one. */
564 astnode_replace(expr, folded);
565 astnode_finalize(expr);
566 return folded;
567 }
568 }
569 else if ( (astnode_is_type(lhs, STRING_NODE)) &&
570 (astnode_is_type(rhs, STRING_NODE)) ) {
571 /* Both sides are string literals. */
572 /* Folding is defined only for certain operators. */
573 switch (expr->oper) {
574 case PLUS_OPERATOR:
575 /* String concatenation. */
576 folded = astnode_create(STRING_NODE, expr->loc);
577 folded->string = (char *)malloc(strlen(lhs->string) + strlen(rhs->string) + 1);
578 if (folded->string != NULL) {
579 strcpy(folded->string, lhs->string);
580 strcat(folded->string, rhs->string);
581 }
582 break;
583
584 /* String comparison. */
585 case LT_OPERATOR: folded = astnode_create_integer(strcmp(lhs->string, rhs->string) < 0, expr->loc); break;
586 case GT_OPERATOR: folded = astnode_create_integer(strcmp(lhs->string, rhs->string) > 0, expr->loc); break;
587 case EQ_OPERATOR: folded = astnode_create_integer(strcmp(lhs->string, rhs->string) == 0, expr->loc); break;
588 case NE_OPERATOR: folded = astnode_create_integer(strcmp(lhs->string, rhs->string) != 0, expr->loc); break;
589 case LE_OPERATOR: folded = astnode_create_integer(strcmp(lhs->string, rhs->string) <= 0, expr->loc); break;
590 case GE_OPERATOR: folded = astnode_create_integer(strcmp(lhs->string, rhs->string) >= 0, expr->loc); break;
591
592 default:
593 folded = expr;
594 break;
595 }
596 if (folded != expr) {
597 /* Replace expression by folded one. */
598 astnode_replace(expr, folded);
599 astnode_finalize(expr);
600 return folded;
601 }
602 }
603 else if ((astnode_get_type(lhs) == STRING_NODE) &&
604 (astnode_get_type(rhs) == INTEGER_NODE) &&
605 (expr->oper == PLUS_OPERATOR)) {
606 /* Left side is string and right side is integer.
607 Result is a string. */
608 char str[32];
609 snprintf(str, sizeof (str), "%d", rhs->integer);
610 folded = astnode_create(STRING_NODE, expr->loc);
611 folded->string = (char *)malloc(strlen(lhs->string) + strlen(str) + 1);
612 if (folded->string != NULL) {
613 strcpy(folded->string, lhs->string);
614 strcat(folded->string, str);
615 }
616 /* Replace expression by folded one. */
617 astnode_replace(expr, folded);
618 astnode_finalize(expr);
619 return folded;
620 }
621 else if ((astnode_get_type(rhs) == STRING_NODE) &&
622 (astnode_get_type(lhs) == INTEGER_NODE) &&
623 (expr->oper == PLUS_OPERATOR)) {
624 /* Left side is integer and right side is string.
625 Result is a string. */
626 char str[32];
627 snprintf(str, sizeof (str), "%d", lhs->integer);
628 folded = astnode_create(STRING_NODE, expr->loc);
629 folded->string = (char *)malloc(strlen(str) + strlen(rhs->string) + 1);
630 if (folded->string != NULL) {
631 strcpy(folded->string, str);
632 strcat(folded->string, rhs->string);
633 }
634 /* Replace expression by folded one. */
635 astnode_replace(expr, folded);
636 astnode_finalize(expr);
637 return folded;
638 }
639 /* Use some mathematical identities... */
640 else if ((astnode_is_type(lhs, INTEGER_NODE) && (lhs->integer == 0))
641 && (expr->oper == PLUS_OPERATOR)) {
642 /* 0+expr == expr */
643 astnode_remove_child(expr, rhs);
644 astnode_replace(expr, rhs);
645 astnode_finalize(expr);
646 return rhs;
647 }
648 else if ((astnode_is_type(rhs, INTEGER_NODE) && (rhs->integer == 0))
649 && (expr->oper == PLUS_OPERATOR)) {
650 /* expr+0 == expr */
651 astnode_remove_child(expr, lhs);
652 astnode_replace(expr, lhs);
653 astnode_finalize(expr);
654 return lhs;
655 }
656 else if ((astnode_is_type(lhs, INTEGER_NODE) && (lhs->integer == 1))
657 && (expr->oper == MUL_OPERATOR)) {
658 /* 1*expr == expr */
659 astnode_remove_child(expr, rhs);
660 astnode_replace(expr, rhs);
661 astnode_finalize(expr);
662 return rhs;
663 }
664 else if ((astnode_is_type(rhs, INTEGER_NODE) && (rhs->integer == 1))
665 && ((expr->oper == MUL_OPERATOR) || (expr->oper == DIV_OPERATOR)) ) {
666 /* expr*1 == expr */
667 /* expr/1 == expr */
668 astnode_remove_child(expr, lhs);
669 astnode_replace(expr, lhs);
670 astnode_finalize(expr);
671 return lhs;
672 }
673 else {
674 /* No chance of folding this one. */
675 }
676 break;
677
678 /* Unary ops */
679 case NEG_OPERATOR:
680 case NOT_OPERATOR:
681 case LO_OPERATOR:
682 case HI_OPERATOR:
683 case UMINUS_OPERATOR:
684 case BANK_OPERATOR:
685 /* See if it can be folded */
686 if (astnode_is_type(lhs, INTEGER_NODE)) {
687 /* Fold it. */
688 switch (expr->oper) {
689 case NEG_OPERATOR: folded = astnode_create_integer(~lhs->integer, expr->loc); break;
690 case NOT_OPERATOR: folded = astnode_create_integer(!lhs->integer, expr->loc); break;
691 case LO_OPERATOR: folded = astnode_create_integer(lhs->integer & 0xFF, expr->loc); break;
692 case HI_OPERATOR: folded = astnode_create_integer((lhs->integer >> 8) & 0xFF, expr->loc); break;
693 case UMINUS_OPERATOR: folded = astnode_create_integer(-lhs->integer, expr->loc); break;
694 default: break;
695 }
696 /* Replace expression by folded one. */
697 astnode_replace(expr, folded);
698 astnode_finalize(expr);
699 return folded;
700 }
701 else {
702 /* Couldn't fold this one. */
703 }
704 break;
705 }
706 }
707 /* Couldn't fold it, return original expression */
708 return expr;
709 }
710
711 /*---------------------------------------------------------------------------*/
712
713 /**
714 * Substitutes identifier if it has a constant definition in symbol table.
715 * @param expr Node of type IDENTIFIER_NODE
716 */
717 static astnode *substitute_ident(astnode *expr)
718 {
719 astnode *c;
720 symtab_entry *e;
721 e = symtab_lookup(expr->ident);
722 if (e != NULL) {
723 if (e->type == CONSTANT_SYMBOL) {
724 /* This is a defined symbol that should be
725 replaced by the expression it stands for */
726 c = astnode_clone((astnode *)e->def, expr->loc);
727 astnode_replace(expr, c);
728 astnode_finalize(expr);
729 expr = c;
730 }
731 }
732 return expr;
733 }
734
735 /**
736 * Substitutes sizeof with proper constant.
737 * @param expr Node of type SIZEOF_NODE
738 */
739 static astnode *reduce_sizeof(astnode *expr)
740 {
741 int ok;
742 astnode *c;
743 astnode *id;
744 astnode *type;
745 astnode *count;
746 symtab_entry *e;
747
748 count = NULL;
749 if (astnode_is_type(LHS(expr), IDENTIFIER_NODE)) {
750 /* Identifier might be the name of a user-defined type, OR
751 it might be the name of a variable of a user-defined type */
752 type = NULL;
753 /* Look it up */
754 id = LHS(expr);
755 e = symtab_global_lookup(id->ident);
756 if (e != NULL) {
757 switch (e->type) {
758 case STRUC_SYMBOL:
759 case UNION_SYMBOL:
760 case RECORD_SYMBOL:
761 case ENUM_SYMBOL:
762 type = astnode_create_datatype(USER_DATATYPE, astnode_clone(id, id->loc), id->loc);
763 break;
764
765 case VAR_SYMBOL:
766 type = astnode_clone(LHS(e->def), id->loc);
767 if (astnode_is_type(e->def, STORAGE_NODE)) {
768 count = astnode_clone(RHS(e->def), id->loc);
769 }
770 else {
771 count = astnode_create_integer(astnode_get_child_count(e->def)-1, id->loc);
772 }
773 break;
774
775 default:
776 /* Can't take sizeof of this symbol type */
777 break;
778 }
779 }
780 if (type == NULL) {
781 /* Unknown */
782 type = astnode_create_datatype(USER_DATATYPE, astnode_clone(id, id->loc), id->loc);
783 }
784 /* Replace identifier by datatype node */
785 astnode_replace(id, type);
786 astnode_finalize(id);
787 }
788 type = LHS(expr);
789 switch (type->datatype) {
790 case BYTE_DATATYPE:
791 case CHAR_DATATYPE:
792 c = astnode_create_integer(1, expr->loc);
793 astnode_replace(expr, c);
794 astnode_finalize(expr);
795 expr = c;
796 break;
797
798 case WORD_DATATYPE:
799 c = astnode_create_integer(2, expr->loc);
800 astnode_replace(expr, c);
801 astnode_finalize(expr);
802 expr = c;
803 break;
804
805 case DWORD_DATATYPE:
806 c = astnode_create_integer(4, expr->loc);
807 astnode_replace(expr, c);
808 astnode_finalize(expr);
809 expr = c;
810 break;
811
812 case USER_DATATYPE:
813 id = LHS(type);
814 e = symtab_global_lookup(id->ident);
815 ok = 0;
816 if (e != NULL) {
817 switch (e->type) {
818 case STRUC_SYMBOL:
819 case UNION_SYMBOL:
820 /* Datatype is defined, replace sizeof with proper expression */
821 c = astnode_clone((astnode *)(e->struc.size), ((astnode *)(e->struc.size))->loc);
822 astnode_replace(expr, c);
823 astnode_finalize(expr);
824 expr = c;
825 ok = 1;
826 break;
827
828 case RECORD_SYMBOL:
829 case ENUM_SYMBOL:
830 /* 1 byte */
831 c = astnode_create_integer(1, expr->loc);
832 astnode_replace(expr, c);
833 astnode_finalize(expr);
834 expr = c;
835 ok = 1;
836 break;
837
838 default:
839 /* Dunno the size of this symbol type */
840 break;
841 }
842 }
843 if (!ok) {
844 /* Datatype not defined, error */
845 err(expr->loc, "size of `%s' is unknown", id->ident);
846 /* Replace by 1 */
847 c = astnode_create_integer(1, expr->loc);
848 astnode_replace(expr, c);
849 astnode_finalize(expr);
850 return c;
851 }
852 break;
853
854 default:
855 err(expr->loc, "substitute_sizeof(): unknown type");
856 break;
857 }
858 if (count != NULL) {
859 c = astnode_create_arithmetic(
860 MUL_OPERATOR,
861 astnode_clone(expr, expr->loc),
862 count,
863 expr->loc
864 );
865 astnode_replace(expr, c);
866 astnode_finalize(expr);
867 expr = c;
868 }
869 return expr;
870 }
871
872 /**
873 * Substitutes A::B with an expression.
874 * If A is a struct: substitute with offset of B
875 * If A is a union: substitute with 0
876 * If A is an enumeration: substitute with value for B
877 * @param expr Node of type SCOPE_NODE
878 */
879 static astnode *reduce_scope(astnode *expr)
880 {
881 symtab_entry *ns;
882 symtab_entry *sym;
883 astnode *c;
884 astnode *namespace;
885 astnode *symbol;
886 /* Look up the namespace */
887 namespace = LHS(expr);
888 ns = symtab_lookup(namespace->ident);
889 if (ns != NULL) {
890 /* Look up the local symbol */
891 symtab_push(ns->symtab);
892 symbol = RHS(expr);
893 sym = symtab_lookup(symbol->ident);
894 if (sym != NULL) {
895 /* See if we can replace it */
896 switch (ns->type) {
897 case STRUC_SYMBOL:
898 case UNION_SYMBOL:
899 case RECORD_SYMBOL:
900 /* Replace with field offset */
901 c = astnode_clone(sym->field.offset, sym->field.offset->loc);
902 astnode_replace(expr, c);
903 astnode_finalize(expr);
904 expr = c;
905 break;
906
907 case ENUM_SYMBOL:
908 /* Replace with enum entry value */
909 c = astnode_clone(sym->def, sym->def->loc);
910 astnode_replace(expr, c);
911 astnode_finalize(expr);
912 expr = c;
913 break;
914
915 default:
916 break;
917 }
918 }
919 symtab_pop();
920 }
921 return expr;
922 }
923
924 static astnode *reduce_expression(astnode *expr);
925
926 /**
927 * Handles remainder of fields in A.B.C.D . ..., where one or more fields may be indexed.
928 * @param expr Node of type DOT_NODE, INDEX_NODE or IDENTIFIER_NODE
929 */
930 static astnode *reduce_dot_recursive(astnode *expr)
931 {
932 astnode *term;
933 astnode *offset;
934 astnode *left;
935 astnode *right;
936 astnode *type;
937 symtab_entry *field;
938 symtab_entry *def;
939 astnode *index = NULL;
940 /* Get identifiers involved: 'right' is field in 'left' */
941 left = LHS(expr);
942 if (astnode_is_type(left, INDEX_NODE)) {
943 left = LHS(left); /* Need identifier */
944 }
945 right = RHS(expr);
946 if (astnode_is_type(right, DOT_NODE)) {
947 right = LHS(right); /* Need identifier */
948 }
949 if (astnode_is_type(right, INDEX_NODE)) {
950 index = RHS(right);
951 right = LHS(right); /* Need identifier */
952 }
953 /* Lookup 'right' in 'left's symbol table (on stack) */
954 field = symtab_lookup(right->ident);
955 /* Look up variable's type definition */
956 type = LHS(field->def);
957 /* Copy its offset */
958 offset = astnode_clone(field->field.offset, right->loc);
959 if (index != NULL) {
960 /* Create expression: identifier + sizeof(datatype) * index */
961 offset = astnode_create_arithmetic(
962 PLUS_OPERATOR,
963 offset,
964 astnode_create_arithmetic(
965 MUL_OPERATOR,
966 astnode_create_sizeof(astnode_clone(type, type->loc), expr->loc),
967 astnode_clone(index, index->loc),
968 index->loc
969 ),
970 expr->loc
971 );
972 }
973 /* See if more subfields to process */
974 expr = RHS(expr);
975 if (astnode_is_type(expr, DOT_NODE)) {
976 /* Next field */
977 def = symtab_global_lookup(LHS(type)->ident);
978 symtab_push(def->symtab);
979 term = reduce_dot_recursive(expr);
980 symtab_pop();
981 /* Construct sum */
982 offset = astnode_create_arithmetic(
983 PLUS_OPERATOR,
984 offset,
985 term,
986 expr->loc
987 );
988 }
989 return offset;
990 }
991
992 /**
993 * Transforms A.B.C.D . ... to A + offset(B) + offset(C) + ...
994 * No error checking, since validate_dotref() should have been called previously.
995 * @param expr Node of type DOT_NODE
996 */
997 static astnode *reduce_dot(astnode *expr)
998 {
999 symtab_entry *father;
1000 symtab_entry *def;
1001 astnode *type;
1002 astnode *left;
1003 astnode *term1;
1004 astnode *term2;
1005 astnode *sum;
1006 astnode *index = NULL;
1007 /* Look up parent in global symbol table */
1008 left = LHS(expr); /* expr := left . right */
1009 if (astnode_is_type(left, INDEX_NODE)) {
1010 index = RHS(left);
1011 left = LHS(left); /* Need identifier */
1012 }
1013 father = symtab_lookup(left->ident);
1014 /* Look up variable's type definition */
1015 type = LHS(father->def); /* DATATYPE_NODE */
1016 def = symtab_lookup(LHS(type)->ident);
1017 /* 1st term of sum is the leftmost structure identifier */
1018 term1 = astnode_clone(left, left->loc);
1019 if (index != NULL) {
1020 /* Create expression: identifier + sizeof(datatype) * index */
1021 term1 = astnode_create_arithmetic(
1022 PLUS_OPERATOR,
1023 term1,
1024 astnode_create_arithmetic(
1025 MUL_OPERATOR,
1026 astnode_create_sizeof(astnode_clone(type, type->loc), expr->loc),
1027 astnode_clone(index, index->loc),
1028 index->loc
1029 ),
1030 expr->loc
1031 );
1032 }
1033 /* Add offsets recursively */
1034 symtab_push(def->symtab);
1035 term2 = reduce_dot_recursive(expr);
1036 symtab_pop();
1037 /* Calculate final sum */
1038 sum = astnode_create_arithmetic(
1039 PLUS_OPERATOR,
1040 term1,
1041 term2,
1042 expr->loc
1043 );
1044 sum = reduce_expression(sum);
1045 /* Replace dotted expression by sum */
1046 astnode_replace(expr, sum);
1047 astnode_finalize(expr);
1048 return sum;
1049 }
1050
1051 /**
1052 * Reduces MASK operation to a field mask.
1053 * @param mask A node of type MASK_NODE
1054 */
1055 static astnode *reduce_mask(astnode *mask)
1056 {
1057 symtab_entry *ns;
1058 symtab_entry *sym;
1059 astnode *c;
1060 astnode *namespace;
1061 astnode *symbol;
1062 astnode *expr;
1063 /* Child is a scope node, record::field */
1064 expr = LHS(mask);
1065 /* Look up the namespace */
1066 namespace = LHS(expr);
1067 ns = symtab_lookup(namespace->ident);
1068 if (ns != NULL) {
1069 /* Make sure it's a record */
1070 if (ns->type != RECORD_SYMBOL) {
1071 err(expr->loc, "`%s' is not a record");
1072 /* Replace by 0 */
1073 c = astnode_create_integer(0, expr->loc);
1074 astnode_replace(mask, c);
1075 astnode_finalize(mask);
1076 expr = c;
1077 }
1078 else {
1079 /* Look up the local symbol */
1080 symtab_push(ns->symtab);
1081 symbol = RHS(expr);
1082 sym = symtab_lookup(symbol->ident);
1083 if (sym != NULL) {
1084 /* Calculate field mask */
1085 // mask = ((1 << width) - 1) << offset
1086 c = astnode_create_arithmetic(
1087 SHL_OPERATOR,
1088 astnode_create_arithmetic(
1089 MINUS_OPERATOR,
1090 astnode_create_arithmetic(
1091 SHL_OPERATOR,
1092 astnode_create_integer(1, expr->loc),
1093 astnode_clone(sym->field.size, expr->loc),
1094 expr->loc
1095 ),
1096 astnode_create_integer(1, expr->loc),
1097 expr->loc
1098 ),
1099 astnode_clone(sym->field.offset, expr->loc),
1100 expr->loc
1101 );
1102 c = reduce_expression(c);
1103 astnode_replace(mask, c);
1104 astnode_finalize(mask);
1105 expr = c;
1106 }
1107 symtab_pop();
1108 }
1109 }
1110 return expr;
1111 }
1112
1113 /**
1114 * Reduces identifier[expression] to identifier + sizeof(identifier type) * expression
1115 */
1116 static astnode *reduce_index(astnode *expr)
1117 {
1118 symtab_entry *e;
1119 astnode *c;
1120 astnode *type;
1121 astnode *id;
1122 astnode *index;
1123 id = LHS(expr);
1124 assert(astnode_is_type(id, IDENTIFIER_NODE));
1125 index = reduce_expression(RHS(expr));
1126 /* Lookup identifier */
1127 e = symtab_lookup(id->ident);
1128 assert(e != 0);
1129 /* Get its datatype */
1130 type = LHS(e->def);
1131 /* Create expression: identifier + sizeof(datatype) * index */
1132 c = astnode_create_arithmetic(
1133 PLUS_OPERATOR,
1134 astnode_clone(id, id->loc),
1135 astnode_create_arithmetic(
1136 MUL_OPERATOR,
1137 astnode_create_sizeof(astnode_clone(type, type->loc), expr->loc),
1138 astnode_clone(index, index->loc),
1139 index->loc
1140 ),
1141 expr->loc
1142 );
1143 /* Replace index expression */
1144 astnode_replace(expr, c);
1145 astnode_finalize(expr);
1146 return c;
1147 }
1148
1149 /**
1150 * Substitutes all identifiers that represent EQU defines with their
1151 * corresponding expression.
1152 * @param expr The expression whose defines to substitute
1153 */
1154 static astnode *substitute_defines(astnode *expr)
1155 {
1156 switch (astnode_get_type(expr)) {
1157 case ARITHMETIC_NODE:
1158 substitute_defines(LHS(expr));
1159 substitute_defines(RHS(expr));
1160 break;
1161
1162 case IDENTIFIER_NODE:
1163 expr = substitute_ident(expr);
1164 break;
1165
1166 case SIZEOF_NODE:
1167 expr = reduce_sizeof(expr);
1168 break;
1169
1170 case MASK_NODE:
1171 expr = reduce_mask(expr);
1172 break;
1173
1174 case INDEX_NODE:
1175 substitute_defines(LHS(expr));
1176 substitute_defines(RHS(expr));
1177 break;
1178
1179 case DOT_NODE:
1180 substitute_defines(LHS(expr));
1181 substitute_defines(RHS(expr));
1182 break;
1183
1184 default:
1185 /* Nada */
1186 break;
1187 }
1188 return expr;
1189 }
1190
1191 /**
1192 *
1193 */
1194 static astnode *reduce_highlevel_constructs(astnode *expr)
1195 {
1196 switch (astnode_get_type(expr)) {
1197 case ARITHMETIC_NODE:
1198 reduce_highlevel_constructs(LHS(expr));
1199 reduce_highlevel_constructs(RHS(expr));
1200 break;
1201
1202 case SCOPE_NODE:
1203 expr = reduce_scope(expr);
1204 break;
1205
1206 case DOT_NODE:
1207 expr = reduce_dot(expr);
1208 break;
1209
1210 case INDEX_NODE:
1211 expr = reduce_index(expr);
1212 break;
1213
1214 default:
1215 /* Nada */
1216 break;
1217 }
1218 return expr;
1219 }
1220
1221 /**
1222 * Really reduces an expression.
1223 * @param expr Expression to attempt to reduce
1224 */
1225 static astnode *reduce_expression_complete(astnode *expr)
1226 {
1227 return astproc_fold_constants( reduce_highlevel_constructs( substitute_defines(expr) ) );
1228 }
1229
1230 /**
1231 * Reduces an expression.
1232 * It does two things:
1233 * 1. Substitute all equates by their value
1234 * 2. Folds constants in the resulting expression
1235 * If the expression is reduced, the original expression is replaced by the
1236 * new one, the original is finalized, and a pointer to the new expression
1237 * is returned.
1238 * If the expression is not reduced, the original pointer is returned.
1239 */
1240 static astnode *reduce_expression(astnode *expr)
1241 {
1242 return astproc_fold_constants( substitute_defines(expr) );
1243 }
1244
1245 /**
1246 * Reduces RECORD instance to a single byte (DB statement).
1247 * @param r Record's symbol table entry
1248 * @param expr Record initializer
1249 * @param flat List on which to append the reduced form
1250 */
1251 static void reduce_record(symtab_entry *r, astnode *init, astnode *flat)
1252 {
1253 ordered_field_list *list;
1254 symtab_entry *e;
1255 astnode *val;
1256 astnode *term;
1257 astnode *result;
1258 astnode *mask;
1259 astnode *repl;
1260 if (!astnode_is_type(init, STRUC_NODE)) {
1261 err(init->loc, "record initializer expected");
1262 return;
1263 }
1264 /* Go through fields */
1265 symtab_push(r->symtab);
1266 result = astnode_create_integer(0, init->loc);
1267 for (val = init->first_child, list = r->struc.fields; (val != NULL) && (list != NULL); list = list->next, val = val->next_sibling) {
1268 if (astnode_is_type(val, NULL_NODE)) {
1269 continue;
1270 }
1271 if (astnode_is_type(val, STRUC_NODE)) {
1272 err(init->loc, "record field initializer expected");
1273 continue;
1274 }
1275 /* Get field definition */
1276 e = list->entry;
1277 /* Calculate field mask */
1278 // mask = ((1 << width) - 1) << offset
1279 mask = astnode_create_arithmetic(
1280 SHL_OPERATOR,
1281 astnode_create_arithmetic(
1282 MINUS_OPERATOR,
1283 astnode_create_arithmetic(
1284 SHL_OPERATOR,
1285 astnode_create_integer(1, val->loc),
1286 astnode_clone(e->field.size, val->loc),
1287 val->loc
1288 ),
1289 astnode_create_integer(1, val->loc),
1290 val->loc
1291 ),
1292 astnode_clone(e->field.offset, val->loc),
1293 val->loc
1294 );
1295 /* Shift val left e->field.offset bits, AND with mask */
1296 term = astnode_create_arithmetic(
1297 AND_OPERATOR,
1298 astnode_create_arithmetic(
1299 SHL_OPERATOR,
1300 astnode_clone(val, val->loc),
1301 astnode_clone(e->field.offset, val->loc),
1302 val->loc
1303 ),
1304 mask,
1305 val->loc
1306 );
1307 /* OR the value with the result so far */
1308 result = astnode_create_arithmetic(
1309 OR_OPERATOR,
1310 result,
1311 term,
1312 val->loc
1313 );
1314 result = reduce_expression(result);
1315 }
1316 /* Determine reason for stopping loop */
1317 if (val != NULL) {
1318 err(init->loc, "too many field initializers");
1319 }
1320 /* Make byte data node (packed record value) */
1321 repl = astnode_create_data(
1322 astnode_create_datatype(BYTE_DATATYPE, NULL, init->loc),
1323 result,
1324 init->loc
1325 );
1326 astnode_add_child(flat, repl);
1327 symtab_pop();
1328 }
1329
1330 /**
1331 * Reduces ENUM instance to DB.
1332 * @param e Enumeration's symbol table entry
1333 * @param expr Expression
1334 * @param flat List on which to append the reduced form
1335 */
1336 static void reduce_enum(symtab_entry *e, astnode *expr, astnode *list)
1337 {
1338 symtab_entry *sym;
1339 astnode *repl;
1340 if (!astnode_is_type(expr, IDENTIFIER_NODE)) {
1341 err(expr->loc, "identifier expected");
1342 }
1343 else {
1344 /* Look up the enumeration symbol */
1345 symtab_push(e->symtab);
1346 sym = symtab_lookup(expr->ident);
1347 symtab_pop();
1348 /* Make byte data node (symbol value) */
1349 repl = astnode_create_data(
1350 astnode_create_datatype(BYTE_DATATYPE, NULL, expr->loc),
1351 astnode_clone(sym->def, expr->loc),
1352 expr->loc
1353 );
1354 astnode_add_child(list, repl);
1355 }
1356 }
1357
1358 static void flatten_struc_recursive(symtab_entry *s, astnode *init, astnode *flat);
1359
1360 /**
1361 * Flattens a union initializer to a sequence of native data values.
1362 * Verify similar to flattening of structure, but only single field allowed.
1363 * @param s Union's symbol table definition
1364 * @param init Union initializer
1365 * @param flat List on which to append the flattened form
1366 */
1367 static void flatten_union_recursive(symtab_entry *s, astnode *init, astnode *flat)
1368 {
1369 astnode *fill;
1370 astnode *type;
1371 astnode *count;
1372 symtab_entry *e;
1373 symtab_entry *t;
1374 astnode *val;
1375 astnode *valvals;
1376 astnode *temp;
1377 ordered_field_list *list;
1378 int num;
1379 if (!astnode_is_type(init, STRUC_NODE)) {
1380 err(init->loc, "union initializer expected");
1381 return;
1382 }
1383 /* Go through fields */
1384 symtab_push(s->symtab);
1385 fill = astnode_clone(s->struc.size, flat->loc);
1386 for (val = init->first_child, list = s->struc.fields; (val != NULL) && (list != NULL); list = list->next, val = val->next_sibling) {
1387 if (astnode_is_type(val, NULL_NODE)) {
1388 continue;
1389 }
1390 if (!astnode_equal(fill, s->struc.size)) {
1391 err(init->loc, "only one field of union can be initialized");
1392 continue;
1393 }
1394 /* Get field definition */
1395 e = list->entry;
1396 /* Symbol definition is STORAGE_NODE w/ two children: type and count */
1397 type = LHS(e->def);
1398 count = RHS(e->def);
1399 /* Decide what to do based on field type and value */
1400 switch (type->datatype) {
1401 case BYTE_DATATYPE:
1402 case CHAR_DATATYPE:
1403 case WORD_DATATYPE:
1404 case DWORD_DATATYPE:
1405 if (astnode_is_type(val, STRUC_NODE)) {
1406 /* Handle multi-value array */
1407 temp = astnode_clone(val, val->loc);
1408 valvals = astnode_remove_children(temp);
1409 astnode_finalize(temp);
1410 astnode_add_child(flat,
1411 astnode_create_data(
1412 astnode_create_datatype(type->datatype, NULL, type->loc),
1413 valvals,
1414 val->loc
1415 )
1416 );
1417 num = astnode_get_child_count(val);
1418 } else {
1419 /* Output single value */
1420 astnode_add_child(flat,
1421 astnode_create_data(
1422 astnode_create_datatype(type->datatype, NULL, type->loc),
1423 astnode_clone(val, val->loc),
1424 val->loc
1425 )
1426 );
1427 num = astnode_is_type(val, STRING_NODE) ? strlen(val->string) : 1;
1428 }
1429 if (num > count->integer) {
1430 err(val->loc, "initializer for field `%s' exceeds field size", e->id);
1431 }
1432 /* Fill in remainder of field if necessary: count - 1 */
1433 else if (count->integer > num) {
1434 astnode_add_child(flat,
1435 astnode_create_storage(
1436 astnode_create_datatype(type->datatype, NULL, type->loc),
1437 astproc_fold_constants(
1438 astnode_create_arithmetic(
1439 MINUS_OPERATOR,
1440 astnode_clone(count, count->loc),
1441 astnode_create_integer(num, flat->loc),
1442 count->loc
1443 )
1444 ),
1445 val->loc
1446 )
1447 );
1448 }
1449 break;
1450
1451 case USER_DATATYPE:
1452 t = symtab_global_lookup(LHS(type)->ident);
1453 switch (t->type) {
1454 case STRUC_SYMBOL:
1455 flatten_struc_recursive(t, val, flat);
1456 break;
1457
1458 case UNION_SYMBOL:
1459 flatten_union_recursive(t, val, flat);
1460 break;
1461
1462 case RECORD_SYMBOL:
1463 reduce_record(t, val, flat);
1464 break;
1465
1466 case ENUM_SYMBOL:
1467 reduce_enum(t, val, flat);
1468 break;
1469
1470 default:
1471 break;
1472 }
1473 break;
1474 }
1475 /* Decrease fill amount according to field size */
1476 fill = astproc_fold_constants(
1477 astnode_create_arithmetic(
1478 MINUS_OPERATOR,
1479 fill,
1480 astnode_clone(e->field.size, flat->loc),
1481 flat->loc
1482 )
1483 );
1484 }
1485 if (val != NULL) {
1486 err(init->loc, "too many field initializers");
1487 }
1488 if (fill->integer > 0) {
1489 /* Fill remainder of union with zeroes */
1490 astnode_add_child(flat,
1491 astnode_create_storage(
1492 astnode_create_datatype(BYTE_DATATYPE, NULL, flat->loc),
1493 fill,
1494 flat->loc
1495 )
1496 );
1497 }
1498 symtab_pop();
1499 }
1500
1501 /**
1502 * Flattens a structure initializer to a sequence of native data values.
1503 * @param s Structure's symbol table definition
1504 * @param init Structure initializer
1505 * @param flat List on which to append the flattened form
1506 */
1507 static void flatten_struc_recursive(symtab_entry *s, astnode *init, astnode *flat)
1508 {
1509 astnode *fill;
1510 astnode *type;
1511 astnode *count;
1512 astnode *temp;
1513 symtab_entry *e;
1514 symtab_entry *t;
1515 astnode *val;
1516 astnode *valvals;
1517 ordered_field_list *list;
1518 int num;
1519 if (!astnode_is_type(init, STRUC_NODE)) {
1520 err(init->loc, "structure initializer expected");
1521 return;
1522 }
1523 /* Go through fields */
1524 symtab_push(s->symtab);
1525 fill = astnode_clone(s->struc.size, flat->loc);
1526 for (val = init->first_child, list = s->struc.fields; (val != NULL) && (list != NULL); list = list->next, val = val->next_sibling) {
1527 e = list->entry;
1528 /* Check if normal field or anonymous union */
1529 if (e->type == UNION_SYMBOL) {
1530 if (astnode_is_type(val, NULL_NODE)) {
1531 /* Output union size bytes to fill in field */
1532 astnode_add_child(flat,
1533 astnode_create_storage(
1534 astnode_create_datatype(BYTE_DATATYPE, NULL, val->loc),
1535 astnode_clone(e->struc.size, val->loc),
1536 val->loc
1537 )
1538 );
1539 } else {
1540 flatten_union_recursive(e, val, flat);
1541 /* Decrease fill amount according to union size */
1542 fill = astproc_fold_constants(
1543 astnode_create_arithmetic(
1544 MINUS_OPERATOR,
1545 fill,
1546 astnode_clone(e->struc.size, flat->loc),
1547 flat->loc
1548 )
1549 );
1550 }
1551 } else {
1552 /* VAR_SYMBOL */
1553 /* Symbol definition is STORAGE_NODE w/ two children: type and count */
1554 type = LHS(e->def);
1555 count = RHS(e->def);
1556 /* Decide what to do based on field type and value */
1557 switch (type->datatype) {
1558 case BYTE_DATATYPE:
1559 case CHAR_DATATYPE:
1560 case WORD_DATATYPE:
1561 case DWORD_DATATYPE:
1562 if (astnode_is_type(val, NULL_NODE)) {
1563 /* Output field_size bytes to fill in field */
1564 astnode_add_child(flat,
1565 astnode_create_storage(
1566 astnode_create_datatype(type->datatype, NULL, type->loc),
1567 astnode_clone(count, count->loc),
1568 val->loc
1569 )
1570 );
1571 } else {
1572 if (astnode_is_type(val, STRUC_NODE)) {
1573 /* Handle multi-value array */
1574 temp = astnode_clone(val, val->loc);
1575 valvals = astnode_remove_children(temp);
1576 astnode_finalize(temp);
1577 astnode_add_child(flat,
1578 astnode_create_data(
1579 astnode_create_datatype(type->datatype, NULL, type->loc),
1580 valvals,
1581 val->loc
1582 )
1583 );
1584 num = astnode_get_child_count(val);
1585 } else {
1586 /* Output single value */
1587 astnode_add_child(flat,
1588 astnode_create_data(
1589 astnode_create_datatype(type->datatype, NULL, type->loc),
1590 astnode_clone(val, val->loc),
1591 val->loc
1592 )
1593 );
1594 num = astnode_is_type(val, STRING_NODE) ? strlen(val->string) : 1;
1595 }
1596 if (astnode_is_type(count, INTEGER_NODE) && (count->integer < num)) {
1597 err(val->loc, "initializer for field `%s' exceeds field size", e->id);
1598 }
1599 /* Fill in remainder of field if necessary: count - 1 */
1600 else if ( (astnode_is_type(count, INTEGER_NODE) && (count->integer > num))
1601 || !astnode_is_type(count, INTEGER_NODE) ) {
1602 astnode_add_child(flat,
1603 astnode_create_storage(
1604 astnode_create_datatype(type->datatype, NULL, flat->loc),
1605 astproc_fold_constants(
1606 astnode_create_arithmetic(
1607 MINUS_OPERATOR,
1608 astnode_clone(count, flat->loc),
1609 astnode_create_integer(num, flat->loc),
1610 flat->loc
1611 )
1612 ),
1613 flat->loc
1614 )
1615 );
1616 }
1617 }
1618 break;
1619
1620 case USER_DATATYPE:
1621 t = symtab_global_lookup(LHS(type)->ident);
1622 if (astnode_is_type(val, NULL_NODE)) {
1623 /* Output sizeof(type) bytes to fill in */
1624 astnode_add_child(flat,
1625 astnode_create_storage(
1626 astnode_create_datatype(BYTE_DATATYPE, NULL, val->loc),
1627 astnode_clone(t->struc.size, val->loc),
1628 val->loc
1629 )
1630 );
1631 } else {
1632 switch (t->type) {
1633 case STRUC_SYMBOL:
1634 flatten_struc_recursive(t, val, flat);
1635 break;
1636
1637 case UNION_SYMBOL:
1638 flatten_union_recursive(t, val, flat);
1639 break;
1640
1641 case RECORD_SYMBOL:
1642 reduce_record(t, val, flat);
1643 break;
1644
1645 case ENUM_SYMBOL:
1646 reduce_enum(t, val, flat);
1647 break;
1648
1649 default:
1650 break;
1651 }
1652 }
1653 break;
1654 }
1655 /* Decrease fill amount according to field size */
1656 fill = astproc_fold_constants(
1657 astnode_create_arithmetic(
1658 MINUS_OPERATOR,
1659 fill,
1660 astnode_clone(e->field.size, flat->loc),
1661 flat->loc
1662 )
1663 );
1664 }
1665 }
1666 if (val != NULL) {
1667 err(init->loc, "too many field initializers");
1668 }
1669 else if (list != NULL) {
1670 /* All fields not initialized; fill remainder of struc with zeroes */
1671 astnode_add_child(flat,
1672 astnode_create_storage(
1673 astnode_create_datatype(BYTE_DATATYPE, NULL, flat->loc),
1674 fill,
1675 flat->loc
1676 )
1677 );
1678 } else {
1679 astnode_finalize(fill);
1680 }
1681 symtab_pop();
1682 }
1683
1684 /**
1685 * Converts data that is expressed in a high-level form (such as structure initializers)
1686 * to a simple sequence of bytes.
1687 * @param n The source node to flatten
1688 * @param type The type of data that n is an instance of
1689 * @param list List on which to append the resulting sequence of items (bytes/words/dwords)
1690 */
1691 static void flatten_user_data(astnode *n, astnode *type, astnode *list)
1692 {
1693 symtab_entry *def;
1694 def = symtab_global_lookup(LHS(type)->ident);
1695 if (def != NULL) {
1696 switch (def->type) {
1697 case STRUC_SYMBOL:
1698 flatten_struc_recursive(def, n, list);
1699 break;
1700
1701 case UNION_SYMBOL:
1702 flatten_union_recursive(def, n, list);
1703 break;
1704
1705 case RECORD_SYMBOL:
1706 reduce_record(def, n, list);
1707 break;
1708
1709 case ENUM_SYMBOL:
1710 reduce_enum(def, n, list);
1711 break;
1712
1713 default:
1714 break;
1715 }
1716 }
1717 }
1718
1719 /*---------------------------------------------------------------------------*/
1720
1721 /**
1722 * Loads the character map specified by the node.
1723 * @param n Node of type CHARMAP_NODE
1724 */
1725 static int load_charmap(astnode *n, void *arg, astnode **next)
1726 {
1727 /* TODO: should probably be done in the parsing phase (same path resolution as for INCSRC and INCBIN) */
1728 astnode *file;
1729 file = astnode_get_child(n, 0);
1730 if (charmap_parse(file->file_path, charmap) == 0) {
1731 err(n->loc, "could not open `%s' for reading", file->file_path);
1732 }
1733 return 0;
1734 }
1735
1736 /**
1737 * First-time processing of instruction node.
1738 * @param instr Node of type INSTRUCTION_NODE
1739 * @param arg Not used
1740 */
1741 static int process_instruction(astnode *instr, void *arg, astnode **next)
1742 {
1743 astnode *expr;
1744 if (in_dataseg) {
1745 err(instr->loc, "instructions not allowed in data segment");
1746 astnode_remove(instr);
1747 astnode_finalize(instr);
1748 return 0;
1749 }
1750 else {
1751 expr = astnode_get_child(instr, 0);
1752 reduce_expression(expr);
1753 return 1;
1754 }
1755 }
1756
1757 /**
1758 * First-time processing of data node.
1759 * @param data Node of type DATA_NODE
1760 * @param arg Not used
1761 */
1762 static int process_data(astnode *data, void *arg, astnode **next)
1763 {
1764 int j;
1765 int k;
1766 astnode *type;
1767 astnode *expr;
1768 astnode *list;
1769 astnode *stmts;
1770 type = astnode_get_child(data, 0);
1771 assert(astnode_is_type(type, DATATYPE_NODE));
1772 if (in_dataseg) {
1773 err(data->loc, "value not allowed in data segment");
1774 /* Replace with storage node */
1775 astnode_replace(
1776 data,
1777 astnode_create_storage(
1778 astnode_create_datatype(BYTE_DATATYPE, NULL, data->loc),
1779 astnode_create_integer(1, data->loc),
1780 data->loc
1781 )
1782 );
1783 astnode_finalize(data);
1784 return 0;
1785 }
1786 if (type->datatype == USER_DATATYPE) {
1787 /* Make sure the type exists */
1788 if (symtab_global_lookup(LHS(type)->ident) == NULL) {
1789 err(data->loc, "unknown type `%s'", LHS(type)->ident);
1790 astnode_remove(data);
1791 astnode_finalize(data);
1792 return 0;
1793 } else {
1794 /* Attempt to reduce user data to native data */
1795 list = astnode_create(LIST_NODE, data->loc);
1796 for (expr = type->next_sibling; expr != NULL; expr = expr->next_sibling) {
1797 flatten_user_data(expr, type, list);
1798 }
1799 /* Replace initializers with generated list */
1800 stmts = astnode_remove_children(list);
1801 astnode_replace(data, stmts);
1802 astnode_finalize(data);
1803 astnode_finalize(list);
1804 *next = stmts;
1805 return 0;
1806 }
1807 }
1808 /* Go through the list of data values, replacing defines and folding constants */
1809 for (j=1; j<astnode_get_child_count(data); j++) {
1810 expr = astnode_get_child(data, j);
1811 /* Substitute defines and fold constants */
1812 expr = reduce_expression(expr);
1813 /* If it's a string, replace by array of integers */
1814 /* (makes it easier to process later... favour regularity) */
1815 if (astnode_is_type(expr, STRING_NODE)) {
1816 astnode_remove_child(data, expr); /* Remove string */
1817 for (k=strlen(expr->string)-1; k>=0; k--) {
1818 /* Check if we should map character from custom charmap */
1819 if (type->datatype == CHAR_DATATYPE) {
1820 expr->string[k] = charmap[(unsigned)expr->string[k]];
1821 }
1822 /* Append character value to array */
1823 astnode_insert_child(data, astnode_create_integer((unsigned char)expr->string[k], data->loc), j);
1824 }
1825 if (type->datatype == CHAR_DATATYPE) {
1826 /* It's normal byte array now */
1827 type->datatype = BYTE_DATATYPE;
1828 }
1829 j += strlen(expr->string)-1;
1830 astnode_finalize(expr);
1831 }
1832 }
1833 return 1;
1834 }
1835
1836 /**
1837 * First-time processing of storage node.
1838 * @param storage Node of type STORAGE_NODE
1839 * @param arg Not used
1840 */
1841 static int process_storage(astnode *storage, void *arg, astnode **next)
1842 {
1843 int item_size;
1844 astnode *type;
1845 astnode *expr;
1846 astnode *new_expr;
1847 type = LHS(storage);
1848 expr = RHS(storage);
1849 /* If not BYTE_DATATYPE, multiply by word/dword-size */
1850 switch (type->datatype) {
1851 case BYTE_DATATYPE:
1852 case CHAR_DATATYPE: item_size = 1; break;
1853 case WORD_DATATYPE: item_size = 2; break;
1854 case DWORD_DATATYPE: item_size = 4; break;
1855 default: item_size = 1; break; // ### Hmmm...
1856 }
1857 if (item_size != 1) {
1858 new_expr = astnode_create_arithmetic(
1859 MUL_OPERATOR,
1860 astnode_clone(expr, expr->loc),
1861 astnode_create_integer(item_size, expr->loc),
1862 expr->loc
1863 );
1864 astnode_replace(expr, new_expr);
1865 astnode_finalize(expr);
1866 expr = new_expr;
1867 type->datatype = BYTE_DATATYPE;
1868 }
1869 /* Substitute defines and fold constants */
1870 expr = reduce_expression(expr);
1871 // TODO: Validate range somewhere else than here please... ???
1872 if (astnode_is_type(expr, INTEGER_NODE)) {
1873 if ((expr->integer <= 0) || (expr->integer >= 0x10000)) {
1874 err(storage->loc, "operand out of range");
1875 }
1876 }
1877 return 1;
1878 }
1879
1880 /**
1881 * Process EQU node.
1882 * @param equ Node of type EQU_NODE
1883 * @param arg Not used
1884 */
1885 static int process_equ(astnode *equ, void *arg, astnode **next)
1886 {
1887 symtab_entry *e;
1888 astnode *id;
1889 astnode *expr;
1890 expr = astnode_clone(astnode_get_child(equ, 1), equ->loc);
1891 expr = reduce_expression(expr);
1892 id = astnode_get_child(equ, 0);
1893 assert(astnode_is_type(id, IDENTIFIER_NODE));
1894 e = symtab_lookup(id->ident);
1895 if (e == NULL) {
1896 // TODO: Check that expression is a constant?
1897 symtab_enter(id->ident, CONSTANT_SYMBOL, expr, 0);
1898 } else {
1899 /* Symbol is being redefined */
1900 /* This is not allowed for EQU equate! */
1901 if (!astnode_equal((astnode *)(e->def), expr)) {
1902 warn(equ->loc, "redefinition of `%s' is not identical; ignored", id->ident);
1903 }
1904 }
1905 astnode_remove(equ);
1906 astnode_finalize(equ);
1907 return 0;
1908 }
1909
1910 /**
1911 * Process '=' node.
1912 * @param assign Node of type ASSIGN_NODE
1913 * @param arg Not used
1914 */
1915 static int process_assign(astnode *assign, void *arg, astnode **next)
1916 {
1917 symtab_entry *e;
1918 astnode *id;
1919 astnode *expr;
1920 /* If it's part of ENUM declaration, don't touch */
1921 if (astnode_has_ancestor_of_type(assign, ENUM_DECL_NODE)) {
1922 return 0;
1923 }
1924 /* Very similar to EQU, except symbol 1) can be
1925 redefined and 2) is volatile (see end of proc) */
1926 expr = astnode_clone(astnode_get_child(assign, 1), assign->loc);
1927 expr = reduce_expression(expr);
1928 id = astnode_get_child(assign, 0);
1929 assert(astnode_is_type(id, IDENTIFIER_NODE));
1930 e = symtab_lookup(id->ident);
1931 if (e == NULL) {
1932 /* Symbol is being defined for the first time */
1933 /* Note that the VOLATILE_FLAG is set */
1934 symtab_enter(id->ident, CONSTANT_SYMBOL, expr, VOLATILE_FLAG);
1935 } else {
1936 /* Symbol is being redefined */
1937 /* This is OK for ASSIGN equate, simply replace definition */
1938 // ### store a list of definitions, otherwise we leak
1939 expr->loc = e->def->loc;
1940 e->def = expr;
1941 }
1942 astnode_remove(assign);
1943 astnode_finalize(assign);
1944 return 0;
1945 }
1946
1947 /**
1948 * Process IFDEF-node.
1949 * @param ifdef Node of type IFDEF_NODE
1950 * @param arg Not used
1951 */
1952 static int process_ifdef(astnode *ifdef, void *arg, astnode **next)
1953 {
1954 symtab_entry *e;
1955 astnode *id;
1956 astnode *stmts;
1957 id = astnode_get_child(ifdef, 0);
1958 assert(astnode_is_type(id, IDENTIFIER_NODE));
1959 e = symtab_lookup(id->ident);
1960 if (e != NULL) {
1961 /* Symbol is defined. */
1962 /* Replace IFDEF node by the true-branch statement list */
1963 stmts = astnode_remove_children(astnode_get_child(ifdef, 1));
1964 astnode_replace(ifdef, stmts);
1965 *next = stmts;
1966 } else {
1967 /* Symbol is not defined. */
1968 /* Replace IFDEF node by the false-branch statement list (if any) */
1969 stmts = astnode_remove_children( astnode_get_child(ifdef, 2));
1970 if (stmts != NULL) {
1971 astnode_replace(ifdef, stmts);
1972 *next = stmts;
1973 } else {
1974 astnode_remove(ifdef);
1975 }
1976 }
1977 astnode_finalize(ifdef);
1978 return 0;
1979 }
1980
1981 /**
1982 * Process IFNDEF-node.
1983 * @param ifndef Node of type IFNDEF_NODE
1984 * @param arg Not used
1985 */
1986 static int process_ifndef(astnode *ifndef, void *arg, astnode **next)
1987 {
1988 symtab_entry *e;
1989 astnode *id;
1990 astnode *stmts;
1991 id = astnode_get_child(ifndef, 0);
1992 assert(astnode_is_type(id, IDENTIFIER_NODE));
1993 e = symtab_lookup(id->ident);
1994 if (e == NULL) {
1995 /* Symbol is not defined. */
1996 /* Replace IFNDEF node by the true-branch statement list */
1997 stmts = astnode_remove_children(astnode_get_child(ifndef, 1));
1998 astnode_replace(ifndef, stmts);
1999 *next = stmts;
2000 } else {
2001 /* Symbol is defined. */
2002 /* Replace IFNDEF node by the false-branch statement list, if any */
2003 stmts = astnode_remove_children(astnode_get_child(ifndef, 2));
2004 if (stmts != NULL) {
2005 astnode_replace(ifndef, stmts);
2006 *next = stmts;
2007 } else {
2008 astnode_remove(ifndef);
2009 }
2010 }
2011 astnode_finalize(ifndef);
2012 return 0;
2013 }
2014
2015 /**
2016 * Process IF-node.
2017 * @param if_node Node of type IF_NODE
2018 * @param arg Not used
2019 */
2020 static int process_if(astnode *if_node, void *arg, astnode **next)
2021 {
2022 astnode *expr;
2023 astnode *stmts;
2024 astnode *c;
2025 int ret = 0;
2026 /* IF_NODE has a list of CASE, DEFAULT nodes as children */
2027 for (c = astnode_get_first_child(if_node); c != NULL; c = astnode_get_next_sibling(c) ) {
2028 if (astnode_is_type(c, CASE_NODE)) {
2029 /* The expression which is being tested */
2030 expr = astnode_get_child(c, 0);
2031 /* Try to reduce expression to literal */
2032 expr = reduce_expression(expr);
2033 /* Resulting expression must be an integer literal,
2034 since this is static evaluation.
2035 In other words, it can't contain label references.
2036 */
2037 if (astnode_is_type(expr, INTEGER_NODE)) {
2038 /* Non-zero is true, zero is false */
2039 if (expr->integer) {
2040 /* Replace IF node by the true-branch statement list */
2041 stmts = astnode_remove_children( astnode_get_child(c, 1) );
2042 astnode_replace(if_node, stmts);
2043 astnode_finalize(if_node);
2044 *next = stmts;
2045 return ret;
2046 }
2047 } else {
2048 /* Error, expression is not constant */
2049 err(expr->loc, "conditional expression does not evaluate to literal");
2050 }
2051 } else { /* DEFAULT_NODE */
2052 /* Replace IF node by the false-branch statement list */
2053 stmts = astnode_remove_children(c);
2054 astnode_replace(if_node, stmts);
2055 astnode_finalize(if_node);
2056 *next = stmts;
2057 return ret;
2058 }
2059 }
2060 /* No match, remove IF node from AST */
2061 astnode_remove(if_node);
2062 astnode_finalize(if_node);
2063 return ret;
2064 }
2065
2066 /**
2067 * Process dataseg-node.
2068 * @param dataseg Node of type DATASEG_NODE
2069 * @param arg Not used
2070 */
2071 static int process_dataseg(astnode *dataseg, void *arg, astnode **next)
2072 {
2073 symbol_modifiers = dataseg->modifiers;
2074 in_dataseg = 1; /* true */
2075 return 0;
2076 }
2077
2078 /**
2079 * Process codeseg-node.
2080 * @param codeseg Node of type CODESEG_NODE
2081 * @param arg Not used
2082 */
2083 static int process_codeseg(astnode *codeseg, void *arg, astnode **next)
2084 {
2085 symbol_modifiers = 0;
2086 in_dataseg = 0; /* false */
2087 return 0;
2088 }
2089
2090 /**
2091 * Process org-node.
2092 * @param n Node of type ORG_NODE
2093 * @param arg Not used
2094 */
2095 static int process_org(astnode *org, void *arg, astnode **next)
2096 {
2097 if (!xasm_args.pure_binary) {
2098 err(org->loc, "org directive can only be used when output format is pure 6502 binary");
2099 } else {
2100 astnode *addr = astnode_get_child(org, 0);
2101 addr = reduce_expression_complete(addr);
2102 if (astnode_is_type(addr, INTEGER_NODE)) {
2103 /* Range check */
2104 if ((addr->integer < 0) || (addr->integer >= 0x10000)) {
2105 err(org->loc, "org address out of 64K range");
2106 }
2107 } else {
2108 err(org->loc, "org address does not evaluate to literal");
2109 astnode_remove(org);
2110 astnode_finalize(org);
2111 }
2112 }
2113 return 0;
2114 }
2115
2116 /**
2117 * Process REPT node.
2118 * @param rept Node of type REPT_NODE
2119 * @param arg Not used
2120 */
2121 static int process_rept(astnode *rept, void *arg, astnode **next)
2122 {
2123 astnode *count;
2124 astnode *stmts;
2125 astnode *list;
2126 count = astnode_get_child(rept, 0);
2127 /* Try to reduce count expression to literal */
2128 count = reduce_expression_complete(count);
2129 /* Resulting expression must be an integer literal,
2130 since this is static evaluation.
2131 */
2132 if (astnode_is_type(count, INTEGER_NODE)) {
2133 if (count->integer < 0) {
2134 warn(rept->loc, "REPT ignored; negative repeat count (%d)", count->integer);
2135 astnode_remove(rept);
2136 astnode_finalize(rept);
2137 } else if (count->integer > 0) {
2138 /* Expand body <count> times */
2139 list = astnode_clone(astnode_get_child(rept, 1), rept->loc);
2140 stmts = astnode_remove_children(list);
2141 astnode_finalize(list);
2142 while (--count->integer > 0) {
2143 list = astnode_clone(astnode_get_child(rept, 1), rept->loc);
2144 astnode_add_sibling(stmts, astnode_remove_children(list) );
2145 astnode_finalize(list);
2146 }
2147 astnode_replace(rept, stmts);
2148 astnode_finalize(rept);
2149 *next = stmts;
2150 } else {
2151 /* count == 0 */
2152 astnode_remove(rept);
2153 astnode_finalize(rept);
2154 }
2155 } else {
2156 err(rept->loc, "repeat count does not evaluate to literal");
2157 astnode_remove(rept);
2158 astnode_finalize(rept);
2159 }
2160 return 0;
2161 }
2162
2163 /**
2164 * Process WHILE node.
2165 * @param while_node Node of type WHILE_NODE
2166 * @param arg Not used
2167 */
2168 static int process_while(astnode *while_node, void *arg, astnode **next)
2169 {
2170 astnode *expr;
2171 astnode *stmts;
2172 astnode *list;
2173 expr = astnode_get_child(while_node, 0);
2174 /* Try to reduce expression to literal */
2175 expr = reduce_expression(astnode_clone(expr, expr->loc));
2176 /* Resulting expression must be an integer literal,
2177 since this is static evaluation.
2178 */
2179 if (astnode_is_type(expr, INTEGER_NODE)) {
2180 /* Expand body if the expression is true */
2181 if (expr->integer) {
2182 list = astnode_clone(astnode_get_child(while_node, 1), while_node->loc);
2183 stmts = astnode_remove_children(list);
2184 astnode_finalize(list);
2185 astnode_replace(while_node, stmts);
2186 astnode_add_sibling(stmts, while_node); /* Clever huh? */
2187 *next = stmts;
2188 } else {
2189 astnode_remove(while_node);
2190 astnode_finalize(while_node);
2191 }
2192 } else {
2193 err(while_node->loc, "while expression does not evaluate to literal");
2194 astnode_remove(while_node);
2195 astnode_finalize(while_node);
2196 }
2197 astnode_finalize(expr);
2198 return 0;
2199 }
2200
2201 /*---------------------------------------------------------------------------*/
2202
2203 /**
2204 * Enters a macro into the symbol table.
2205 * @param n Must be a node of type MACRO_DECL_NODE
2206 * @param arg Not used
2207 */
2208 static int enter_macro(astnode *macro_def, void *arg, astnode **next)
2209 {
2210 astnode *id = astnode_get_child(macro_def, 0);
2211 assert(astnode_get_type(id) == IDENTIFIER_NODE);
2212 if (symtab_enter(id->ident, MACRO_SYMBOL, macro_def, 0) == NULL) {
2213 /* ### This could be allowed, you know... */
2214 err(macro_def->loc, "duplicate symbol `%s'", id->ident);
2215 }
2216 astnode_remove(macro_def);
2217 return 0;
2218 }
2219
2220 /**
2221 * Enters a label into the symbol table.
2222 * @param label Must be a node of type LABEL_NODE
2223 */
2224 static int enter_label(astnode *label, void *arg, astnode **next)
2225 {
2226 symtab_entry *e;
2227 astnode *addr;
2228 /* Make sure it's unique first */
2229 if (symtab_lookup(label->ident)) {
2230 err(label->loc, "duplicate symbol `%s'", label->ident);
2231 astnode_remove(label);
2232 astnode_finalize(label);
2233 } else {
2234 e = symtab_enter(label->ident, LABEL_SYMBOL, label, (in_dataseg ? DATA_FLAG : 0) | symbol_modifiers );
2235 /* Check if hardcoded address */
2236 addr = reduce_expression_complete(RHS(label));
2237 if (astnode_is_type(addr, INTEGER_NODE)) {
2238 /* Store it */
2239 e->address = addr->integer;
2240 e->flags |= ADDR_FLAG;
2241 } else if (!astnode_is_type(addr, CURRENT_PC_NODE)) {
2242 err(label->loc, "label address does not evaluate to literal");
2243 }
2244 label_count++;
2245 }
2246 return 0;
2247 }
2248
2249 /**
2250 * Enters a variable declaration in symbol table.
2251 * @param var Must be a node of type VAR_DECL_NODE
2252 */
2253 static int enter_var(astnode *var, void *arg, astnode **next)
2254 {
2255 astnode *id = LHS(var);
2256 assert(astnode_get_type(id) == IDENTIFIER_NODE);
2257 if (symtab_lookup(id->ident)) {
2258 err(var->loc, "duplicate symbol `%s'", id->ident);
2259 astnode_remove(var);
2260 astnode_finalize(var);
2261 return 0;
2262 } else {
2263 if ((var->modifiers & ZEROPAGE_FLAG) && !in_dataseg) {
2264 warn(var->loc, "zeropage modifier has no effect in code segment");
2265 var->modifiers &= ~ZEROPAGE_FLAG;
2266 }
2267 symtab_enter(id->ident, VAR_SYMBOL, astnode_clone(RHS(var), var->loc), (in_dataseg ? DATA_FLAG : 0) | var->modifiers | symbol_modifiers);
2268 return 1;
2269 }
2270 }
2271
2272 /**
2273 * Enters a procedure declaration in symbol table.
2274 * @param proc Must be a node of type PROC_NODE
2275 */
2276 static int enter_proc(astnode *proc, void *arg, astnode **next)
2277 {
2278 astnode *id;
2279 if (in_dataseg) {
2280 err(proc->loc, "procedures not allowed in data segment");
2281 astnode_remove(proc);
2282 astnode_finalize(proc);
2283 return 0;
2284 }
2285 id = LHS(proc);
2286 assert(astnode_get_type(id) == IDENTIFIER_NODE);
2287 if (symtab_lookup(id->ident)) {
2288 err(proc->loc, "duplicate symbol `%s'", id->ident);
2289 astnode_remove(proc);
2290 astnode_finalize(proc);
2291 return 0;
2292 } else {
2293 /* Enter it! RHS(proc) is the list of procedure statements */
2294 symtab_enter(id->ident, PROC_SYMBOL, RHS(proc), (in_dataseg ? DATA_FLAG : 0) );
2295 label_count++;
2296 return 1;
2297 }
2298 }
2299
2300 /**
2301 * Enters a simple <identifier> <storage> structure member.
2302 * @param c Node of type VAR_DECL_NODE
2303 * @param offset Offset of this field
2304 * @param plist List of symbol table's entries
2305 * @param struc_id Structure identifier (for error messages)
2306 * @return New offset (old offset + size of this field)
2307 */
2308 static astnode *enter_struc_atomic_field(astnode *c, astnode *offset, ordered_field_list ***plist, astnode *struc_id)
2309 {
2310 astnode *field_id;
2311 astnode *field_data;
2312 astnode *field_size;
2313 symtab_entry *fe;
2314 /* c has two children: id and STORAGE_NODE */
2315 field_id = LHS(c);
2316 assert(astnode_get_type(field_id) == IDENTIFIER_NODE);
2317 field_data = RHS(c);
2318 reduce_expression(RHS(field_data));
2319 if (astnode_is_type(field_data, DATA_NODE)) {
2320 err(c->loc, "data initialization not allowed here");
2321 return(offset);
2322 }
2323 fe = symtab_enter(
2324 field_id->ident,
2325 VAR_SYMBOL,
2326 astnode_clone(field_data, field_data->loc),
2327 0
2328 );
2329 if (fe == NULL) {
2330 err(c->loc, "duplicate symbol `%s' in structure `%s'", field_id->ident, struc_id->ident);
2331 return(offset);
2332 }
2333 /* Add to ordered list of fields */
2334 (**plist) = malloc(sizeof(ordered_field_list));
2335 (**plist)->entry = fe;
2336 (**plist)->next = NULL;
2337 *plist = &((**plist)->next);
2338 /* Set field offset */
2339 fe->field.offset = astnode_clone(offset, offset->loc);
2340 /* Calculate field size in bytes: sizeof(datatype) * count */
2341 field_size = astnode_create_arithmetic(
2342 MUL_OPERATOR,
2343 astnode_create_sizeof(astnode_clone(LHS(field_data), field_data->loc), field_data->loc),
2344 astnode_clone(RHS(field_data), field_data->loc),
2345 field_data->loc
2346 );
2347 field_size = reduce_expression(field_size);
2348 /* Set field size */
2349 fe->field.size = astnode_clone(field_size, field_size->loc);
2350 /* Add field size to total offset */
2351 offset = astnode_create_arithmetic(
2352 PLUS_OPERATOR,
2353 offset,
2354 field_size,
2355 offset->loc
2356 );
2357 offset = reduce_expression(offset);
2358 return(offset);
2359 }
2360
2361 static void enter_union_fields(symtab_entry *, astnode *);
2362
2363 /**
2364 * Attempts to enter an (anonymous) union's members into structure's symbol table.
2365 * @param n Node of type UNION_DECL_NODE
2366 * @param offset Current parent structure offset
2367 * @param plist Ordered list of parent structure's fields
2368 */
2369 astnode *enter_struc_union_field(astnode *n, astnode *offset, ordered_field_list ***plist, astnode *struc_id)
2370 {
2371 ordered_field_list *ls;
2372 symtab_entry *se;
2373 symtab_entry *fe;
2374 static int id = 0;
2375 char id_str[16];
2376 astnode *union_id;
2377 union_id = LHS(n);
2378 if (astnode_is_type(union_id, IDENTIFIER_NODE)) {
2379 err(n->loc, "anonymous union expected");
2380 return(offset);
2381 }
2382 snprintf(id_str, sizeof (id_str), "%d", id++);
2383 se = symtab_enter(id_str, UNION_SYMBOL, n, 0);
2384 enter_union_fields(se, n);
2385 /* Add to ordered list of fields */
2386 (**plist) = malloc(sizeof(ordered_field_list));
2387 (**plist)->entry = se;
2388 (**plist)->next = NULL;
2389 *plist = &((**plist)->next);
2390 /* Add to parent structure as well, with same offsets */
2391 for (ls = se->struc.fields; ls != NULL; ls = ls->next) {
2392 /* Try to enter field in structure's symbol table */
2393 fe = symtab_enter(
2394 ls->entry->id,
2395 VAR_SYMBOL,
2396 astnode_clone(ls->entry->def, ls->entry->def->loc),
2397 0
2398 );
2399 if (fe == NULL) {
2400 err(ls->entry->def->loc, "duplicate symbol `%s' in structure `%s'", ls->entry->id, struc_id->ident);
2401 continue;
2402 }
2403 /* Set field offset */
2404 fe->field.offset = astnode_clone(offset, offset->loc);
2405 /* Set field size */
2406 fe->field.size = astnode_clone(se->struc.size, offset->loc);
2407 }
2408 /* Advance offset by size of union */
2409 offset = astnode_create_arithmetic(
2410 PLUS_OPERATOR,
2411 offset,
2412 astnode_clone(se->struc.size, offset->loc),
2413 offset->loc
2414 );
2415 offset = reduce_expression(offset);
2416 return(offset);
2417 }
2418
2419 /**
2420 * Enters struc type into symbol table based on AST node.
2421 * - Creates a symbol table for the structure
2422 * - Validates and enters all its fields
2423 * - Calculates offset of each field in the structure, and total size
2424 * @param struc_def Node of type STRUC_DECL_NODE
2425 */
2426 static int enter_struc(astnode *struc_def, void *arg, astnode **next)
2427 {
2428 ordered_field_list **plist;
2429 symtab_entry *se;
2430 astnode *c;
2431 astnode *offset;
2432 astnode *struc_id = LHS(struc_def);
2433 assert(astnode_is_type(struc_id, IDENTIFIER_NODE));
2434 se = symtab_enter(struc_id->ident, STRUC_SYMBOL, struc_def, 0);
2435 if (se == NULL) {
2436 err(struc_def->loc, "duplicate symbol `%s'", struc_id->ident);
2437 } else {
2438 /* Put the fields of the structure in local symbol table */
2439 se->symtab = symtab_create();
2440 offset = astnode_create_integer(0, struc_def->loc); /* offset = 0 */
2441 plist = &se->struc.fields;
2442 for (c = struc_id->next_sibling; c != NULL; c = c->next_sibling) {
2443 /* Check if it's a field declaration */
2444 if (astnode_is_type(c, VAR_DECL_NODE)) {
2445 offset = enter_struc_atomic_field(c, offset, &plist, struc_id);
2446 }
2447 /* Check if (anonymous) union */
2448 else if (astnode_is_type(c, UNION_DECL_NODE)) {
2449 offset = enter_struc_union_field(c, offset, &plist, struc_id);
2450 } else {
2451 err(c->loc, "field declaration expected");
2452 continue;
2453 }
2454 }
2455 /* Store total size of structure */
2456 se->struc.size = offset;
2457 /* Restore previous symbol table */
2458 symtab_pop();
2459 }
2460 /* ### Remove STRUC node from AST */
2461 // astnode_remove(struc_def);
2462 // astnode_finalize(struc_def);
2463 return 0;
2464 }
2465
2466 /**
2467 * Enters fields of union into its symbol table.
2468 */
2469 static void enter_union_fields(symtab_entry *se, astnode *union_def)
2470 {
2471 ordered_field_list **plist;
2472 astnode *c;
2473 astnode *field_id;
2474 astnode *field_data;
2475 astnode *field_size;
2476 symtab_entry *fe;
2477
2478 se->symtab = symtab_create();
2479 se->struc.size = astnode_create_integer(0, union_def->loc);
2480 plist = &se->struc.fields;
2481 /* Process field declarations */
2482 for (c = RHS(union_def); c != NULL; c = c->next_sibling) {
2483 if (!astnode_is_type(c, VAR_DECL_NODE)) {
2484 err(c->loc, "field declaration expected");
2485 continue;
2486 }
2487 /* c has two children: id and STORAGE_NODE */
2488 field_id = LHS(c);
2489 assert(astnode_get_type(field_id) == IDENTIFIER_NODE);
2490 field_data = RHS(c);
2491 reduce_expression(RHS(field_data));
2492 if (astnode_is_type(field_data, DATA_NODE)) {
2493 err(c->loc, "data initialization not allowed here");
2494 continue;
2495 }
2496 /* Calculate field size in bytes: sizeof(datatype) * count */
2497 field_size = astnode_create_arithmetic(
2498 MUL_OPERATOR,
2499 astnode_create_sizeof(astnode_clone(LHS(field_data), field_data->loc), field_data->loc),
2500 astnode_clone(RHS(field_data), field_data->loc),
2501 field_data->loc
2502 );
2503 field_size = reduce_expression(field_size);
2504 if (!astnode_is_type(field_size, INTEGER_NODE)) {
2505 err(c->loc, "union member must be of constant size");
2506 astnode_finalize(field_size);
2507 /* Use default size: 1 byte */
2508 field_size = astnode_create_integer(1, field_data->loc);
2509 }
2510 fe = symtab_enter(
2511 field_id->ident,
2512 VAR_SYMBOL,
2513 astnode_clone(field_data, field_data->loc),
2514 0
2515 );
2516 if (fe == NULL) {
2517 err(c->loc, "duplicate symbol `%s' in union `%s'", field_id->ident, se->id);
2518 astnode_finalize(field_size);
2519 continue;
2520 }
2521 /* Add to ordered list of fields */
2522 (*plist) = malloc(sizeof(ordered_field_list));
2523 (*plist)->entry = fe;
2524 (*plist)->next = NULL;
2525 plist = &((*plist)->next);
2526 /* Set field offset (0 for all) and size */
2527 fe->field.offset = astnode_create_integer(0, union_def->loc);
2528 fe->field.size = astnode_clone(field_size, field_size->loc);
2529 /* See if field size of this member is largest so far */
2530 if (se->struc.size->integer < field_size->integer) {
2531 astnode_finalize(se->struc.size);
2532 se->struc.size = field_size;
2533 } else {
2534 astnode_finalize(field_size);
2535 }
2536 }
2537 symtab_pop();
2538 }
2539
2540 /**
2541 * Enters union type into symbol table based on AST node.
2542 * @param union_def Node of type UNION_DECL_NODE
2543 */
2544 static int enter_union(astnode *union_def, void *arg, astnode **next)
2545 {
2546 symtab_entry *se;
2547 astnode *union_id = astnode_get_child(union_def, 0);
2548 assert(astnode_is_type(union_id, IDENTIFIER_NODE));
2549 if (astnode_is_type(union_id, NULL_NODE)) {
2550 err(union_def->loc, "anonymous union not allowed in global scope");
2551 } else {
2552 assert(astnode_get_type(union_id) == IDENTIFIER_NODE);
2553 se = symtab_enter(union_id->ident, UNION_SYMBOL, union_def, 0);
2554 if (se == NULL) {
2555 err(union_def->loc, "duplicate symbol `%s'", union_id->ident);
2556 } else {
2557 /* Put the fields of the union in local symbol table */
2558 enter_union_fields(se, union_def);
2559 }
2560 }
2561 /* ### Remove UNION node from AST */
2562 // astnode_remove(union_def);
2563 // astnode_finalize(union_def);
2564 return 0;
2565 }
2566
2567 /**
2568 * Enters enumerated type into symbol table based on AST node.
2569 * @param n Node of type ENUM_DECL_NODE
2570 */
2571 static int enter_enum(astnode *enum_def, void *arg, astnode **next)
2572 {
2573 astnode *c;
2574 astnode *id;
2575 astnode *val;
2576 symtab_entry *se;
2577 astnode *enum_id = astnode_get_child(enum_def, 0);
2578 assert(astnode_get_type(enum_id) == IDENTIFIER_NODE);
2579 se = symtab_enter(enum_id->ident, ENUM_SYMBOL, enum_def, 0);
2580 if (se == NULL) {
2581 err(enum_def->loc, "duplicate symbol `%s'", enum_id->ident);
2582 } else {
2583 /* Add all the enum symbols to its own symbol table */
2584 se->symtab = symtab_create();
2585 val = NULL;
2586 for (c = enum_id->next_sibling; c != NULL; c = c->next_sibling) {
2587 if (astnode_is_type(c, IDENTIFIER_NODE)) {
2588 id = c;
2589 if (val == NULL) {
2590 val = astnode_create_integer(0, c->loc);
2591 } else {
2592 val = astnode_create_integer(val->integer+1, c->loc);
2593 }
2594 } else {
2595 id = LHS(c);
2596 val = reduce_expression_complete(astnode_clone(RHS(c), RHS(c)->loc));
2597 if (!astnode_is_type(val, INTEGER_NODE)) {
2598 err(c->loc, "initializer does not evaluate to integer literal");
2599 astnode_finalize(val);
2600 /* Use default value */
2601 val = astnode_create_integer(0, c->loc);
2602 }
2603 }
2604 if (symtab_enter(id->ident, CONSTANT_SYMBOL, val, 0) == NULL) {
2605 err(c->loc, "duplicate symbol `%s' in enumeration `%s'", id->ident, enum_id->ident);
2606 continue;
2607 }
2608 }
2609 symtab_pop();
2610 }
2611 /* ### Remove ENUM node from AST */
2612 // astnode_remove(enum_def);
2613 // astnode_finalize(enum_def);
2614 return 0;
2615 }
2616
2617 /**
2618 * Enters record type into symbol table based on AST node.
2619 * @param n Node of type RECORD_DECL_NODE
2620 */
2621 static int enter_record(astnode *record_def, void *arg, astnode **next)
2622 {
2623 ordered_field_list **plist;
2624 astnode *c;
2625 astnode *field_id;
2626 astnode *field_width;
2627 int size;
2628 int offset;
2629 symtab_entry *se;
2630 symtab_entry *fe;
2631 astnode *record_id = astnode_get_child(record_def, 0);
2632 assert(astnode_get_type(record_id) == IDENTIFIER_NODE);
2633 se = symtab_enter(record_id->ident, RECORD_SYMBOL, record_def, 0);
2634 if (se == NULL) {
2635 err(record_def->loc, "duplicate symbol `%s'", record_id->ident);
2636 }
2637 else {
2638 /* Add all the record fields to record's own symbol table */
2639 se->symtab = symtab_create();
2640 offset = 8;
2641 plist = &se->struc.fields;
2642 for (c = record_id->next_sibling; c != NULL; c = c->next_sibling) {
2643 /* c has two children: field identifier and its width */
2644 field_id = LHS(c);
2645 field_width = astnode_clone(reduce_expression(RHS(c)), RHS(c)->loc);
2646 /* Validate the width -- must be positive integer literal */
2647 if (!astnode_is_type(field_width, INTEGER_NODE)) {
2648 err(c->loc, "record member `%s' is not of constant size", field_id->ident);
2649 continue;
2650 }
2651 if ((field_width->integer <= 0) || (field_width->integer >= 8)) {
2652 err(c->loc, "width of record member `%s' is out of range (%d)", field_id->ident, field_width->integer);
2653 continue;
2654 }
2655 /* Attempt to enter field in record's symbol table */
2656 fe = symtab_enter(field_id->ident, VAR_SYMBOL, c, 0);
2657 if (fe == NULL) {
2658 err(c->loc, "duplicate symbol `%s' in record `%s'", field_id->ident, record_id->ident);
2659 continue;
2660 }
2661 /* Add to ordered list of fields */
2662 (*plist) = malloc(sizeof(ordered_field_list));
2663 (*plist)->entry = fe;
2664 (*plist)->next = NULL;
2665 plist = &((*plist)->next);
2666 /* Set field offset */
2667 offset = offset - field_width->integer;
2668 fe->field.offset = astnode_create_integer(offset, c->loc);
2669 /* Set field size (width) */
2670 fe->field.size = field_width;
2671 }
2672 size = 8 - offset;
2673 if (size > 8) {
2674 err(record_def->loc, "size of record `%s' (%d) exceeds 8 bits", record_id->ident, size);
2675 } else {
2676 /* Set size of record (in bits) */
2677 se->struc.size = astnode_create_integer(size, record_def->loc);
2678 }
2679 symtab_pop();
2680 }
2681 /* ### Remove RECORD node from AST */
2682 // astnode_remove(record_def);
2683 // astnode_finalize(record_def);
2684 return 0;
2685 }
2686
2687 /**
2688 * Globalizes a local.
2689 * The node is morphed into its global equivalent (LABEL_NODE or IDENTIFIER_NODE).
2690 * @param n A node of type LOCAL_LABEL_NODE or LOCAL_ID_NODE
2691 * @param arg Pointer to namespace counter
2692 */
2693 static int globalize_local(astnode *n, void *arg, astnode **next)
2694 {
2695 char str[32];
2696 /* Make it global by appending namespace counter to the id */
2697 snprintf(str, sizeof (str), "#%d", label_count);
2698 if (astnode_is_type(n, LOCAL_LABEL_NODE)) {
2699 /* Local label definition, use label field */
2700 n->label = realloc(n->label, strlen(n->label)+strlen(str)+1);
2701 strcat(n->label, str);
2702 /* This node is now a unique, global label */
2703 n->type = LABEL_NODE;
2704 /* Make sure it's unique */
2705 if (symtab_lookup(n->label)) {
2706 err(n->loc, "duplicate symbol `%s'", n->label);
2707 astnode_remove(n);
2708 astnode_finalize(n);
2709 return 0;
2710 } else {
2711 symtab_enter(n->label, LABEL_SYMBOL, n, (in_dataseg ? DATA_FLAG : 0) );
2712 }
2713 } else {
2714 /* Local label reference, use ident field */
2715 n->ident = realloc(n->ident, strlen(n->ident)+strlen(str)+1);
2716 strcat(n->ident, str);
2717 /* This node is now a unique, global identifier */
2718 n->type = IDENTIFIER_NODE;
2719 }
2720 return 1;
2721 }
2722
2723 /**
2724 * Tags symbols as extrn.
2725 * @param n A node of type EXTRN_NODE
2726 */
2727 static int tag_extrn_symbols(astnode *extrn, void *arg, astnode **next)
2728 {
2729 astnode *id;
2730 astnode *type;
2731 astnode *list;
2732 symtab_entry *e;
2733 type = astnode_get_child(extrn, 0);
2734 /* Go through the list of identifiers */
2735 list = astnode_get_child(extrn, 1);
2736 for (id=astnode_get_first_child(list); id != NULL; id=astnode_get_next_sibling(id) ) {
2737 e = symtab_lookup(id->ident);
2738 if (e != NULL) {
2739 if (!(e->flags & EXTRN_FLAG)) {
2740 /* Error, can't import a symbol that's defined locally! */
2741 // TODO: this is okay?
2742 err(extrn->loc, "`%s' declared as extrn but is defined locally", id->ident);
2743 }
2744 }
2745 else {
2746 // TODO: store external unit name
2747 switch (astnode_get_type(type)) {
2748 case DATATYPE_NODE:
2749 symtab_enter(id->ident, VAR_SYMBOL, astnode_create_data(astnode_clone(type, extrn->loc), NULL, extrn->loc), EXTRN_FLAG);
2750 break;
2751
2752 case INTEGER_NODE:
2753 /* type->integer is (LABEL|PROC)_SYMBOL */
2754 symtab_enter(id->ident, type->integer, NULL, EXTRN_FLAG);
2755 break;
2756
2757 default:
2758 break;
2759 }
2760 }
2761 }
2762 astnode_remove(extrn);
2763 astnode_finalize(extrn);
2764 return 0;
2765 }
2766
2767 /**
2768 *
2769 */
2770 static int process_message(astnode *message, void *arg, astnode **next)
2771 {
2772 astnode *expr = reduce_expression_complete(LHS(message));
2773 if (astnode_is_type(expr, STRING_NODE)) {
2774 printf("%s\n", expr->string);
2775 } else if (astnode_is_type(expr, INTEGER_NODE)) {
2776 printf("%d\n", expr->integer);
2777 } else {
2778 err(expr->loc, "string or integer argument expected");
2779 }
2780 astnode_remove(message);
2781 astnode_finalize(message);
2782 return 0;
2783 }
2784
2785 /**
2786 *
2787 */
2788 static int process_warning(astnode *warning, void *arg, astnode **next)
2789 {
2790 astnode *expr = reduce_expression_complete(LHS(warning));
2791 if (astnode_is_type(expr, STRING_NODE)) {
2792 warn(warning->loc, expr->string);
2793 } else {
2794 err(warning->loc, "string argument expected");
2795 }
2796 astnode_remove(warning);
2797 astnode_finalize(warning);
2798 return 0;
2799 }
2800
2801 /**
2802 *
2803 */
2804 static int process_error(astnode *error, void *arg, astnode **next)
2805 {
2806 astnode *expr = reduce_expression_complete(LHS(error));
2807 if (astnode_is_type(expr, STRING_NODE)) {
2808 err(error->loc, expr->string);
2809 } else {
2810 err(expr->loc, "string argument expected");
2811 }
2812 astnode_remove(error);
2813 astnode_finalize(error);
2814 return 0;
2815 }
2816
2817 /**
2818 * Processes a forward branch declaration.
2819 * @param forward_branch Node of type FORWARD_BRANCH_DECL_NODE
2820 * @param arg Not used
2821 */
2822 static int process_forward_branch_decl(astnode *n, void *arg, astnode **next)
2823 {
2824 astnode *l;
2825 int i;
2826 char str[32];
2827 assert(!strchr(n->ident, '#'));
2828 /* Get branch info structure for label (+, ++, ...) */
2829 forward_branch_info *fwd = &forward_branch[strlen(n->ident)-1];
2830 /* Morph n to globally unique label */
2831 snprintf(str, sizeof (str), "#%d", fwd->counter);
2832 n->label = (char *)realloc(n->ident, strlen(n->ident)+strlen(str)+1);
2833 strcat(n->label, str);
2834 n->type = LABEL_NODE;
2835 symtab_enter(n->label, LABEL_SYMBOL, n, 0);
2836 /* Fix reference identifiers */
2837 for (i=0; i<fwd->index; i++) {
2838 l = fwd->refs[i];
2839 l->ident = (char *)realloc(l->ident, strlen(n->ident)+1);
2840 strcpy(l->ident, n->ident);
2841 }
2842 /* Prepare for next declaration */
2843 fwd->index = 0;
2844 fwd->counter++;
2845 return 0;
2846 }
2847
2848 /**
2849 * Processes a backward branch declaration.
2850 * @param n Node of type BACKWARD_BRANCH_DECL_NODE
2851 * @param arg Not used
2852 */
2853 static int process_backward_branch_decl(astnode *n, void *arg, astnode **next)
2854 {
2855 char str[32];
2856 assert(!strchr(n->ident, '#'));
2857 /* Get branch info */
2858 backward_branch_info *bwd = &backward_branch[strlen(n->ident)-1];
2859 bwd->decl = n;
2860 /* Morph n to globally unique label */
2861 snprintf(str, sizeof (str), "#%d", bwd->counter);
2862 n->label = (char *)realloc(n->ident, strlen(n->ident)+strlen(str)+1);
2863 strcat(n->label, str);
2864 n->type = LABEL_NODE;
2865 symtab_enter(n->label, LABEL_SYMBOL, n, 0);
2866 /* Prepare for next declaration */
2867 bwd->counter++;
2868 return 0;
2869 }
2870
2871 /**
2872 * Processes a forward branch label reference.
2873 * @param n Node of type FORWARD_BRANCH_NODE
2874 * @param arg Not used
2875 */
2876 static int process_forward_branch(astnode *n, void *arg, astnode **next)
2877 {
2878 /* Add n to proper forward_branch array */
2879 forward_branch_info *fwd = &forward_branch[strlen(n->ident)-1];
2880 fwd->refs[fwd->index++] = n;
2881 /* Change to identifier node */
2882 n->type = IDENTIFIER_NODE;
2883 return 0;
2884 }
2885
2886 /**
2887 * Processes a backward branch label reference.
2888 * @param n Node of type BACKWARD_BRANCH_NODE
2889 * @param arg Not used
2890 */
2891 static int process_backward_branch(astnode *n, void *arg, astnode **next)
2892 {
2893 /* Get branch info */
2894 backward_branch_info *bwd = &backward_branch[strlen(n->ident)-1];
2895 /* Make sure it's a valid reference */
2896 if (bwd->decl != NULL) {
2897 /* Fix n->ident */
2898 n->ident = (char *)realloc(n->ident, strlen(bwd->decl->ident)+1);
2899 strcpy(n->ident, bwd->decl->ident);
2900 }
2901 /* Change to identifier node */
2902 n->type = IDENTIFIER_NODE;
2903 return 0;
2904 }
2905
2906 /*---------------------------------------------------------------------------*/
2907
2908 static int is_field_ref(astnode *n)
2909 {
2910 astnode *p = astnode_get_parent(n);
2911 /* Case 1: id.id */
2912 if (astnode_is_type(p, DOT_NODE)) return 1;
2913 /* Case 2: id.id[expr] */
2914 if (astnode_is_type(p, INDEX_NODE) && (n == LHS(p)) && astnode_is_type(astnode_get_parent(p), DOT_NODE) ) return 1;
2915 return 0;
2916 }
2917
2918 /**
2919 * Checks that the given identifier node is present in symbol table.
2920 * Issues error if it is not, and replaces with integer 0.
2921 * @param n A node of type IDENTIFIER_NODE
2922 */
2923 static int validate_ref(astnode *n, void *arg, astnode **next)
2924 {
2925 int i;
2926 symbol_ident_list list;
2927 symtab_entry *enum_def;
2928 int ret = 1;
2929 if (is_field_ref(n)) {
2930 return 1; /* Validated by validate_dotref() */
2931 }
2932 symtab_entry * e = symtab_lookup(n->ident);
2933 if (e == NULL) {
2934 /* Maybe it is part of an enumeration */
2935 symtab_list_type(ENUM_SYMBOL, &list);
2936 for (i=0; i<list.size; i++) {
2937 enum_def = symtab_lookup(list.idents[i]);
2938 symtab_push(enum_def->symtab);
2939 e = symtab_lookup(n->ident);
2940 symtab_pop();
2941 if (e != NULL) {
2942 /* Replace id by SCOPE_NODE */
2943 astnode *scope = astnode_create_scope(
2944 astnode_create_identifier(enum_def->id, n->loc),
2945 astnode_clone(n, n->loc), n->loc);
2946 astnode_replace(n, scope);
2947 astnode_finalize(n);
2948 *next = scope;
2949 ret = 0;
2950 break;
2951 }
2952 }
2953 symtab_list_finalize(&list);
2954 if (e == NULL) {
2955 strtok(n->ident, "#"); /* Remove globalize junk */
2956 // err(n->loc, "unknown symbol `%s'", n->ident);
2957 /* ### Replace by integer 0 */
2958 //astnode_replace(n, astnode_create_integer(0, n->loc) );
2959 //astnode_finalize(n);
2960 warn(n->loc, "`%s' undeclared; assuming external label", n->ident);
2961 e = symtab_enter(n->ident, LABEL_SYMBOL, NULL, EXTRN_FLAG);
2962 }
2963 }
2964 assert(e);
2965 e->ref_count++;
2966 return ret;
2967 }
2968
2969 /**
2970 * Validates top-level (not part of structure) indexed identifier.
2971 * @param n Node of type INDEX_NODE
2972 * @param arg Not used
2973 */
2974 static int validate_index(astnode *n, void *arg, astnode **next)
2975 {
2976 symtab_entry *e;
2977 astnode *id;
2978 astnode *type;
2979 if (is_field_ref(LHS(n))) {
2980 return 1; /* Validated by validate_dotref() */
2981 }
2982 id = LHS(n);
2983 if (!astnode_is_type(id, IDENTIFIER_NODE)) {
2984 err(n->loc, "identifier expected");
2985 astnode_replace(n, astnode_create_integer(0, n->loc) );
2986 astnode_finalize(n);
2987 return 0;
2988 }
2989 e = symtab_lookup(id->ident);
2990 if (e != NULL) {
2991 type = LHS(e->def);
2992 if (!astnode_is_type(type, DATATYPE_NODE)) {
2993 err(n->loc, "`%s' cannot be indexed", id->ident);
2994 astnode_replace(n, astnode_create_integer(0, n->loc) );
2995 astnode_finalize(n);
2996 return 0;
2997 } else {
2998 // TODO: bounds check
2999 astnode *reduced = reduce_index(n);
3000 if (reduced != n) {
3001 *next = reduced;
3002 return 0;
3003 }
3004 }
3005 } else {
3006 err(n->loc, "unknown symbol `%s'", id->ident);
3007 astnode_replace(n, astnode_create_integer(0, n->loc) );
3008 astnode_finalize(n);
3009 return 0;
3010 }
3011 return 1;
3012 }
3013
3014 /**
3015 * Checks that A::B is valid.
3016 * If it's not valid it is replaced by integer 0.
3017 * @param n Node of type SCOPE_NODE
3018 */
3019 static int validate_scoperef(astnode *n, void *arg, astnode **next)
3020 {
3021 astnode *symbol;
3022 astnode *namespace = LHS(n);
3023 symtab_entry * e = symtab_lookup(namespace->ident);
3024 if (e == NULL) {
3025 err(n->loc, "unknown namespace `%s'", namespace->ident);
3026 /* Replace by integer 0 */
3027 astnode_replace(n, astnode_create_integer(0, n->loc) );
3028 astnode_finalize(n);
3029 return 0;
3030 } else {
3031 /* Get symbol on right of :: operator */
3032 symbol = RHS(n);
3033 /* Namespace was found, check its type */
3034 switch (e->type) {
3035 case STRUC_SYMBOL:
3036 case UNION_SYMBOL:
3037 case RECORD_SYMBOL:
3038 case ENUM_SYMBOL:
3039 /* OK, check the symbol */
3040 symtab_push(e->symtab);
3041 e = symtab_lookup(symbol->ident);
3042 if (e == NULL) {
3043 err(n->loc, "unknown symbol `%s' in namespace `%s'", symbol->ident, namespace->ident);
3044 /* Replace by integer 0 */
3045 astnode_replace(n, astnode_create_integer(0, n->loc) );
3046 astnode_finalize(n);
3047 }
3048 symtab_pop();
3049 break;
3050
3051 default:
3052 err(n->loc, "`%s' is not a namespace", namespace->ident);
3053 /* Replace by integer 0 */
3054 astnode_replace(n, astnode_create_integer(0, n->loc) );
3055 astnode_finalize(n);
3056 break;
3057 }
3058 }
3059 return 0;
3060 }
3061
3062 /**
3063 * Validates right part of dotted reference recursively.
3064 * Assumes that left part's symbol table is on stack.
3065 * @param n Node of type DOT_NODE
3066 */
3067 static void validate_dotref_recursive(astnode *n, astnode *top)
3068 {
3069 astnode *left;
3070 astnode *right;
3071 astnode *type;
3072 symtab_entry *field;
3073 symtab_entry *def;
3074 left = LHS(n);
3075 if (astnode_is_type(left, INDEX_NODE)) {
3076 left = LHS(left); /* Need identifier */
3077 }
3078 right = RHS(n);
3079 if (astnode_is_type(right, DOT_NODE)) {
3080 right = LHS(right); /* Need identifier */
3081 }
3082 if (astnode_is_type(right, INDEX_NODE)) {
3083 right = LHS(right); /* Need identifier */
3084 }
3085 /* Lookup 'right' in 'left's symbol table */
3086 assert(astnode_get_type(right) == IDENTIFIER_NODE);
3087 field = symtab_lookup(right->ident);
3088 if (field == NULL) {
3089 err(n->loc, "`%s' is not a member of `%s'", right->ident, left->ident);
3090 /* Replace by integer 0 */
3091 astnode_replace(top, astnode_create_integer(0, top->loc) );
3092 astnode_finalize(top);
3093 } else {
3094 /* See if more subfields to process */
3095 n = RHS(n);
3096 if (astnode_is_type(n, DOT_NODE)) {
3097 /* Verify the variable's type -- should be user-defined */
3098 type = LHS(field->def);
3099 if ((type == NULL) || (type->datatype != USER_DATATYPE)) {
3100 err(n->loc, "member `%s' of `%s' is not a structure", right->ident, left->ident);
3101 /* Replace by integer 0 */
3102 astnode_replace(top, astnode_create_integer(0, top->loc) );
3103 astnode_finalize(top);
3104 } else {
3105 /* Look up variable's type definition and verify it's a structure */
3106 def = symtab_global_lookup(LHS(type)->ident);
3107 if (def == NULL) {
3108 err(n->loc, "member '%s' of '%s' is of unknown type (`%s')", right->ident, left->ident, LHS(type)->ident);
3109 /* Replace by integer 0 */
3110 astnode_replace(top, astnode_create_integer(0, top->loc) );
3111 astnode_finalize(top);
3112 } else if ( !((def->type == STRUC_SYMBOL) || (def->type == UNION_SYMBOL)) ) {
3113 err(n->loc, "member `%s' of `%s' is not a structure", right->ident, left->ident);
3114 /* Replace by integer 0 */
3115 astnode_replace(top, astnode_create_integer(0, top->loc) );
3116 astnode_finalize(top);
3117 } else {
3118 /* Next field */
3119 symtab_push(def->symtab);
3120 validate_dotref_recursive(n, top);
3121 symtab_pop();
3122 }
3123 }
3124 }
3125 }
3126 }
3127
3128 /**
3129 * Validates A.B.C.D. . ...
3130 * Replaces the whole thing with integer 0 if not.
3131 * @param n Node of type DOT_NODE
3132 */
3133 static int validate_dotref(astnode *n, void *arg, astnode **next)
3134 {
3135 symtab_entry *father;
3136 symtab_entry *def;
3137 astnode *type;
3138 astnode *left;
3139 if (astnode_has_ancestor_of_type(n, DOT_NODE)) {
3140 return 1; /* Already validated, since this function is recursive */
3141 }
3142 /* Look up parent in global symbol table */
3143 left = LHS(n); /* n := left . right */
3144 if (astnode_is_type(left, INDEX_NODE)) {
3145 left = LHS(left); /* Need identifier */
3146 }
3147 father = symtab_lookup(left->ident);
3148 if (father == NULL) {
3149 err(n->loc, "unknown symbol `%s'", left->ident);
3150 /* Replace by integer 0 */
3151 astnode_replace(n, astnode_create_integer(0, n->loc) );
3152 astnode_finalize(n);
3153 return 0;
3154 } else {
3155 father->ref_count++;
3156 /* Verify the variable's type -- should be user-defined */
3157 type = LHS(father->def);
3158 if ((type == NULL) || (type->datatype != USER_DATATYPE)) {
3159 err(n->loc, "`%s' is not a structure", left->ident);
3160 /* Replace by integer 0 */
3161 astnode_replace(n, astnode_create_integer(0, n->loc) );
3162 astnode_finalize(n);
3163 return 0;
3164 } else {
3165 def = symtab_lookup(LHS(type)->ident);
3166 if (def == NULL) {
3167 err(n->loc, "'%s' is of unknown type (`%s')", left->ident, LHS(type)->ident);
3168 /* Replace by integer 0 */
3169 astnode_replace(n, astnode_create_integer(0, n->loc) );
3170 astnode_finalize(n);
3171 return 0;
3172 } else if ( !((def->type == STRUC_SYMBOL) || (def->type == UNION_SYMBOL)) ) {
3173 err(n->loc, "`%s' is not a structure", left->ident);
3174 /* Replace by integer 0 */
3175 astnode_replace(n, astnode_create_integer(0, n->loc) );
3176 astnode_finalize(n);
3177 return 0;
3178 } else {
3179 /* Verify fields recursively */
3180 symtab_push(def->symtab);
3181 validate_dotref_recursive(n, n);
3182 symtab_pop();
3183 }
3184 }
3185 }
3186 return 1;
3187 }
3188
3189 /*---------------------------------------------------------------------------*/
3190
3191 /**
3192 * Evaluates expressions involved in conditional assembly, and removes the
3193 * appropriate branches from the AST.
3194 * Does some other stuff too, such as substitute equates and fold constants.
3195 */
3196 void astproc_first_pass(astnode *root)
3197 {
3198 /* Table of callback functions for our purpose. */
3199 static astnodeprocmap map[] = {
3200 { LABEL_NODE, enter_label },
3201 { VAR_DECL_NODE, enter_var },
3202 { PROC_NODE, enter_proc },
3203 { STRUC_DECL_NODE, enter_struc },
3204 { UNION_DECL_NODE, enter_union },
3205 { ENUM_DECL_NODE, enter_enum },
3206 { RECORD_DECL_NODE, enter_record },
3207 { LOCAL_LABEL_NODE, globalize_local },
3208 { LOCAL_ID_NODE, globalize_local },
3209 { MACRO_DECL_NODE, enter_macro },
3210 { MACRO_NODE, expand_macro },
3211 { REPT_NODE, process_rept },
3212 { WHILE_NODE, process_while },
3213 { DATASEG_NODE, process_dataseg },
3214 { CODESEG_NODE, process_codeseg },
3215 { ORG_NODE, process_org },
3216 { CHARMAP_NODE, load_charmap },
3217 { INSTRUCTION_NODE, process_instruction },
3218 { DATA_NODE, process_data },
3219 { STORAGE_NODE, process_storage },
3220 { EQU_NODE, process_equ },
3221 { ASSIGN_NODE, process_assign },
3222 { IFDEF_NODE, process_ifdef },
3223 { IFNDEF_NODE, process_ifndef },
3224 { IF_NODE, process_if },
3225 { EXTRN_NODE, tag_extrn_symbols },
3226 { MESSAGE_NODE, process_message },
3227 { WARNING_NODE, process_warning },
3228 { ERROR_NODE, process_error },
3229 { FORWARD_BRANCH_DECL_NODE, process_forward_branch_decl },
3230 { BACKWARD_BRANCH_DECL_NODE, process_backward_branch_decl },
3231 { FORWARD_BRANCH_NODE, process_forward_branch },
3232 { BACKWARD_BRANCH_NODE, process_backward_branch },
3233 { 0, NULL }
3234 };
3235 reset_charmap();
3236 branch_init();
3237 in_dataseg = 0; /* codeseg is default */
3238 /* Do the walk. */
3239 astproc_walk(root, NULL, map);
3240 /* Remove all the volatile constants from the symbol table */
3241 /* These are the ones defined with the '=' operator, whose identifiers should
3242 all have been replaced by their value in the syntax tree now. Since
3243 they're not referenced anywhere we can safely dispose of them.
3244 The EQUates on the other hand should be kept, since they will
3245 possibly be exported. */
3246 #ifdef ENABLE_BUGGY_THING // ### FIXME
3247 {
3248 int i;
3249 symbol_ident_list list;
3250 symtab_entry *e;
3251 symtab_list_type(CONSTANT_SYMBOL, &list);
3252 for (i = 0; i < list.size; ++i) {
3253 e = symtab_lookup(list.idents[i]);
3254 if (e->flags & VOLATILE_FLAG) {
3255 symtab_remove(list.idents[i]);
3256 }
3257 }
3258 symtab_list_finalize(&list);
3259 }
3260 #endif
3261 }
3262
3263 /*---------------------------------------------------------------------------*/
3264
3265 /**
3266 * Tags labels as public.
3267 * @param public A node of type PUBLIC_NODE
3268 */
3269 static int tag_public_symbols(astnode *public, void *arg, astnode **next)
3270 {
3271 astnode *id;
3272 symtab_entry *e;
3273 /* Go through the list of identifiers */
3274 for (id=astnode_get_first_child(public); id != NULL; id = astnode_get_next_sibling(id) ) {
3275 e = symtab_lookup(id->ident);
3276 if (e != NULL) {
3277 if (e->flags & EXTRN_FLAG) {
3278 err(public->loc, "`%s' already declared extrn", id->ident);
3279 } else {
3280 switch (e->type) {
3281 case LABEL_SYMBOL:
3282 case CONSTANT_SYMBOL:
3283 case VAR_SYMBOL:
3284 case PROC_SYMBOL:
3285 /* GO! */
3286 e->flags |= PUBLIC_FLAG;
3287 break;
3288
3289 default:
3290 err(public->loc, "`%s' is of non-exportable type", id->ident);
3291 break;
3292 }
3293 }
3294 } else {
3295 warn(public->loc, "`%s' declared as public but is not defined", id->ident);
3296 }
3297 }
3298 astnode_remove(public);
3299 astnode_finalize(public);
3300 return 0;
3301 }
3302
3303 /**
3304 * Sets alignment for a set of (data) labels.
3305 * @param align A node of type ALIGN_NODE
3306 */
3307 static int tag_align_symbols(astnode *align, void *arg, astnode **next)
3308 {
3309 int pow;
3310 astnode *id;
3311 astnode *idents;
3312 astnode *expr;
3313 symtab_entry *e;
3314 /* Go through the list of identifiers */
3315 idents = LHS(align);
3316 for (id=astnode_get_first_child(idents); id != NULL; id = astnode_get_next_sibling(id) ) {
3317 e = symtab_lookup(id->ident);
3318 if (e != NULL) {
3319 if (!(e->flags & DATA_FLAG)) {
3320 err(align->loc, "cannot align a code symbol (`%s')", id->ident);
3321 } else {
3322 switch (e->type) {
3323 case LABEL_SYMBOL:
3324 case VAR_SYMBOL:
3325 expr = reduce_expression(RHS(align));
3326 if (!astnode_is_type(expr, INTEGER_NODE)) {
3327 err(align->loc, "alignment expression must be an integer literal");
3328 } else if ((expr->integer < 0) || (expr->integer >= 0x10000)) {
3329 err(align->loc, "alignment expression out of range");
3330 } else if (expr->integer > 1) {
3331 pow = 0;
3332 switch (expr->integer) {
3333 case 32768: pow++;
3334 case 16384: pow++;
3335 case 8192: pow++;
3336 case 4096: pow++;
3337 case 2048: pow++;
3338 case 1024: pow++;
3339 case 512: pow++;
3340 case 256: pow++;
3341 case 128: pow++;
3342 case 64: pow++;
3343 case 32: pow++;
3344 case 16: pow++;
3345 case 8: pow++;
3346 case 4: pow++;
3347 case 2: pow++;
3348 /* GO! */
3349 e->flags |= ALIGN_FLAG;
3350 e->align = pow;
3351 break;
3352
3353 default:
3354 err(align->loc, "alignment expression must be a power of 2");
3355 break;
3356 }
3357 }
3358 break;
3359
3360 default:
3361 err(align->loc, "`%s' cannot be aligned", id->ident);
3362 break;
3363 }
3364 }
3365 }
3366 else {
3367 warn(align->loc, "alignment ignored for undefined symbol `%s'", id->ident);
3368 }
3369 }
3370 astnode_remove(align);
3371 astnode_finalize(align);
3372 return 0;
3373 }
3374
3375 /*---------------------------------------------------------------------------*/
3376
3377 /**
3378 * Removes unused labels from a syntax tree (and symbol table).
3379 * Unused labels are labels that are defined but not referenced anywhere.
3380 * This function assumes that the reference counts have already been calculated.
3381 */
3382 void remove_unused_labels()
3383 {
3384 int i;
3385 char *id;
3386 astnode *n;
3387 symbol_ident_list list;
3388 symtab_list_type(LABEL_SYMBOL, &list);
3389 for (i=0; i<list.size; i++) {
3390 id = list.idents[i];
3391 symtab_entry * e = symtab_lookup(id);
3392 if ((e->ref_count == 0) && ((e->flags & PUBLIC_FLAG) == 0)) {
3393 n = e->def;
3394 strtok(n->label, "#"); /* Remove globalize junk */
3395 warn(n->loc, "`%s' defined but not used", n->label);
3396 astnode_remove(n);
3397 astnode_finalize(n);
3398 //symtab_remove(n->label); ### FIXME leads to crash sometimes...
3399 }
3400 }
3401 symtab_list_finalize(&list);
3402 }
3403
3404 /**
3405 * If the storage is of user-defined type, replaces it with
3406 * .DSB sizeof(type) * count
3407 */
3408 static int reduce_user_storage(astnode *n, void *arg, astnode **next)
3409 {
3410 astnode *type;
3411 astnode *count;
3412 astnode *byte_storage;
3413 symtab_entry *e;
3414 type = LHS(n);
3415 if (type->datatype == USER_DATATYPE) {
3416 e = symtab_lookup(LHS(type)->ident);
3417 if (e != NULL) {
3418 /* Replace by DSB */
3419 count = RHS(n);
3420 byte_storage = astnode_create_storage(
3421 astnode_create_datatype(BYTE_DATATYPE, NULL, type->loc),
3422 astnode_create_arithmetic(
3423 MUL_OPERATOR,
3424 astnode_create_sizeof(
3425 astnode_create_identifier(LHS(type)->ident, n->loc),
3426 n->loc
3427 ),
3428 astnode_clone(count, n->loc),
3429 n->loc
3430 ),
3431 n->loc
3432 );
3433 astnode_replace(n, byte_storage);
3434 astnode_finalize(n);
3435 *next = byte_storage;
3436 return 0;
3437 } else {
3438 err(n->loc, "unknown symbol `%s'", LHS(type)->ident);
3439 astnode_remove(n);
3440 astnode_finalize(n);
3441 return 0;
3442 }
3443 }
3444 return 1;
3445 }
3446
3447 /**
3448 * Second major pass over AST.
3449 */
3450 void astproc_second_pass(astnode *root)
3451 {
3452 /* Table of callback functions for our purpose. */
3453 static astnodeprocmap map[] = {
3454 { IDENTIFIER_NODE, validate_ref },
3455 { SCOPE_NODE, validate_scoperef },
3456 { DOT_NODE, validate_dotref },
3457 { INDEX_NODE, validate_index },
3458 { PUBLIC_NODE, tag_public_symbols },
3459 { STORAGE_NODE, reduce_user_storage },
3460 { ALIGN_NODE, tag_align_symbols },
3461 { STRUC_DECL_NODE, noop },
3462 { UNION_DECL_NODE, noop },
3463 { ENUM_DECL_NODE, noop },
3464 { RECORD_DECL_NODE, noop },
3465 { 0, NULL }
3466 };
3467 in_dataseg = 0; /* codeseg is default */
3468 /* Do the walk. */
3469 astproc_walk(root, NULL, map);
3470 /* */
3471 remove_unused_labels();
3472 }
3473
3474 /*---------------------------------------------------------------------------*/
3475
3476 /**
3477 * Translates a single instruction.
3478 * @param instr A node of type INSTRUCTION_NODE
3479 */
3480 static int translate_instruction(astnode *instr, void *arg, astnode **next)
3481 {
3482 unsigned char c;
3483 /* Put the operand in final form */
3484 astnode *o = reduce_expression_complete( LHS(instr) );
3485 assert(o == LHS(instr));
3486 /* Convert (mnemonic, addressing mode) pair to opcode */
3487 instr->instr.opcode = opcode_get(instr->instr.mnemonic, instr->instr.mode);
3488 if (instr->instr.opcode == 0xFF) {
3489 /* Check for the special cases */
3490 if ((instr->instr.mnemonic == STX_MNEMONIC) && (instr->instr.mode == ABSOLUTE_Y_MODE)) {
3491 /* Doesn't have absolute version, "scale down" to zeropage */
3492 instr->instr.mode = ZEROPAGE_Y_MODE;
3493 instr->instr.opcode = opcode_get(instr->instr.mnemonic, instr->instr.mode);
3494 } else if ((instr->instr.mnemonic == STY_MNEMONIC) && (instr->instr.mode == ABSOLUTE_X_MODE)) {
3495 /* Doesn't have absolute version, "scale down" to zeropage */
3496 instr->instr.mode = ZEROPAGE_X_MODE;
3497 instr->instr.opcode = opcode_get(instr->instr.mnemonic, instr->instr.mode);
3498 } else if (instr->instr.mode == ABSOLUTE_MODE) {
3499 /* Check for relative addressing (these are parsed as absolute mode) */
3500 switch (instr->instr.mnemonic) {
3501 case BCC_MNEMONIC:
3502 case BCS_MNEMONIC:
3503 case BEQ_MNEMONIC:
3504 case BMI_MNEMONIC:
3505 case BNE_MNEMONIC:
3506 case BPL_MNEMONIC:
3507 case BVC_MNEMONIC:
3508 case BVS_MNEMONIC:
3509 /* Fix addressing mode and opcode */
3510 instr->instr.mode = RELATIVE_MODE;
3511 instr->instr.opcode = opcode_get(instr->instr.mnemonic, instr->instr.mode);
3512 break;
3513 }
3514 }
3515 }
3516 if (instr->instr.opcode != 0xFF) {
3517 /* If the operand is a constant, see if we can "reduce" from
3518 absolute mode to zeropage mode */
3519 if ((astnode_is_type(o, INTEGER_NODE)) &&
3520 ((unsigned long)o->integer < 256) &&
3521 ((c = opcode_zp_equiv(instr->instr.opcode)) != 0xFF)) {
3522 /* Switch to the zeromode version */
3523 instr->instr.opcode = c;
3524 switch (instr->instr.mode) {
3525 case ABSOLUTE_MODE: instr->instr.mode = ZEROPAGE_MODE; break;
3526 case ABSOLUTE_X_MODE: instr->instr.mode = ZEROPAGE_X_MODE; break;
3527 case ABSOLUTE_Y_MODE: instr->instr.mode = ZEROPAGE_Y_MODE; break;
3528 default: /* Impossible to get here, right? */ break;
3529 }
3530 }
3531 /* If the operand is a constant, make sure it fits */
3532 if (astnode_is_type(o, INTEGER_NODE)) {
3533 switch (instr->instr.mode) {
3534 case IMMEDIATE_MODE:
3535 case ZEROPAGE_MODE:
3536 case ZEROPAGE_X_MODE:
3537 case ZEROPAGE_Y_MODE:
3538 case PREINDEXED_INDIRECT_MODE:
3539 case POSTINDEXED_INDIRECT_MODE:
3540 /* Operand must fit in 8 bits */
3541 if (!IS_BYTE_VALUE(o->integer)) {
3542 warn(o->loc, "operand out of range; truncated");
3543 o->integer &= 0xFF;
3544 }
3545 break;
3546
3547 case ABSOLUTE_MODE:
3548 case ABSOLUTE_X_MODE:
3549 case ABSOLUTE_Y_MODE:
3550 case INDIRECT_MODE:
3551 /* Operand must fit in 16 bits */
3552 if ((unsigned long)o->integer >= 0x10000) {
3553 warn(o->loc, "operand out of range; truncated");
3554 o->integer &= 0xFFFF;
3555 }
3556 break;
3557
3558 case RELATIVE_MODE:
3559 /* Constant isn't allowed here is it? */
3560 break;
3561
3562 default:
3563 break;
3564 }
3565 }
3566 else if (astnode_is_type(o, STRING_NODE)) {
3567 /* String operand doesn't make sense here */
3568 err(instr->loc, "invalid operand");
3569 }
3570 } else {
3571 err(instr->loc, "invalid addressing mode");
3572 }
3573 return 0;
3574 }
3575
3576 /**
3577 * ### Is this really such a good idea?
3578 */
3579 static int maybe_merge_data(astnode *n, void *arg, astnode **next)
3580 {
3581 astnode *temp;
3582 astnode *type;
3583 type = LHS(n);
3584 /* Only merge if no debugging, otherwise line information is lost. */
3585 if (!xasm_args.debug && astnode_is_type(*next, DATA_NODE)
3586 && astnode_equal(type, LHS(*next)) ) {
3587 /* Merge ahead */
3588 temp = *next;
3589 astnode_finalize( astnode_remove_child_at(temp, 0) ); /* Remove datatype node */
3590 astnode_add_child(n, astnode_remove_children(temp) );
3591 astnode_finalize(temp);
3592 *next = n;
3593 } else {
3594 /* Reduce expressions to final form */
3595 for (n = n->first_child; n != NULL; n = temp->next_sibling) {
3596 temp = reduce_expression_complete(n);
3597 if (astnode_is_type(temp, INTEGER_NODE)) {
3598 /* Check that value fits according to datatype */
3599 switch (type->datatype) {
3600 case BYTE_DATATYPE:
3601 if (!IS_BYTE_VALUE(temp->integer)) {
3602 warn(temp->loc, "operand out of range; truncated");
3603 temp->integer &= 0xFF;
3604 }
3605 break;
3606
3607 case WORD_DATATYPE:
3608 if (!IS_WORD_VALUE(temp->integer)) {
3609 warn(temp->loc, "operand out of range; truncated");
3610 temp->integer &= 0xFFFF;
3611 }
3612 break;
3613
3614 case DWORD_DATATYPE:
3615 break;
3616
3617 default:
3618 break;
3619 }
3620 }
3621 }
3622 }
3623 return 0;
3624 }
3625
3626 /**
3627 *
3628 */
3629 static int maybe_merge_storage(astnode *storage, void *arg, astnode **next)
3630 {
3631 astnode *temp;
3632 astnode *new_count;
3633 astnode *old_count;
3634 if (astnode_is_type(*next, STORAGE_NODE)
3635 && astnode_equal(LHS(storage), LHS(*next)) ) {
3636 /* Merge ahead */
3637 temp = *next;
3638 astnode_finalize( astnode_remove_child_at(temp, 0) ); /* Remove datatype node */
3639 old_count = RHS(storage);
3640 /* Calculate new count */
3641 new_count = astnode_create_arithmetic(
3642 PLUS_OPERATOR,
3643 astnode_remove_child_at(temp, 0),
3644 astnode_clone(old_count, storage->loc),
3645 storage->loc
3646 );
3647 new_count = reduce_expression_complete(new_count);
3648 astnode_replace(old_count, new_count);
3649 astnode_finalize(old_count);
3650 astnode_finalize(temp);
3651 *next = storage;
3652 } else {
3653 reduce_expression_complete(RHS(storage));
3654 }
3655 return 0;
3656 }
3657
3658 /**
3659 * Replaces .proc by its label followed by statements.
3660 */
3661 static int flatten_proc(astnode *proc, void *arg, astnode **next)
3662 {
3663 astnode *id = LHS(proc);
3664 astnode *list = RHS(proc);
3665 astnode_remove(id);
3666 id->type = LABEL_NODE;
3667 astnode_insert_child(list, id, 0);
3668 astnode *stmts = astnode_remove_children(list);
3669 astnode_replace(proc, stmts);
3670 astnode_finalize(proc);
3671 *next = stmts;
3672 return 0;
3673 }
3674
3675 /**
3676 *
3677 */
3678 static int flatten_var_decl(astnode *var, void *arg, astnode **next)
3679 {
3680 astnode *stmts = LHS(var);
3681 astnode_remove_children(var);
3682 stmts->type = LABEL_NODE;
3683 astnode_replace(var, stmts);
3684 astnode_finalize(var);
3685 *next = stmts;
3686 return 0;
3687 }
3688
3689 /**
3690 * Third and final pass (if the output isn't pure 6502).
3691 * Translates instructions, merges data and storage nodes,
3692 * and reduces their operands to final form on the way.
3693 */
3694 void astproc_third_pass(astnode *root)
3695 {
3696 /* Table of callback functions for our purpose. */
3697 static astnodeprocmap map[] = {
3698 { INSTRUCTION_NODE, translate_instruction },
3699 { DATA_NODE, maybe_merge_data },
3700 { STORAGE_NODE, maybe_merge_storage },
3701 { VAR_DECL_NODE, flatten_var_decl },
3702 { PROC_NODE, flatten_proc },
3703 { STRUC_DECL_NODE, noop },
3704 { UNION_DECL_NODE, noop },
3705 { ENUM_DECL_NODE, noop },
3706 { RECORD_DECL_NODE, noop },
3707 { 0, NULL }
3708 };
3709 in_dataseg = 0; /* codeseg is default */
3710 /* Do the walk. */
3711 astproc_walk(root, NULL, map);
3712 }
3713
3714 /*---------------------------------------------------------------------------*/
3715
3716 /**
3717 * Evaluates the given expression, _without_ replacing it in the AST
3718 * (unlike astproc_reduce_expression() and friends).
3719 */
3720 static astnode *eval_expression(astnode *expr)
3721 {
3722 switch (astnode_get_type(expr)) {
3723
3724 case ARITHMETIC_NODE: {
3725 astnode *lhs = eval_expression(LHS(expr));
3726 astnode *rhs = eval_expression(RHS(expr));
3727 switch (expr->oper) {
3728 /* Binary ops */
3729 case PLUS_OPERATOR:
3730 case MINUS_OPERATOR:
3731 case MUL_OPERATOR:
3732 case DIV_OPERATOR:
3733 case MOD_OPERATOR:
3734 case AND_OPERATOR:
3735 case OR_OPERATOR:
3736 case XOR_OPERATOR:
3737 case SHL_OPERATOR:
3738 case SHR_OPERATOR:
3739 case LT_OPERATOR:
3740 case GT_OPERATOR:
3741 case EQ_OPERATOR:
3742 case NE_OPERATOR:
3743 case LE_OPERATOR:
3744 case GE_OPERATOR:
3745 if (astnode_is_type(lhs, INTEGER_NODE)
3746 && astnode_is_type(rhs, INTEGER_NODE)) {
3747 /* Both sides are integer literals. */
3748 switch (expr->oper) {
3749 case PLUS_OPERATOR: return astnode_create_integer(lhs->integer + rhs->integer, expr->loc);
3750 case MINUS_OPERATOR: return astnode_create_integer(lhs->integer - rhs->integer, expr->loc);
3751 case MUL_OPERATOR: return astnode_create_integer(lhs->integer * rhs->integer, expr->loc);
3752 case DIV_OPERATOR: return astnode_create_integer(lhs->integer / rhs->integer, expr->loc);
3753 case MOD_OPERATOR: return astnode_create_integer(lhs->integer % rhs->integer, expr->loc);
3754 case AND_OPERATOR: return astnode_create_integer(lhs->integer & rhs->integer, expr->loc);
3755 case OR_OPERATOR: return astnode_create_integer(lhs->integer | rhs->integer, expr->loc);
3756 case XOR_OPERATOR: return astnode_create_integer(lhs->integer ^ rhs->integer, expr->loc);
3757 case SHL_OPERATOR: return astnode_create_integer(lhs->integer << rhs->integer, expr->loc);
3758 case SHR_OPERATOR: return astnode_create_integer(lhs->integer >> rhs->integer, expr->loc);
3759 case LT_OPERATOR: return astnode_create_integer(lhs->integer < rhs->integer, expr->loc);
3760 case GT_OPERATOR: return astnode_create_integer(lhs->integer > rhs->integer, expr->loc);
3761 case EQ_OPERATOR: return astnode_create_integer(lhs->integer == rhs->integer, expr->loc);
3762 case NE_OPERATOR: return astnode_create_integer(lhs->integer != rhs->integer, expr->loc);
3763 case LE_OPERATOR: return astnode_create_integer(lhs->integer <= rhs->integer, expr->loc);
3764 case GE_OPERATOR: return astnode_create_integer(lhs->integer >= rhs->integer, expr->loc);
3765
3766 default: /* ### Error, actually */
3767 break;
3768 }
3769 }
3770 /* Use some mathematical identities... */
3771 else if ((astnode_is_type(lhs, INTEGER_NODE) && (lhs->integer == 0))
3772 && (expr->oper == PLUS_OPERATOR)) {
3773 /* 0+expr == expr */
3774 return astnode_clone(rhs, rhs->loc);
3775 } else if ((astnode_is_type(rhs, INTEGER_NODE) && (rhs->integer == 0))
3776 && (expr->oper == PLUS_OPERATOR)) {
3777 /* expr+0 == expr */
3778 return astnode_clone(lhs, lhs->loc);
3779 } else if ((astnode_is_type(lhs, INTEGER_NODE) && (lhs->integer == 1))
3780 && (expr->oper == MUL_OPERATOR)) {
3781 /* 1*expr == expr */
3782 return astnode_clone(rhs, rhs->loc);
3783 } else if ((astnode_is_type(rhs, INTEGER_NODE) && (rhs->integer == 1))
3784 && ((expr->oper == MUL_OPERATOR) || (expr->oper == DIV_OPERATOR)) ) {
3785 /* expr*1 == expr */
3786 /* expr/1 == expr */
3787 return astnode_clone(lhs, lhs->loc);
3788 }
3789 break;
3790
3791 /* Unary ops */
3792 case NEG_OPERATOR:
3793 case NOT_OPERATOR:
3794 case LO_OPERATOR:
3795 case HI_OPERATOR:
3796 case UMINUS_OPERATOR:
3797 case BANK_OPERATOR:
3798 if (astnode_is_type(lhs, INTEGER_NODE)) {
3799 switch (expr->oper) {
3800 case NEG_OPERATOR: return astnode_create_integer(~lhs->integer, expr->loc);
3801 case NOT_OPERATOR: return astnode_create_integer(!lhs->integer, expr->loc);
3802 case LO_OPERATOR: return astnode_create_integer(lhs->integer & 0xFF, expr->loc);
3803 case HI_OPERATOR: return astnode_create_integer((lhs->integer >> 8) & 0xFF, expr->loc);
3804 case UMINUS_OPERATOR: return astnode_create_integer(-lhs->integer, expr->loc);
3805 default: break;
3806 }
3807 }
3808 break;
3809 } /* switch */
3810 } break;
3811
3812 case INTEGER_NODE:
3813 return astnode_clone(expr, expr->loc);
3814
3815 case IDENTIFIER_NODE: {
3816 symtab_entry *e = symtab_lookup(expr->ident);
3817 // ### assert(e->type == LABEL_SYMBOL);
3818 if (e->flags & ADDR_FLAG)
3819 return astnode_create_integer(e->address, expr->loc);
3820 } break;
3821
3822 case CURRENT_PC_NODE:
3823 return astnode_create_integer(in_dataseg ? dataseg_pc : codeseg_pc, expr->loc);
3824
3825 default:
3826 break;
3827 } /* switch */
3828 return 0;
3829 }
3830
3831 /**
3832 * Sets the address of the label to be the currently calculated PC.
3833 */
3834 static int set_label_address(astnode *label, void *arg, astnode **next)
3835 {
3836 symtab_entry *e = symtab_lookup(label->ident);
3837 // ### assert(e && (e->type == LABEL_SYMBOL));
3838 e->address = in_dataseg ? dataseg_pc : codeseg_pc;
3839 e->flags |= ADDR_FLAG;
3840 return 0;
3841 }
3842
3843 /**
3844 * Sets the current PC to the address specified by the ORG node.
3845 */
3846 static int set_pc_from_org(astnode *org, void *arg, astnode **next)
3847 {
3848 astnode *addr = LHS(org);
3849 assert(astnode_is_type(addr, INTEGER_NODE));
3850 if (in_dataseg)
3851 dataseg_pc = addr->integer;
3852 else
3853 codeseg_pc = addr->integer;
3854 return 0;
3855 }
3856
3857 /**
3858 * Ensures that the given symbol is defined.
3859 */
3860 static int ensure_symbol_is_defined(astnode *id, void *arg, astnode **next)
3861 {
3862 symtab_entry *e = symtab_lookup(id->ident);
3863 assert(e);
3864 if ((e->flags & EXTRN_FLAG) && !(e->flags & ERROR_UNDEFINED_FLAG)) {
3865 err(id->loc, "cannot generate pure binary because `%s' is not defined", id->ident);
3866 e->flags |= ERROR_UNDEFINED_FLAG;
3867 }
3868 return 0;
3869 }
3870
3871 /**
3872 * Increments PC according to the size of the instruction.
3873 */
3874 static int inc_pc_by_instruction(astnode *instr, void *arg, astnode **next)
3875 {
3876 assert(!in_dataseg);
3877 if (LHS(instr)) {
3878 /* Has operand */
3879 unsigned char zp_op = opcode_zp_equiv(instr->instr.opcode);
3880 if (zp_op != 0xFF) {
3881 /* See if we can optimize this to a ZP-instruction */
3882 astnode *operand = eval_expression(LHS(instr));
3883 if (operand && astnode_is_type(operand, INTEGER_NODE)) {
3884 if ((operand->integer >= 0) && (operand->integer < 256)) {
3885 instr->instr.opcode = zp_op;
3886 }
3887 astnode_finalize(operand);
3888 }
3889 }
3890 }
3891 codeseg_pc += opcode_length(instr->instr.opcode);
3892 return 1;
3893 }
3894
3895 /**
3896 * Increments PC according to the size of the defined data.
3897 */
3898 static int inc_pc_by_data(astnode *data, void *arg, astnode **next)
3899 {
3900 astnode *type = LHS(data);
3901 int count = astnode_get_child_count(data) - 1;
3902 int nbytes;
3903 assert(!in_dataseg);
3904 switch (type->datatype) {
3905 case BYTE_DATATYPE: nbytes = count; break;
3906 case WORD_DATATYPE: nbytes = count * 2; break;
3907 case DWORD_DATATYPE: nbytes = count * 4; break;
3908 default:
3909 assert(0);
3910 break;
3911 }
3912 codeseg_pc += nbytes;
3913 return 0;
3914 }
3915
3916 /**
3917 * Increments PC according to the size of the included binary.
3918 */
3919 static int inc_pc_by_binary(astnode *node, void *arg, astnode **next)
3920 {
3921 assert(!in_dataseg);
3922 codeseg_pc += node->binary.size;
3923 return 0;
3924 }
3925
3926 /**
3927 * Increments PC according to the size of the storage.
3928 */
3929 static int inc_pc_by_storage(astnode *storage, void *arg, astnode **next)
3930 {
3931 astnode *type = LHS(storage);
3932 assert(type->datatype == BYTE_DATATYPE);
3933 astnode *count = eval_expression(RHS(storage));
3934 if (count) {
3935 if (astnode_get_type(count) == INTEGER_NODE) {
3936 if (in_dataseg)
3937 dataseg_pc += count->integer;
3938 else
3939 codeseg_pc += count->integer;
3940 }
3941 astnode_finalize(count);
3942 }
3943 return 1;
3944 }
3945
3946 /**
3947 * This pass is only performed if the output format is pure 6502.
3948 * It ensures that it is actually possible to generate pure 6502
3949 * for this syntax tree (i.e. no external symbols).
3950 * Furthermore, it calculates the address of all labels, so that
3951 * everything is ready for the final output phase.
3952 */
3953 void astproc_fourth_pass(astnode *root)
3954 {
3955 int x;
3956 /* ### Should loop while there's a change in the address of
3957 one or more labels */
3958 for (x = 0; x < 2; ++x) {
3959 in_dataseg = 0; /* codeseg is default */
3960 dataseg_pc = 0;
3961 codeseg_pc = 0;
3962 /* Table of callback functions for our purpose. */
3963 static astnodeprocmap map[] = {
3964 { DATASEG_NODE, process_dataseg },
3965 { CODESEG_NODE, process_codeseg },
3966 { ORG_NODE, set_pc_from_org },
3967 { LABEL_NODE, set_label_address },
3968 { IDENTIFIER_NODE, ensure_symbol_is_defined },
3969 { INSTRUCTION_NODE, inc_pc_by_instruction },
3970 { DATA_NODE, inc_pc_by_data },
3971 { STORAGE_NODE, inc_pc_by_storage },
3972 { BINARY_NODE, inc_pc_by_binary },
3973 { STRUC_DECL_NODE, noop },
3974 { UNION_DECL_NODE, noop },
3975 { ENUM_DECL_NODE, noop },
3976 { RECORD_DECL_NODE, noop },
3977 { 0, NULL }
3978 };
3979 /* Do the walk. */
3980 astproc_walk(root, NULL, map);
3981 }
3982 }
3983
3984 /*---------------------------------------------------------------------------*/
3985
3986 /**
3987 * Writes an instruction.
3988 */
3989 static int write_instruction(astnode *instr, void *arg, astnode **next)
3990 {
3991 FILE *fp = (FILE *)arg;
3992 unsigned char op = instr->instr.opcode;
3993 int len = opcode_length(op);
3994 fputc(op, fp);
3995 if (len > 1) {
3996 /* Write operand */
3997 astnode *operand = eval_expression(LHS(instr));
3998 if(!astnode_is_type(operand, INTEGER_NODE)) {
3999 /* ### This is rather fatal, it should be a literal by this point */
4000 err(instr->loc, "operand does not evaluate to literal");
4001 } else {
4002 int value = operand->integer;
4003 if (len == 2) {
4004 /* Check if it's a relative jump */
4005 switch (op) {
4006 case 0x10:
4007 case 0x30:
4008 case 0x50:
4009 case 0x70:
4010 case 0x90:
4011 case 0xB0:
4012 case 0xD0:
4013 case 0xF0:
4014 /* Calculate difference between target and address of next instruction */
4015 value = value - (codeseg_pc + 2);
4016 if (!IS_BYTE_VALUE(value)) {
4017 err(operand->loc, "branch out of range");
4018 value &= 0xFF;
4019 }
4020 break;
4021
4022 default:
4023 if (!IS_BYTE_VALUE(value)) {
4024 warn(operand->loc, "operand out of range; truncated");
4025 value &= 0xFF;
4026 }
4027 break;
4028 }
4029 fputc((unsigned char)value, fp);
4030 } else {
4031 assert(len == 3);
4032 if (!IS_WORD_VALUE(value)) {
4033 warn(operand->loc, "operand out of range; truncated");
4034 value &= 0xFFFF;
4035 }
4036 fputc((unsigned char)value, fp);
4037 fputc((unsigned char)(value >> 8), fp);
4038 }
4039 }
4040 astnode_finalize(operand);
4041 }
4042 codeseg_pc += opcode_length(instr->instr.opcode);
4043 return 0;
4044 }
4045
4046 /**
4047 * Writes data.
4048 */
4049 static int write_data(astnode *data, void *arg, astnode **next)
4050 {
4051 FILE *fp = (FILE *)arg;
4052 astnode *type = LHS(data);
4053 astnode *expr;
4054 assert(!in_dataseg);
4055 for (expr = RHS(data); expr != NULL; expr = astnode_get_next_sibling(expr) ) {
4056 int value;
4057 astnode *e = eval_expression(expr);
4058 assert(e->type == INTEGER_NODE);
4059 value = e->integer;
4060 switch (type->datatype) {
4061 case BYTE_DATATYPE:
4062 if (!IS_BYTE_VALUE(value)) {
4063 warn(expr->loc, "operand out of range; truncated");
4064 value &= 0xFF;
4065 }
4066 fputc((unsigned char)value, fp);
4067 codeseg_pc += 1;
4068 break;
4069
4070 case WORD_DATATYPE:
4071 if (!IS_WORD_VALUE(value)) {
4072 warn(expr->loc, "operand out of range; truncated");
4073 value &= 0xFFFF;
4074 }
4075 fputc((unsigned char)value, fp);
4076 fputc((unsigned char)(value >> 8), fp);
4077 codeseg_pc += 2;
4078 break;
4079
4080 case DWORD_DATATYPE:
4081 fputc((unsigned char)value, fp);
4082 fputc((unsigned char)(value >> 8), fp);
4083 fputc((unsigned char)(value >> 16), fp);
4084 fputc((unsigned char)(value >> 24), fp);
4085 codeseg_pc += 4;
4086 break;
4087
4088 default:
4089 assert(0);
4090 break;
4091 }
4092 astnode_finalize(e);
4093 }
4094 return 0;
4095 }
4096
4097 /**
4098 * Writes storage (padding).
4099 */
4100 static int write_storage(astnode *storage, void *arg, astnode **next)
4101 {
4102 FILE *fp = (FILE *)arg;
4103 astnode *type = LHS(storage);
4104 astnode *count = eval_expression(RHS(storage));
4105 assert(type->datatype == BYTE_DATATYPE);
4106 assert(!in_dataseg);
4107 if (count) {
4108 int i;
4109 assert(astnode_get_type(count) == INTEGER_NODE);
4110 for (i = 0; i < count->integer; ++i)
4111 fputc(0, fp);
4112 codeseg_pc += count->integer;
4113 astnode_finalize(count);
4114 }
4115 return 0;
4116 }
4117
4118 /**
4119 * Writes binary.
4120 */
4121 static int write_binary(astnode *node, void *arg, astnode **next)
4122 {
4123 FILE *fp = (FILE *)arg;
4124 assert(!in_dataseg);
4125 fwrite(node->binary.data, 1, node->binary.size, fp);
4126 codeseg_pc += node->binary.size;
4127 return 0;
4128 }
4129
4130 /**
4131 * This pass is only performed if the output format is pure 6502.
4132 * It writes the binary code.
4133 */
4134 void astproc_fifth_pass(astnode *root)
4135 {
4136 FILE *fp = fopen(xasm_args.output_file, "wb");
4137 if (!fp) {
4138 fprintf(stderr, "could not open '%s' for writing\n", xasm_args.output_file);
4139 ++err_count;
4140 return;
4141 }
4142 /* Table of callback functions for our purpose. */
4143 static astnodeprocmap map[] = {
4144 { DATASEG_NODE, process_dataseg },
4145 { CODESEG_NODE, process_codeseg },
4146 { ORG_NODE, set_pc_from_org },
4147 { INSTRUCTION_NODE, write_instruction },
4148 { DATA_NODE, write_data },
4149 { STORAGE_NODE, write_storage },
4150 { BINARY_NODE, write_binary },
4151 { STRUC_DECL_NODE, noop },
4152 { UNION_DECL_NODE, noop },
4153 { ENUM_DECL_NODE, noop },
4154 { RECORD_DECL_NODE, noop },
4155 { 0, NULL }
4156 };
4157 in_dataseg = 0; /* codeseg is default */
4158 dataseg_pc = 0;
4159 codeseg_pc = 0;
4160 /* Do the walk. */
4161 astproc_walk(root, fp, map);
4162 fclose(fp);
4163 }
6502 assembler