Mercurial > hg-old > index.cgi
annotate lwasm/parse.c @ 262:6d09310438a4 2.x
Fixed problem with local symbol context handling in the face of conditional assembly
author | lost |
---|---|
date | Thu, 07 Jan 2010 03:57:58 +0000 |
parents | 6363b9ebf825 |
children |
rev | line source |
---|---|
36 | 1 /* |
2 parse.c | |
3 Copyright © 2008 William Astle | |
4 | |
5 This file is part of LWASM. | |
6 | |
7 LWASM is free software: you can redistribute it and/or modify it under the | |
8 terms of the GNU General Public License as published by the Free Software | |
9 Foundation, either version 3 of the License, or (at your option) any later | |
10 version. | |
11 | |
12 This program is distributed in the hope that it will be useful, but WITHOUT | |
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
15 more details. | |
16 | |
17 You should have received a copy of the GNU General Public License along with | |
18 this program. If not, see <http://www.gnu.org/licenses/>. | |
19 */ | |
20 | |
21 /* | |
22 Contains the general parser | |
23 */ | |
24 | |
25 #define __parse_c_seen__ | |
212 | 26 #include <config.h> |
36 | 27 |
28 #include <ctype.h> | |
29 #include <string.h> | |
30 | |
31 #include "lwasm.h" | |
32 #include "instab.h" | |
33 #include "util.h" | |
34 | |
35 // parse a line and despatch to the appropriate handlers for opcodes | |
36 int lwasm_parse_line(asmstate_t *as, lwasm_line_t *l) | |
37 { | |
38 char *p, *p2; | |
39 char *opc; | |
40 int opnum; | |
44 | 41 char *sym = NULL; |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
42 |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
43 // if this was a bad op first pass (or otherwise a no-process line) |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
44 // ignore it |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
45 if (l -> badop) |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
46 return; |
36 | 47 |
48 p = l -> text; | |
101
f59c0916753d
Fixed relative branches and PCR addressing to handle constant intra-section references properly
lost
parents:
99
diff
changeset
|
49 l -> sect = as -> csect; |
236
a58f49a77441
Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents:
230
diff
changeset
|
50 l -> inmod = as -> inmod; |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
51 |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
52 // blank lines are a no brainer |
262
6d09310438a4
Fixed problem with local symbol context handling in the face of conditional assembly
lost
parents:
255
diff
changeset
|
53 if (as -> passnum == 2) |
6d09310438a4
Fixed problem with local symbol context handling in the face of conditional assembly
lost
parents:
255
diff
changeset
|
54 as -> context = l -> context; |
6d09310438a4
Fixed problem with local symbol context handling in the face of conditional assembly
lost
parents:
255
diff
changeset
|
55 else if (!*p) |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
56 { |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
57 as -> context = lwasm_next_context(as); |
36 | 58 return 0; |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
59 } |
36 | 60 |
52 | 61 // for output generation later but only on pass 1 |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
62 // also used by some pseudo ops on pass 2 |
52 | 63 if (as -> passnum == 1) |
64 l -> codeaddr = as -> addr; | |
255 | 65 |
66 // check if there is a line number and ignore it if there is | |
67 if (isdigit(*p)) | |
68 { | |
69 for (p2 = p; *p2 && isdigit(*p2); p2++) | |
70 /* do nothing */ ; | |
71 | |
72 // we have a line number, skip it and the *first* | |
73 // whitespace character | |
74 if (!*p2 || isspace(*p2)) | |
75 p = p2 + 1; | |
76 } | |
44 | 77 |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
78 // if it's a comment, return (this doesn't cause a context change) |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
79 if (*p == '*' || *p == ';') |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
80 return; |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
81 |
169 | 82 // if we have C pre-processor directives/output, ignore it |
83 if (*p == '#') | |
84 return; | |
85 | |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
86 // if we start with a non-space character, it's a symbol |
244
c8bcc396ec59
Allow symbols to appear after whitespace when terminated by :
lost
parents:
236
diff
changeset
|
87 symbolagain: |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
88 if (!isspace(*p)) |
36 | 89 { |
253 | 90 // if it starts with a comment character, it's not a symbol |
91 if (*p == ';' || *p == '*') | |
92 return; | |
93 | |
36 | 94 // we have a symbol specified here |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
95 // parse it out and record it for later use |
157 | 96 for (p2 = p; *p2 && !isspace(*p2) && *p2 != ':'; p2++) |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
97 /* do nothing */ ; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
98 |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
99 sym = lwasm_alloc((p2 - p) + 1); |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
100 sym[p2 - p] = '\0'; |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
101 memcpy(sym, p, p2 - p); |
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
102 |
44 | 103 p = p2; |
157 | 104 if (!*sym) |
105 { | |
106 register_error(as, l, 1, "Invalid symbol"); | |
107 lwasm_free(sym); | |
108 sym = NULL; | |
109 } | |
110 if (*p == ':') | |
111 p++; | |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
112 } |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
113 l -> sym = sym; |
36 | 114 |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
115 // now skip any whitespace to find the opcode |
36 | 116 while (*p && isspace(*p)) |
117 p++; | |
118 | |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
119 // is the line blank? |
262
6d09310438a4
Fixed problem with local symbol context handling in the face of conditional assembly
lost
parents:
255
diff
changeset
|
120 if (!*p && !sym && as -> passnum == 1) |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
121 { |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
122 // nothing but white space *is* a context break |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
123 as -> context = lwasm_next_context(as); |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
124 return; |
37
538e15927776
Added symbol handling to expression subsystem; adpated instruction handlers to the new scheme; misc fixes
lost
parents:
36
diff
changeset
|
125 } |
36 | 126 |
127 // parse the opcode | |
128 for (p2 = p; *p2 && !isspace(*p2); p2++) | |
129 /* do nothing */ ; | |
130 | |
131 opc = lwasm_alloc((p2 - p) + 1); | |
132 memcpy(opc, p, p2 - p); | |
133 opc[p2 - p] = '\0'; | |
134 | |
244
c8bcc396ec59
Allow symbols to appear after whitespace when terminated by :
lost
parents:
236
diff
changeset
|
135 if (strchr(opc, ':')) |
c8bcc396ec59
Allow symbols to appear after whitespace when terminated by :
lost
parents:
236
diff
changeset
|
136 { |
c8bcc396ec59
Allow symbols to appear after whitespace when terminated by :
lost
parents:
236
diff
changeset
|
137 lwasm_free(opc); |
c8bcc396ec59
Allow symbols to appear after whitespace when terminated by :
lost
parents:
236
diff
changeset
|
138 goto symbolagain; |
c8bcc396ec59
Allow symbols to appear after whitespace when terminated by :
lost
parents:
236
diff
changeset
|
139 } |
c8bcc396ec59
Allow symbols to appear after whitespace when terminated by :
lost
parents:
236
diff
changeset
|
140 |
190 | 141 l -> forceglobal = 0; |
142 // if the opcode contains an =, treat it as "symbol = expr" | |
143 if (!sym && strchr(opc, '=')) | |
144 { | |
145 for (p2 = opc; *p2 && *p2 != '='; p2++) | |
146 /* do nothing */ ; | |
147 sym = lwasm_alloc((p2 - opc) + 1); | |
148 memcpy(sym, opc, p2 - opc); | |
149 sym[p2 - opc] = '\0'; | |
150 l -> sym = sym; | |
151 | |
152 p2 = p + (p2 - opc) + 1; | |
153 // p2++; | |
154 opc[0] = '='; | |
155 opc[1] = '\0'; | |
156 debug_message(2, "Found opcode = with symbol %s and operand %s", sym, p2); | |
157 l -> forceglobal = 1; | |
158 } | |
159 | |
38 | 160 debug_message(2, "Found operation code: '%s'", opc); |
161 | |
36 | 162 // skip intervening whitespace if present |
163 while (*p2 && isspace(*p2)) | |
164 p2++; | |
165 | |
166 // look up instruction in insn table | |
167 for (opnum = 0; instab[opnum].opcode; opnum++) | |
168 { | |
169 if (!strcasecmp(instab[opnum].opcode, opc)) | |
170 break; | |
171 } | |
172 | |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
173 // if we found no operation, check if we had a comment |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
174 // the reason this check is here is to allow for "private" |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
175 // operation codes like "*pragma" which will be ignored by |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
176 // other assemblers |
68 | 177 // also skip empty ops |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
178 if (!(instab[opnum].opcode)) |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
179 { |
68 | 180 if (*opc == '*' || *opc == ';' || !*opc) |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
181 goto done_line; |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
182 } |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
183 |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
184 // now we have the opcode and the symbol, we can decide if we're |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
185 // actually going to do anything with this line |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
186 |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
187 // we will NOT call the function if any of the following are true: |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
188 |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
189 // - we are skipping a condition and the operation code is not a conditional |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
190 // - we are defining a macro and the operation code is not ENDM |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
191 |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
192 // we will call the function in any other circumstance |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
193 |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
194 // first condition above |
57 | 195 if (as -> inmacro && instab[opnum].endm == 0) |
196 { | |
197 add_macro_line(as, l -> text); | |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
198 goto done_line; |
57 | 199 } |
200 | |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
201 // second condition above |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
202 if (as -> skipcond && instab[opnum].iscond == 0) |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
203 goto done_line; |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
204 |
254 | 205 if (as -> instruct && as -> passnum == 1) |
206 { | |
207 structtab_t *s = NULL; | |
208 struct struct_sym_e *e, *e2; | |
209 | |
210 // look for a structure if not an acceptable opcode | |
211 if (!instab[opnum].opcode) | |
212 { | |
213 for (s = as -> structs; s; s = s -> next) | |
214 { | |
215 if (s == as -> cstruct) | |
216 continue; | |
217 if (!strcmp(opc, s -> name)) | |
218 goto isok; | |
219 } | |
220 } | |
221 // check for a "reservation opcode" | |
222 if (instab[opnum].opcode && instab[opnum].isreserve) | |
223 { | |
224 (instab[opnum].fn)(as, l, &p2, opnum); | |
225 | |
226 // if we didn't end on a "space" character or EOL, throw error | |
227 if (p2 && *p2 && !isspace(*p2) && !(l -> err) && as -> passnum == 1) | |
228 register_error(as, l, 1, "Bad operand: %s (%d)", p2, as -> passnum); | |
229 | |
230 if (as -> instruct == 0) | |
231 goto done_line; | |
232 | |
233 goto isok; | |
234 } | |
235 // carp if not valid | |
236 register_error(as, l, 1, "Only other structs and rmb allowed in struct"); | |
237 l -> badop = 1; | |
238 goto done_line; | |
239 | |
240 isok: | |
241 for (e2 = as -> cstruct -> fields; e2 && e2 -> next; e2 = e2 -> next) | |
242 /* do nothing */ ; | |
243 e = lwasm_alloc(sizeof(struct struct_sym_e)); | |
244 e -> next = NULL; | |
245 e -> substruct = s; | |
246 if (sym) | |
247 e -> name = lwasm_strdup(sym); | |
248 else | |
249 e -> name = NULL; | |
250 if (s) | |
251 e -> size = s -> size; | |
252 else | |
253 e -> size = l -> nocodelen; | |
254 if (e2) | |
255 e2 -> next = e; | |
256 else | |
257 as -> cstruct -> fields = e; | |
258 as -> cstruct -> size += e -> size; | |
259 } | |
260 | |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
261 // we've registered the symbol as needed |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
262 // now we need to check for a macro call IFF we don't collide with |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
263 // an operation code; otherwise, call the operation function |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
264 if (instab[opnum].opcode) |
36 | 265 { |
230
0df2a39a268c
Added --6809/--6309 switches and some cleanups in error reporting
lost
parents:
223
diff
changeset
|
266 if (instab[opnum].fn && !(as -> no6309 && instab[opnum].is6309)) |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
267 { |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
268 (instab[opnum].fn)(as, l, &p2, opnum); |
223
436b36214e35
Fixed lack of error when there are extraneous characters at the end of the operand.
lost
parents:
212
diff
changeset
|
269 |
436b36214e35
Fixed lack of error when there are extraneous characters at the end of the operand.
lost
parents:
212
diff
changeset
|
270 // if we didn't end on a "space" character or EOL, throw error |
250
0986834ec7d3
Added no-op .bank pseudo-op to support compiling gcc6809
lost
parents:
244
diff
changeset
|
271 if (p2 && *p2 && !isspace(*p2) && !(l -> err) && as -> passnum == 1) |
236
a58f49a77441
Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents:
230
diff
changeset
|
272 register_error(as, l, 1, "Bad operand: %s (%d)", p2, as -> passnum); |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
273 } |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
274 else |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
275 { |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
276 // carp about unimplemented operation |
230
0df2a39a268c
Added --6809/--6309 switches and some cleanups in error reporting
lost
parents:
223
diff
changeset
|
277 if (instab[opnum].is6309) |
0df2a39a268c
Added --6809/--6309 switches and some cleanups in error reporting
lost
parents:
223
diff
changeset
|
278 register_error(as, l, 1, "Use of 6309 operation code: %s", opc); |
0df2a39a268c
Added --6809/--6309 switches and some cleanups in error reporting
lost
parents:
223
diff
changeset
|
279 else |
0df2a39a268c
Added --6809/--6309 switches and some cleanups in error reporting
lost
parents:
223
diff
changeset
|
280 register_error(as, l, 1, "Unimplemented operation code: %s", opc); |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
281 } |
36 | 282 } |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
283 else |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
284 { |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
285 if (expand_macro(as, l, &p2, opc) == 0) |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
286 goto done_line; |
36 | 287 |
254 | 288 if (expand_struct(as, l, &p2, opc) == 0) |
289 goto done_line; | |
290 | |
66
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
291 // carp about an unknown operation code and note that fact for |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
292 // pass 2 in case a macro appears later with the same name! |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
293 register_error(as, l, 1, "Uknown operation code: %s", opc); |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
294 l -> badop = 1; |
aa9d9fedfdf4
Redid lwasm_parse_line() to correct overly complex logic flaws
lost
parents:
64
diff
changeset
|
295 } |
57 | 296 |
297 done_line: | |
68 | 298 if (!(as -> skipcond || as -> inmacro)) |
299 { | |
300 // register symbol if the operation didn't | |
254 | 301 if (sym && instab[opnum].setsym == 0 && as -> instruct == 0) |
68 | 302 { |
303 if (as -> passnum == 1) | |
304 { | |
71
90a5657d5408
Fixed problem with symbols being registered with the address of the NEXT instruction
lost
parents:
68
diff
changeset
|
305 debug_message(1, "Registering symbol '%s' at %04X", sym, l -> codeaddr); |
90a5657d5408
Fixed problem with symbols being registered with the address of the NEXT instruction
lost
parents:
68
diff
changeset
|
306 if (lwasm_register_symbol(as, l, sym, l -> codeaddr, SYMBOL_NORM) < 0) |
68 | 307 l -> sym = NULL; |
308 else | |
309 l -> addrset = 1; | |
310 } | |
311 } | |
312 } | |
99 | 313 |
85 | 314 l -> sect = as -> csect; |
91
718998b673ee
Added incomplete references to object output and added support for section base terms in expression handler
lost
parents:
85
diff
changeset
|
315 l -> context = as -> context; |
85 | 316 |
36 | 317 lwasm_free(opc); |
44 | 318 if (sym) |
319 lwasm_free(sym); | |
36 | 320 } |