Mercurial > hg-old > index.cgi
annotate src/lwasm.c @ 76:2fe5fd7d65a3
Checkpointing object target implementation
| author | lost |
|---|---|
| date | Thu, 08 Jan 2009 02:57:24 +0000 |
| parents | c8c772ef5df9 |
| children | a338d496350e |
| 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) |
| 76 | 219 return NULL; |
| 220 if (st -> as -> outformat != OUTPUT_OBJ || se -> sect == NULL || se -> sect == st -> as -> csect) | |
| 221 { | |
| 222 // global symbol, intrasegment reference, or not an object target | |
| 223 val = se -> value; | |
| 224 goto retconst; | |
| 225 } | |
| 226 // an intersegment reference will return as NULL (to be resolved at output/link time) | |
| 227 // if se -> expr is NULL, it has to be an intersegment reference here | |
| 228 if (se -> expr == NULL) | |
| 229 { | |
| 230 return NULL; | |
| 231 } | |
| 232 | |
| 233 // duplicate the expression for return | |
| 234 rs = lwasm_expr_stack_create(); | |
| 235 for (n = se -> expr -> head; n; n = n -> next) | |
| 236 { | |
| 237 lwasm_expr_stack_push(rs, n -> term); | |
| 238 } | |
| 239 return rs; | |
| 240 | |
| 241 retconst: | |
| 242 rs = lwasm_expr_stack_create(); | |
| 243 t = lwasm_expr_term_create_int(val); | |
| 244 lwasm_expr_stack_push(rs, t); | |
| 245 lwasm_expr_term_free(t); | |
| 246 return rs; | |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
247 } |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
248 |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
249 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
|
250 { |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
251 struct symstateinfo st; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
252 |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
253 st.as = as; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
254 st.l = l; |
|
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
255 |
| 38 | 256 debug_message(2, "Evaluate expression: %s", inp); |
| 257 | |
|
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
32
diff
changeset
|
258 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
|
259 } |
| 38 | 260 |
| 76 | 261 // return 1 if no undefined symbols (externals and incompletes are okay) |
| 262 // return 0 if there are undefined symbols | |
| 263 int lwasm_expr_result_ckconst(asmstate_t *as, lwasm_expr_stack_t *s) | |
| 264 { | |
| 265 lwasm_expr_stack_node_t *n; | |
| 266 lwasm_symbol_ent_t *se; | |
| 267 | |
| 268 for (n = s -> head; n; n = n -> next) | |
| 269 { | |
| 270 if (n -> term -> term_type == LWASM_TERM_SYM) | |
| 271 { | |
| 272 se = lwasm_find_symbol(as, n -> term -> symbol, as -> context); | |
| 273 if (!se) | |
| 274 se = lwasm_find_symbol(as, n -> term -> symbol, -1); | |
| 275 if (!se) | |
| 276 return 0; | |
| 277 } | |
| 278 } | |
| 279 return 1; | |
| 280 } | |
| 281 | |
| 282 /* | |
| 283 Evaluate an expression according to the flag value. Return 0 if a constant result was | |
| 284 obtained, 1 if an incomplete result was obtained, and -1 if an error was flagged. | |
| 285 | |
| 286 Symbol resolution will be modified for the object target as follows: | |
| 287 - a symbol which is not defined within a section will evaluate as a constant | |
| 288 - a symbol which is defined within the same section will evaluate as a constant | |
| 289 - a symbol defined in another section will remain unresolved | |
| 290 - external references will also remain unresolved | |
| 291 | |
| 292 */ | |
| 55 | 293 int lwasm_expr_result(asmstate_t *as, lwasm_line_t *l, char **inp, int flag, int *val) |
| 294 { | |
| 295 lwasm_expr_stack_t *s; | |
| 58 | 296 const char *ep; |
| 55 | 297 int rval; |
| 298 | |
| 299 s = lwasm_evaluate_expr(as, l, *inp, &ep); | |
| 300 if (!s) | |
| 301 { | |
| 302 register_error(as, l, 1, "Bad expression"); | |
| 303 *val = 0; | |
| 304 return -1; | |
| 305 } | |
| 58 | 306 *inp = (char *)ep; |
| 55 | 307 |
| 308 if (flag & EXPR_PASS1CONST && as -> passnum == 1 && !lwasm_expr_is_constant(s)) | |
| 309 { | |
| 310 register_error(as, l, 1, "Illegal incomplete reference (pass 1)"); | |
| 311 *val = 0; | |
| 312 lwasm_expr_stack_free(s); | |
| 313 return -1; | |
| 314 } | |
| 315 if (flag & EXPR_PASS2CONST && as -> passnum == 2 && !lwasm_expr_is_constant(s)) | |
| 316 { | |
| 317 register_error(as, l, 2, "Incomplete reference (pass 2)"); | |
| 318 *val = 0; | |
| 319 lwasm_expr_stack_free(s); | |
| 320 return -1; | |
| 321 } | |
| 322 *val = lwasm_expr_get_value(s); | |
| 323 lwasm_expr_stack_free(s); | |
| 324 | |
| 325 if (flag & EXPR_BYTE && as -> passnum == 2 && (*val < -128 || *val > 255)) | |
| 326 { | |
| 327 register_error(as, l, 2, "Byte overflow"); | |
| 328 *val &= 0xff; | |
| 329 return -1; | |
| 330 } | |
| 331 if (flag & EXPR_BYTE) | |
| 332 { | |
| 333 *val &= 0xff; | |
| 334 } | |
| 335 | |
| 336 return 0; | |
| 337 } | |
| 338 | |
| 38 | 339 void debug_message(int level, const char *fmt, ...) |
| 340 { | |
| 341 va_list args; | |
| 342 | |
| 343 va_start(args, fmt); | |
| 344 if (debug_level >= level) | |
| 345 { | |
| 39 | 346 if (level > 0) |
| 347 fprintf(stderr, "DEBUG %d: ", level); | |
| 38 | 348 vfprintf(stderr, fmt, args); |
| 349 fputc('\n', stderr); | |
| 350 } | |
| 351 va_end(args); | |
| 352 } | |
| 57 | 353 |
| 354 int lwasm_next_context(asmstate_t *as) | |
| 355 { | |
| 58 | 356 int r; |
| 357 r = as -> nextcontext; | |
| 358 as -> nextcontext += 1; | |
| 359 debug_message(3, "lwasm_next_context(): %d (%d) pass %d", r, as -> nextcontext, as -> passnum); | |
| 360 return r; | |
| 57 | 361 } |
| 362 |