Mercurial > hg-old > index.cgi
annotate src/lwasm.c @ 91:718998b673ee
Added incomplete references to object output and added support for section base terms in expression handler
| author | lost |
|---|---|
| date | Sat, 17 Jan 2009 05:56:40 +0000 |
| parents | e12edcfbebd5 |
| children | ea2cfebef5d0 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
2 lwasm.c |
| 55 | 3 Copyright © 2009 William Astle |
|
4
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
4 |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
5 This file is part of LWASM. |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
6 |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
7 LWASM is free software: you can redistribute it and/or modify it under the |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
8 terms of the GNU General Public License as published by the Free Software |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
9 Foundation, either version 3 of the License, or (at your option) any later |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
10 version. |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
11 |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
12 This program is distributed in the hope that it will be useful, but WITHOUT |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
15 more details. |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
16 |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
17 You should have received a copy of the GNU General Public License along with |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
18 this program. If not, see <http://www.gnu.org/licenses/>. |
|
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
19 |
| 26 | 20 |
| 21 Contains random functions used by the assembler | |
|
4
34568fab6058
Fixed package to include all required files; also added copyright preamble to all source files
lost
parents:
0
diff
changeset
|
22 */ |
| 0 | 23 |
| 26 | 24 #define __lwasm_c_seen__ |
| 25 | |
| 26 #include <stdarg.h> | |
| 0 | 27 #include <stdlib.h> |
| 26 | 28 #include <stdio.h> |
| 29 | |
| 0 | 30 #include "lwasm.h" |
| 26 | 31 #include "util.h" |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
32 #include "expr.h" |
| 0 | 33 |
| 38 | 34 int debug_level = 0; |
| 35 | |
| 26 | 36 int register_error(asmstate_t *as, lwasm_line_t *l, int pass, const char *fmt, ...) |
| 0 | 37 { |
| 26 | 38 lwasm_error_t *e; |
| 39 va_list args; | |
| 40 char errbuff[1024]; | |
| 41 int r; | |
| 0 | 42 |
| 26 | 43 if (as -> passnum != pass) |
| 44 return; | |
| 45 | |
| 46 va_start(args, fmt); | |
| 0 | 47 |
| 26 | 48 e = lwasm_alloc(sizeof(lwasm_error_t)); |
| 49 | |
| 50 e -> next = l -> err; | |
| 51 l -> err = e; | |
| 0 | 52 |
| 53 as -> errorcount++; | |
| 54 | |
| 26 | 55 r = vsnprintf(errbuff, 1024, fmt, args); |
| 56 e -> mess = lwasm_strdup(errbuff); | |
| 0 | 57 |
| 26 | 58 va_end(args); |
| 0 | 59 |
| 26 | 60 return r; |
| 0 | 61 } |
|
27
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
62 |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
63 void lwasm_emit(asmstate_t *as, lwasm_line_t *l, int b) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
64 { |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
65 as -> addr += 1; |
| 58 | 66 as -> addr &= 0xffff; |
| 67 | |
| 74 | 68 if (as -> outformat == OUTPUT_OBJ && !(as -> csect)) |
| 69 { | |
| 70 register_error(as, l, 1, "Output not allowed outside sections with obj target"); | |
| 71 return; | |
| 72 } | |
| 73 if (as -> outformat == OUTPUT_OBJ && as -> csect -> flags & SECTION_BSS) | |
| 74 { | |
| 75 register_error(as, l, 1, "Output not allowed inside BSS sections"); | |
| 76 return; | |
| 77 } | |
|
27
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
78 if (as -> passnum == 1) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
79 return; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
80 |
| 42 | 81 |
| 82 if (l -> codelen >= l -> codesize) | |
| 83 { | |
| 84 l -> bytes = realloc(l -> bytes, l -> codesize + 16); | |
| 85 l -> codesize += 16; | |
| 86 } | |
| 87 l -> bytes[l -> codelen] = b & 0xff; | |
| 88 l -> codelen += 1; | |
|
27
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
89 } |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
90 |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
91 void lwasm_emitop(asmstate_t *as, lwasm_line_t *l, int o) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
92 { |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
93 if (o >= 0x100) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
94 lwasm_emit(as, l, o >> 8); |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
95 lwasm_emit(as, l, o & 0xff); |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
96 } |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
97 |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
98 int lwasm_lookupreg2(const char *reglist, char **str) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
99 { |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
100 int rval = 0; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
101 |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
102 while (*reglist) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
103 { |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
104 if (toupper(**str) == *reglist) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
105 { |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
106 // first char matches |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
107 if (reglist[1] == ' ' && !isalpha(*(*str + 1))) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
108 break; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
109 if (toupper(*(*str + 1)) == reglist[1]) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
110 break; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
111 } |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
112 reglist += 2; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
113 rval++; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
114 } |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
115 if (!*reglist) |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
116 return -1; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
117 if (reglist[1] == ' ') |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
118 (*str)++; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
119 else |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
120 (*str) += 2; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
121 return rval; |
|
f736579569b4
Added handlers for inherent and register to register instructions
lost
parents:
26
diff
changeset
|
122 } |
| 32 | 123 |
| 124 int lwasm_lookupreg3(const char *rlist, const char **str) | |
| 125 { | |
| 126 int rval = 0; | |
| 127 int f = 0; | |
| 128 const char *reglist = rlist; | |
| 129 | |
| 130 while (*reglist) | |
| 131 { | |
| 132 if (toupper(**str) == *reglist) | |
| 133 { | |
| 134 // first char matches | |
| 135 if (reglist[1] == ' ') | |
| 136 { | |
| 137 f = 1; | |
| 138 break; | |
| 139 } | |
| 140 if (toupper(*(*str + 1)) == reglist[1]) | |
| 141 { | |
| 142 // second char matches | |
| 143 if (reglist[2] == ' ') | |
| 144 { | |
| 145 f = 1; | |
| 146 break; | |
| 147 } | |
| 148 if (toupper(*(*str + 2)) == reglist[2]) | |
| 149 { | |
| 150 f = 1; | |
| 151 break; | |
| 152 } | |
| 153 } | |
| 154 } | |
| 155 reglist += 3; | |
| 156 rval++; | |
| 157 } | |
| 158 if (f == 0) | |
| 159 return -1; | |
| 160 | |
| 161 | |
| 162 reglist = rval * 3 + rlist; | |
| 163 if (reglist[1] == ' ') | |
| 164 (*str) += 1; | |
| 165 else if (reglist[2] == ' ') | |
| 166 (*str) += 2; | |
| 167 else | |
| 168 (*str)+=3; | |
| 169 return rval; | |
| 170 } | |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
171 |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
172 struct symstateinfo |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
173 { |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
174 asmstate_t *as; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
175 lwasm_line_t *l; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
176 }; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
177 |
| 76 | 178 lwasm_expr_stack_t *lwasm_expr_lookup_symbol(char *sym, void *state) |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
179 { |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
180 lwasm_symbol_ent_t *se; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
181 struct symstateinfo *st; |
| 76 | 182 lwasm_expr_stack_t *rs; |
| 183 lwasm_expr_term_t *t; | |
| 184 lwasm_expr_stack_node_t *n; | |
| 185 | |
| 186 int val; | |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
187 |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
188 st = state; |
| 52 | 189 debug_message(3, "lwasm_expr_lookup_symbol(): find '%s' (context=%d)", sym, st -> as -> context); |
| 190 | |
| 60 | 191 // check for special symbols first... |
| 192 if (sym[1] == '\0') | |
| 193 { | |
| 194 switch (sym[0]) | |
| 195 { | |
| 196 // current line address | |
| 197 case '*': | |
| 198 case '.': | |
| 76 | 199 val = st -> l -> codeaddr; |
| 200 goto retconst; | |
| 60 | 201 |
| 202 case '<': | |
| 203 // previous branch point | |
| 204 // not implemented | |
| 205 break; | |
| 206 case '>': | |
| 207 // next branch point | |
| 208 // not implemented | |
| 209 break; | |
| 210 } | |
| 211 } | |
| 212 | |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
213 // look for local symbol first then global symbol |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
214 se = lwasm_find_symbol(st -> as, sym, st -> as -> context); |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
215 if (!se) |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
216 se = lwasm_find_symbol(st -> as, sym, -1); |
| 52 | 217 debug_message(3, "lwasm_expr_lookup_symbol(): got '%p'", se); |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
218 if (!se) |
| 77 | 219 { |
| 220 register_error(st -> as, st -> l, 2, "Undefined symbol '%s'", sym); | |
| 76 | 221 return NULL; |
| 77 | 222 } |
| 76 | 223 if (st -> as -> outformat != OUTPUT_OBJ || se -> sect == NULL || se -> sect == st -> as -> csect) |
| 224 { | |
| 225 // global symbol, intrasegment reference, or not an object target | |
| 226 val = se -> value; | |
| 227 goto retconst; | |
| 228 } | |
| 229 // an intersegment reference will return as NULL (to be resolved at output/link time) | |
| 230 // if se -> expr is NULL, it has to be an intersegment reference here | |
| 231 if (se -> expr == NULL) | |
| 232 { | |
| 233 return NULL; | |
| 234 } | |
| 235 | |
| 236 // duplicate the expression for return | |
| 237 rs = lwasm_expr_stack_create(); | |
| 238 for (n = se -> expr -> head; n; n = n -> next) | |
| 239 { | |
| 240 lwasm_expr_stack_push(rs, n -> term); | |
| 241 } | |
| 242 return rs; | |
| 243 | |
| 244 retconst: | |
| 245 rs = lwasm_expr_stack_create(); | |
| 246 t = lwasm_expr_term_create_int(val); | |
| 247 lwasm_expr_stack_push(rs, t); | |
| 248 lwasm_expr_term_free(t); | |
| 249 return rs; | |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
250 } |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
251 |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
252 lwasm_expr_stack_t *lwasm_evaluate_expr(asmstate_t *as, lwasm_line_t *l, const char *inp, const char **outp) |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
253 { |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
254 struct symstateinfo st; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
255 |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
256 st.as = as; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
257 st.l = l; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
258 |
| 38 | 259 debug_message(2, "Evaluate expression: %s", inp); |
| 260 | |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
261 return(lwasm_expr_eval(inp, outp, lwasm_expr_lookup_symbol, &st)); |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
262 } |
| 38 | 263 |
| 77 | 264 |
| 265 int lwasm_reevaluate_expr(asmstate_t *as, lwasm_line_t *l, lwasm_expr_stack_t *s) | |
| 266 { | |
| 267 struct symstateinfo st; | |
| 268 | |
| 269 st.as = as; | |
| 270 st.l = l; | |
| 271 | |
| 272 return(lwasm_expr_reval(s, lwasm_expr_lookup_symbol, &st)); | |
| 273 } | |
| 274 | |
| 76 | 275 // return 1 if no undefined symbols (externals and incompletes are okay) |
| 276 // return 0 if there are undefined symbols | |
| 277 int lwasm_expr_result_ckconst(asmstate_t *as, lwasm_expr_stack_t *s) | |
| 278 { | |
| 279 lwasm_expr_stack_node_t *n; | |
| 280 lwasm_symbol_ent_t *se; | |
| 281 | |
| 77 | 282 if (as -> outformat != OUTPUT_OBJ) |
| 283 { | |
| 284 if (lwasm_expr_is_constant(s)) | |
| 285 return 1; | |
| 286 else | |
| 287 return 0; | |
| 288 } | |
| 289 | |
| 76 | 290 for (n = s -> head; n; n = n -> next) |
| 291 { | |
| 292 if (n -> term -> term_type == LWASM_TERM_SYM) | |
| 293 { | |
| 294 se = lwasm_find_symbol(as, n -> term -> symbol, as -> context); | |
| 295 if (!se) | |
| 296 se = lwasm_find_symbol(as, n -> term -> symbol, -1); | |
| 297 if (!se) | |
| 298 return 0; | |
| 299 } | |
| 300 } | |
| 301 return 1; | |
| 302 } | |
| 303 | |
| 304 /* | |
| 305 Evaluate an expression according to the flag value. Return 0 if a constant result was | |
| 306 obtained, 1 if an incomplete result was obtained, and -1 if an error was flagged. | |
| 307 | |
| 308 Symbol resolution will be modified for the object target as follows: | |
| 309 - a symbol which is not defined within a section will evaluate as a constant | |
| 310 - a symbol which is defined within the same section will evaluate as a constant | |
| 311 - a symbol defined in another section will remain unresolved | |
| 312 - external references will also remain unresolved | |
| 313 | |
| 77 | 314 EXPR_PASS2PASS will cause the result from pass 1 along with the offset to |
| 315 the end of the expression to be stored in the line data. There can only be | |
| 316 one such expression per source line. In this case, the expression is parsed | |
| 317 and evaluated on pass 1 but the intermediate representation is re-evaluated | |
| 318 on pass 2. | |
| 76 | 319 */ |
| 77 | 320 /* |
| 55 | 321 int lwasm_expr_result(asmstate_t *as, lwasm_line_t *l, char **inp, int flag, int *val) |
| 322 { | |
| 323 lwasm_expr_stack_t *s; | |
| 58 | 324 const char *ep; |
| 55 | 325 int rval; |
| 326 | |
| 327 s = lwasm_evaluate_expr(as, l, *inp, &ep); | |
| 328 if (!s) | |
| 329 { | |
| 330 register_error(as, l, 1, "Bad expression"); | |
| 331 *val = 0; | |
| 332 return -1; | |
| 333 } | |
| 58 | 334 *inp = (char *)ep; |
| 55 | 335 |
| 77 | 336 if (flag & EXPR_PASS1CONST && as -> passnum == 1 && !lwasm_expr_result_ckconst(as, s)) |
| 55 | 337 { |
| 77 | 338 register_error(as, l, 1, "Undefined reference (pass 1)"); |
| 339 *val = 0; | |
| 340 lwasm_expr_stack_free(s); | |
| 341 return -1; | |
| 342 } | |
| 343 if (flag & EXPR_PASS2CONST && as -> passnum == 2 && !lwasm_expr_result_ckconst(as, s)) | |
| 344 { | |
| 345 register_error(as, l, 2, "Undefined reference (pass 2)"); | |
| 55 | 346 *val = 0; |
| 347 lwasm_expr_stack_free(s); | |
| 348 return -1; | |
| 349 } | |
| 77 | 350 if (flag & EXPR_NOINTERSECT && !lwasm_expr_is_constant(s)) |
| 55 | 351 { |
| 77 | 352 register_error(as, l, 2, "Invalid inter-section reference"); |
| 55 | 353 } |
| 354 *val = lwasm_expr_get_value(s); | |
| 77 | 355 if (l -> expr) |
| 356 { | |
| 357 lwasm_expr_stack_free(l -> expr); | |
| 358 l -> expr = NULL; | |
| 359 } | |
| 360 if (lwasm_is_constant(s)) | |
| 361 { | |
| 362 // fully resolved value here | |
| 363 lwasm_expr_stack_free(s); | |
| 364 } | |
| 365 else | |
| 366 { | |
| 367 // incomplete reference here | |
| 368 l -> expr = s; | |
| 369 } | |
| 55 | 370 |
| 371 if (flag & EXPR_BYTE && as -> passnum == 2 && (*val < -128 || *val > 255)) | |
| 372 { | |
| 373 register_error(as, l, 2, "Byte overflow"); | |
| 374 *val &= 0xff; | |
| 375 return -1; | |
| 376 } | |
| 377 if (flag & EXPR_BYTE) | |
| 378 { | |
| 379 *val &= 0xff; | |
| 380 } | |
| 381 | |
| 382 return 0; | |
| 383 } | |
| 77 | 384 */ |
| 385 int lwasm_expr_result2(asmstate_t *as, lwasm_line_t *l, char **inp, int flag, int *val, int slot) | |
| 386 { | |
|
79
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
387 lwasm_expr_stack_t *s = NULL; |
| 77 | 388 const char *ep; |
| 389 int rval; | |
| 390 | |
|
79
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
391 if (as -> passnum == 1 || slot < 0) |
| 77 | 392 { |
| 393 s = lwasm_evaluate_expr(as, l, *inp, &ep); | |
|
79
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
394 if (slot >= 0) |
|
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
395 l -> exprs[slot] = s; |
| 77 | 396 if (!s) |
| 397 { | |
| 398 register_error(as, l, 1, "Bad expression"); | |
| 399 *val = 0; | |
| 400 return -1; | |
| 401 } | |
| 402 *inp = (char *)ep; | |
|
79
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
403 if (slot >= 0) |
|
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
404 { |
|
84
e12edcfbebd5
Fixed problem with expression evaluation infrastructure not advancing input pointer on pass 2
lost
parents:
79
diff
changeset
|
405 l -> exprends[slot] = ep; |
|
79
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
406 l -> exprvals[slot] = lwasm_expr_get_value(s); |
|
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
407 } |
| 77 | 408 } |
| 409 else if (l -> exprs[slot]) | |
| 410 { | |
| 411 s = l -> exprs[slot]; | |
| 412 lwasm_reevaluate_expr(as, l, s); | |
| 413 l -> exprvals[slot] = lwasm_expr_get_value(s); | |
| 414 } | |
|
84
e12edcfbebd5
Fixed problem with expression evaluation infrastructure not advancing input pointer on pass 2
lost
parents:
79
diff
changeset
|
415 if (as -> passnum == 2 && slot >= 0) |
|
e12edcfbebd5
Fixed problem with expression evaluation infrastructure not advancing input pointer on pass 2
lost
parents:
79
diff
changeset
|
416 *inp = l -> exprends[slot]; |
| 77 | 417 |
| 418 if (s && lwasm_expr_is_constant(s)) | |
| 419 { | |
| 420 lwasm_expr_stack_free(s); | |
| 421 l -> exprs[slot] = NULL; | |
| 422 s = NULL; | |
| 423 } | |
| 424 | |
|
79
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
425 if (!s && slot >= 0) |
| 77 | 426 { |
| 427 *val = l -> exprvals[slot]; | |
| 428 return 0; | |
| 429 } | |
|
79
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
430 else if (!s) |
|
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
431 { |
|
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
432 *val = 0; |
|
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
433 return 0; |
|
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
434 } |
|
78
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
435 |
|
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
436 // was a constant result on pass 1 requested? |
|
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
437 // that means we must have a constant on either pass |
|
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
438 if (flag & EXPR_PASS1CONST) |
|
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
439 { |
|
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
440 *val = 0; |
|
79
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
441 if (slot >= 0) |
|
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
442 l -> exprvals[slot] = 0; |
|
78
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
443 register_error(as, l, 1, "Illegal forward, external, or inter-section reference"); |
|
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
444 lwasm_expr_stack_free(s); |
|
79
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
445 if (slot >= 0) |
|
d0ce3f5f6797
Checkpointing deployment of non-constant expression handling
lost
parents:
78
diff
changeset
|
446 l -> exprs[slot] = NULL; |
|
78
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
447 return -1; |
|
121bf4a588ea
Checkpointing deployment of non-constant expression handling
lost
parents:
77
diff
changeset
|
448 } |
| 77 | 449 |
| 450 return 1; | |
| 451 } | |
| 55 | 452 |
| 38 | 453 void debug_message(int level, const char *fmt, ...) |
| 454 { | |
| 455 va_list args; | |
| 456 | |
| 457 va_start(args, fmt); | |
| 458 if (debug_level >= level) | |
| 459 { | |
| 39 | 460 if (level > 0) |
| 461 fprintf(stderr, "DEBUG %d: ", level); | |
| 38 | 462 vfprintf(stderr, fmt, args); |
| 463 fputc('\n', stderr); | |
| 464 } | |
| 465 va_end(args); | |
| 466 } | |
| 57 | 467 |
| 468 int lwasm_next_context(asmstate_t *as) | |
| 469 { | |
| 58 | 470 int r; |
| 471 r = as -> nextcontext; | |
| 472 as -> nextcontext += 1; | |
| 473 debug_message(3, "lwasm_next_context(): %d (%d) pass %d", r, as -> nextcontext, as -> passnum); | |
| 474 return r; | |
| 57 | 475 } |
| 476 |