annotate lwasm/pseudo.c @ 243:f9f01a499525 2.x

Added zero-width external references
author lost
date Tue, 15 Sep 2009 03:16:17 +0000
parents 31231d1c87e6
children c7a41b4c89b3
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1 /*
4
34568fab6058 Fixed package to include all required files; also added copyright preamble to all source files
lost
parents: 0
diff changeset
2 pseudo.c
47
804d7465e0f9 Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents: 4
diff changeset
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
34568fab6058 Fixed package to include all required files; also added copyright preamble to all source files
lost
parents: 0
diff changeset
20
34568fab6058 Fixed package to include all required files; also added copyright preamble to all source files
lost
parents: 0
diff changeset
21 This file implements the various pseudo operations.
34568fab6058 Fixed package to include all required files; also added copyright preamble to all source files
lost
parents: 0
diff changeset
22 */
212
bae1e3ecdce1 More preparation for gnulib integration
lost
parents: 202
diff changeset
23 #include <config.h>
225
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
24 #include <errno.h>
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
25 #include <stdio.h>
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
26 #include <stdlib.h>
50
e672232caffe Added rmb pseudo op
lost
parents: 49
diff changeset
27 #include <string.h>
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
28 #include "lwasm.h"
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
29 #include "instab.h"
47
804d7465e0f9 Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents: 4
diff changeset
30 #include "expr.h"
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
31 #include "util.h"
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
32
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
33 extern int lwasm_read_file(asmstate_t *as, const char *filename);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
34
158
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
35 OPFUNC(pseudo_noop)
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
36 {
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
37 skip_operand(p);
158
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
38 }
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
39
47
804d7465e0f9 Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents: 4
diff changeset
40 OPFUNC(pseudo_org)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
41 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
42 int v, r;
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
43
74
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
44 if (as -> csect)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
45 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
46 register_error(as, l, 1, "ORG not allowed within sections");
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
47 return;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
48 }
241
31231d1c87e6 Made ORG carp if used inside a mod/emod section
lost
parents: 236
diff changeset
49 if (as -> inmod)
31231d1c87e6 Made ORG carp if used inside a mod/emod section
lost
parents: 236
diff changeset
50 {
31231d1c87e6 Made ORG carp if used inside a mod/emod section
lost
parents: 236
diff changeset
51 register_error(as, l, 1, "ORG not allowed within modules");
31231d1c87e6 Made ORG carp if used inside a mod/emod section
lost
parents: 236
diff changeset
52 return;
31231d1c87e6 Made ORG carp if used inside a mod/emod section
lost
parents: 236
diff changeset
53 }
74
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
54
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
55 if (as -> passnum != 1)
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
56 {
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
57 // org is not needed to be processed on pass 2
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
58 // this will prevent phasing errors for forward references that
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
59 // resolve on the second pass
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
60 // we saved the org address in l -> codeaddr on pass 1
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
61 as -> addr = l -> codeaddr;
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
62 skip_operand(p);
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
63 return;
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
64 }
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
65
47
804d7465e0f9 Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents: 4
diff changeset
66 if (l -> sym)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
67 {
47
804d7465e0f9 Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents: 4
diff changeset
68 register_error(as, l, 1, "No symbol allowed with ORG");
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
69 }
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
70
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
71 r = lwasm_expr_result2(as, l, p, EXPR_PASS1CONST, &v, 0);
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
72 if (r != 0)
47
804d7465e0f9 Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents: 4
diff changeset
73 return;
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
74 l -> codeaddr = v;
49
21ae0fab469b Added needed infra for useful listing of EQU and ORG type statements
lost
parents: 47
diff changeset
75 l -> addrset = 1;
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
76 as -> addr = v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
77 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
78
47
804d7465e0f9 Implemented ORG and fixed problems with constants using $, &, or @ to specify base
lost
parents: 4
diff changeset
79 /*
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
80 The operand for include is a string optionally enclosed in "
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
81 */
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
82 OPFUNC(pseudo_include)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
83 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
84 int v1;
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
85 char *fn;
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
86
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
87 // only include files on pass 1
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
88 // but make sure local include context is right
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
89 // for the next line...
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
90 if (as -> passnum != 1)
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
91 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
92 as -> context = lwasm_next_context(as);
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
93 skip_operand(p);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
94 return;
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
95 }
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
96
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
97 while (**p && isspace(**p))
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
98 (*p)++;
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
99
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
100 if (!**p)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
101 {
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
102 register_error(as, l, 1, "Bad file name");
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
103 return;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
104 }
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
105
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
106 if (**p == '"')
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
107 {
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
108 // search for ending "
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
109 (*p)++;
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
110 for (v1 = 0; *((*p)+v1) && *((*p)+v1) != '"'; v1++)
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
111 /* do nothing */ ;
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
112 if (*((*p)+v1) != '"')
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
113 {
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
114 register_error(as, l, 1, "Bad file name");
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
115 return;
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
116 }
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
117 }
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
118 else
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
119 {
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
120 // search for a space type character
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
121 for (v1 = 0; *((*p)+v1) && !isspace(*((*p)+v1)); v1++)
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
122 ;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
123 }
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
124
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
125 fn = lwasm_alloc(v1 + 1);
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
126 memcpy(fn, *p, v1);
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
127 fn[v1] = '\0';
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
128
225
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
129 (*p) += v1;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
130 if (**p == '"')
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
131 (*p)++;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
132
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
133 // end local label context on include
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
134 as -> context = lwasm_next_context(as);
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
135 if (lwasm_read_file(as, fn) < 0)
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
136 {
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
137 register_error(as, l, 1, "File include error (%s)", fn);
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
138 }
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
139 lwasm_free(fn);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
140 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
141
225
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
142 /*
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
143 The operand for includebin is a string optionally enclosed in "
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
144 */
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
145 OPFUNC(pseudo_includebin)
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
146 {
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
147 int v1;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
148 char *fn;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
149 FILE *f;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
150
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
151 // only include files on pass 1
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
152 while (**p && isspace(**p))
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
153 (*p)++;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
154
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
155 if (!**p)
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
156 {
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
157 register_error(as, l, 1, "Bad file name");
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
158 return;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
159 }
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
160
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
161 if (**p == '"')
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
162 {
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
163 // search for ending "
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
164 (*p)++;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
165 for (v1 = 0; *((*p)+v1) && *((*p)+v1) != '"'; v1++)
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
166 /* do nothing */ ;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
167 if (*((*p)+v1) != '"')
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
168 {
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
169 register_error(as, l, 1, "Bad file name");
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
170 return;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
171 }
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
172 }
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
173 else
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
174 {
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
175 // search for a space type character
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
176 for (v1 = 0; *((*p)+v1) && !isspace(*((*p)+v1)); v1++)
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
177 ;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
178 }
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
179
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
180 fn = lwasm_alloc(v1 + 1);
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
181 memcpy(fn, *p, v1);
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
182 fn[v1] = '\0';
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
183
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
184 (*p) += v1;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
185 if (**p == '"')
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
186 (*p)++;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
187
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
188 // open the file
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
189 f = fopen(fn, "rb");
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
190 if (!f)
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
191 {
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
192 register_error(as, l, 1, "Cannot open file: %s", strerror(errno));
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
193 register_error(as, l, 2, "Cannot open file: %s", strerror(errno));
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
194 }
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
195
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
196 // don't need fn any more
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
197 lwasm_free(fn);
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
198
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
199 // read the contents of the file and "emit()" it
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
200 while (!feof(f) && !ferror(f))
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
201 {
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
202 v1 = fgetc(f);
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
203 if (v1 == EOF)
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
204 break;
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
205 lwasm_emit(as, l, v1);
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
206 }
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
207 // close file
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
208 fclose(f);
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
209 }
058f18119025 Fixed filename parsing bug in include directive and added includebin directive
lost
parents: 221
diff changeset
210
50
e672232caffe Added rmb pseudo op
lost
parents: 49
diff changeset
211 OPFUNC(pseudo_rmb)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
212 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
213 int r, v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
214
95
f3497072ac44 Fixed think-o in rm* ops (reversed pass number test)
lost
parents: 94
diff changeset
215 if (as -> passnum == 2)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
216 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
217 as -> addr += l -> nocodelen;
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
218 skip_operand(p);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
219 return;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
220 }
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
221 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, -1);
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
222 if (r != 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
223 return;
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
224 l -> nocodelen = v;
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
225 as -> addr += v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
226 }
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
227
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
228 OPFUNC(pseudo_rmd)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
229 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
230 int r, v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
231
95
f3497072ac44 Fixed think-o in rm* ops (reversed pass number test)
lost
parents: 94
diff changeset
232 if (as -> passnum == 2)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
233 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
234 as -> addr += l -> nocodelen;
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
235 skip_operand(p);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
236 return;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
237 }
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
238 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, 0);
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
239 if (r != 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
240 return;
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
241 v *= 2;
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
242 l -> nocodelen = v;
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
243 as -> addr += v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
244 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
245
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
246 OPFUNC(pseudo_rmq)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
247 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
248 int r, v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
249
95
f3497072ac44 Fixed think-o in rm* ops (reversed pass number test)
lost
parents: 94
diff changeset
250 if (as -> passnum == 2)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
251 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
252 as -> addr += l -> nocodelen;
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
253 skip_operand(p);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
254 return;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
255 }
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
256 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, 0);
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
257 if (r != 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
258 return;
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
259 v *= 4;
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
260 l -> nocodelen = v;
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
261 as -> addr += v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
262 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
263
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
264 OPFUNC(pseudo_zmb)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
265 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
266 int r, v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
267
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
268 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, 0);
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
269 if (r != 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
270 return;
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
271 while (v--)
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
272 lwasm_emit(as, l, 0);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
273 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
274
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
275 OPFUNC(pseudo_zmd)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
276 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
277 int r, v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
278
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
279 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, 0);
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
280 if (r != 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
281 return;
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
282 v *= 2;
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
283 while (v--)
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
284 lwasm_emit(as, l, 0);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
285 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
286
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
287 OPFUNC(pseudo_zmq)
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
288 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
289 int r, v;
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
290
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
291 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, 0);
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
292 if (r != 0)
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
293 return;
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
294 v *= 4;
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
295 while (v--)
53
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
296 lwasm_emit(as, l, 0);
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
297 }
493cb8ea50a0 Added rm[dq], zm[bdq]
lost
parents: 52
diff changeset
298
54
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
299 OPFUNC(pseudo_end)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
300 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
301 int r, v;
54
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
302 lwasm_expr_stack_t *s;
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
303
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
304
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
305 as -> endseen = 1;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
306
54
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
307 // address only matters for DECB output
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
308 if (as -> outformat != OUTPUT_DECB)
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
309 {
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
310 skip_operand(p);
54
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
311 return;
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
312 }
54
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
313
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
314 r = lwasm_expr_result2(as, l, p, 0, &v, 0);
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
315 if (r != 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
316 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
317 register_error(as, l, 2, "Bad operand");
54
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
318 }
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
319
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
320 v = v & 0xffff;
54
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
321 if (as -> passnum == 2)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
322 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
323 as -> execaddr = v;
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
324 l -> symaddr = v;
54
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
325 l -> addrset = 2;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
326 }
54
360d53062bb9 Fixed typo in instruction table and added END directive
lost
parents: 53
diff changeset
327 }
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
328
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
329
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
330 OPFUNC(pseudo_align)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
331 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
332 int cn;
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
333 int r, v;
235
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
334 int pad = 0;
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
335 // we have to parse this on pass 2 so that we get the pad value
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
336 // if (as -> passnum == 2)
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
337 // {
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
338 // skip_operand(p);
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
339 // while (as -> addr < l -> symaddr)
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
340 // lwasm_emit(as, l, 0);
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
341 // return;
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
342 // }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
343
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
344 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, 0);
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
345 if (r != 0)
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
346 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
347 l -> symaddr = as -> addr;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
348 return;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
349 }
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
350
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
351 if (v < 1)
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
352 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
353 register_error(as, l, 1, "Illegal alignment %d", v);
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
354 return;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
355 }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
356
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
357 cn = l -> codeaddr % v;
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
358 if (cn)
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
359 cn = v - cn;
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
360
235
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
361 if (**p == ',')
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
362 {
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
363 // we have a padding value specified
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
364 (*p)++;
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
365 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST, &pad, 1);
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
366 if (r != 0 && as -> passnum == 2)
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
367 {
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
368 register_error(as, l, 2, "Illegal padding value - must be constant on pass 2");
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
369 return;
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
370 }
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
371 }
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
372
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
373 while (cn--)
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
374 {
235
aa0056ca7319 Added a padding value for the ALIGN directive
lost
parents: 229
diff changeset
375 lwasm_emit(as, l, pad);
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
376 }
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
377 l -> symaddr = as -> addr;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
378 }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
379
50
e672232caffe Added rmb pseudo op
lost
parents: 49
diff changeset
380 OPFUNC(pseudo_equ)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
381 {
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
382 int r, v;
52
b9856da2674a Added file inclusion
lost
parents: 50
diff changeset
383
50
e672232caffe Added rmb pseudo op
lost
parents: 49
diff changeset
384 if (l -> sym == NULL)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
385 {
50
e672232caffe Added rmb pseudo op
lost
parents: 49
diff changeset
386 register_error(as, l, 1, "No symbol specified");
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
387 return;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
388 }
50
e672232caffe Added rmb pseudo op
lost
parents: 49
diff changeset
389
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
390 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, 0);
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
391 if (r < 0)
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
392 v = 0;
63
d85ba47b1e8f Moved symbol registration so symbols that are in skipped code do not get registered and so EQU/SET can do their own registration
lost
parents: 57
diff changeset
393
78
121bf4a588ea Checkpointing deployment of non-constant expression handling
lost
parents: 74
diff changeset
394 l -> symaddr = v & 0xFFFF;
50
e672232caffe Added rmb pseudo op
lost
parents: 49
diff changeset
395 l -> addrset = 2;
63
d85ba47b1e8f Moved symbol registration so symbols that are in skipped code do not get registered and so EQU/SET can do their own registration
lost
parents: 57
diff changeset
396
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
397 // note: we need to do this because the symbol might have resolved
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
398 // to a constant!
190
563adfccb645 Added 'sym=expr' opcode handling
lost
parents: 162
diff changeset
399 lwasm_register_symbol(as, l, l -> sym, v, (r > 0 ? SYMBOL_COMPLEX: SYMBOL_NORM) | SYMBOL_FORCE | (l -> forceglobal ? SYMBOL_GLOBAL : SYMBOL_NORM));
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
400 }
63
d85ba47b1e8f Moved symbol registration so symbols that are in skipped code do not get registered and so EQU/SET can do their own registration
lost
parents: 57
diff changeset
401
d85ba47b1e8f Moved symbol registration so symbols that are in skipped code do not get registered and so EQU/SET can do their own registration
lost
parents: 57
diff changeset
402 OPFUNC(pseudo_set)
d85ba47b1e8f Moved symbol registration so symbols that are in skipped code do not get registered and so EQU/SET can do their own registration
lost
parents: 57
diff changeset
403 {
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
404 int r, v;
64
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
405
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
406 // set MUST run on both passes as the symbol value changes!
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
407
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
408 if (l -> sym == NULL)
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
409 {
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
410 register_error(as, l, 1, "No symbol specified");
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
411 return;
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
412 }
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
413
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
414 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, 0);
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
415 if (r < 0)
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
416 v = 0;
64
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
417
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
418 l -> symaddr = v & 0xFFFF;
64
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
419 l -> addrset = 2;
aaddd47219b4 Added the 'set' directive
lost
parents: 63
diff changeset
420
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
421 lwasm_register_symbol(as, l, l -> sym, v, (r > 0 ? SYMBOL_COMPLEX: SYMBOL_NORM) | SYMBOL_SET);
63
d85ba47b1e8f Moved symbol registration so symbols that are in skipped code do not get registered and so EQU/SET can do their own registration
lost
parents: 57
diff changeset
422 }
d85ba47b1e8f Moved symbol registration so symbols that are in skipped code do not get registered and so EQU/SET can do their own registration
lost
parents: 57
diff changeset
423
65
31d8e85706e7 Implemented setdp and corrected handling of direct page detection in insn_gen_aux()
lost
parents: 64
diff changeset
424 OPFUNC(pseudo_setdp)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
425 {
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
426 int r, v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
427
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
428 if (as -> outformat == OUTPUT_OBJ)
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
429 {
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
430 register_error(as, l, 1, "SETDP not permitted with OBJ target");
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
431 return;
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
432 }
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
433
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
434 // setdp is needed on both passes; must resolve to a constant on pass 1
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
435 r = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v, 0);
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
436 if (r != 0)
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
437 return;
65
31d8e85706e7 Implemented setdp and corrected handling of direct page detection in insn_gen_aux()
lost
parents: 64
diff changeset
438
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
439 if (v < -127 || v > 255)
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
440 {
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
441 register_error(as, l, 1, "Byte overflow");
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
442 return;
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
443 }
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
444
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
445 l -> symaddr = v & 0xFF;
65
31d8e85706e7 Implemented setdp and corrected handling of direct page detection in insn_gen_aux()
lost
parents: 64
diff changeset
446 l -> addrset = 2;
31d8e85706e7 Implemented setdp and corrected handling of direct page detection in insn_gen_aux()
lost
parents: 64
diff changeset
447
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
448 as -> dpval = v & 0xFF;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
449 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
450
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
451 // used to get a byte from a string
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
452 // -1 is end of line
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
453 int pseudo_fcc_fetchchar(asmstate_t *as, char **p)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
454 {
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
455 int c;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
456
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
457 // -
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
458 if (!**p)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
459 return -1;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
460
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
461 c = (unsigned char)(**p);
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
462 (*p)++;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
463
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
464 if (as -> pragmas & PRAGMA_CESCAPES && c == '\\')
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
465 {
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
466 // decode escapes if needed
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
467 if (!**p)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
468 return c;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
469
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
470 c = **p;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
471 (*p)++;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
472
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
473 switch (c)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
474 {
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
475 // octal value
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
476 // 1, 2, or 3 digits
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
477 // NOTE: \0 for NUL is included in this...
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
478 case '0':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
479 case '1':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
480 case '2':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
481 case '3':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
482 case '4':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
483 case '5':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
484 case '6':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
485 case '7':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
486 c -= '0';
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
487 if (**p < '0' || **p > '9')
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
488 return c;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
489 c = c << 3;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
490 c |= **p - '0';
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
491 (*p)++;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
492 if (**p < '0' || **p > '9')
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
493 return c;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
494 c = c << 3;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
495 c |= **p - '0';
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
496 (*p)++;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
497 return c;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
498
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
499 // LF
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
500 case 'n':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
501 return 10;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
502
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
503 // CR
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
504 case 'r':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
505 return 13;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
506
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
507 // TAB
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
508 case 't':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
509 return 9;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
510
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
511 // VT
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
512 case 'v':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
513 return 11;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
514
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
515 // BS
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
516 case 'b':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
517 return 8;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
518
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
519 // FF
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
520 case 'f':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
521 return 12;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
522
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
523 // BEL
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
524 case 'a':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
525 return 7;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
526
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
527 // hex char code (2 chars)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
528 case 'x':
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
529 {
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
530 int c2;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
531 if (!**p)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
532 return 'x';
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
533 c = toupper(**p);
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
534 (*p)++;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
535 if (c < '0' || (c > '9' && c < 'A') || c > 'F')
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
536 return 0;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
537 c -= '0';
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
538 if (c > 9)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
539 c -= 7;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
540 c2 = c << 4;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
541 if (!**p)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
542 return 0;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
543 c = toupper(**p);
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
544 (*p)++;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
545 if (c < '0' || (c > '9' && c < 'A') || c > 'F')
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
546 return 0;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
547 c -= '0';
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
548 if (c > 9)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
549 c -= 7;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
550 c2 |= c;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
551 return c2;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
552 }
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
553 // everything else stands for itself as a fall back or legit
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
554 default:
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
555 return c;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
556 }
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
557 }
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
558 return c;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
559 }
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
560
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
561 OPFUNC(pseudo_fcc)
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
562 {
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
563 int delim = 0;
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
564 int c;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
565
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
566 delim = **p;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
567 if (!delim)
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
568 {
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
569 register_error(as, l, 1, "Bad operand");
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
570 return;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
571 }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
572 *p += 1;
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
573 for (;;)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
574 {
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
575 c = pseudo_fcc_fetchchar(as, p);
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
576 if (c == delim || c < 0)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
577 break;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
578
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
579 lwasm_emit(as, l, c);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
580 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
581 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
582
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
583
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
584 OPFUNC(pseudo_fcs)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
585 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
586 int delim = 0;
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
587 int c, lc = -1;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
588
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
589 delim = **p;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
590 if (!delim)
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
591 {
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
592 register_error(as, l, 1, "Bad operand");
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
593 return;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
594 }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
595 *p += 1;
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
596 for (;;)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
597 {
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
598 c = pseudo_fcc_fetchchar(as, p);
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
599 if (c == delim || c < 0)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
600 {
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
601 if (lc >= 0)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
602 lwasm_emit(as, l, lc | 0x80);
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
603 break;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
604 }
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
605 if (lc >= 0)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
606 lwasm_emit(as, l, lc);
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
607 lc = c;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
608 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
609 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
610
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
611 OPFUNC(pseudo_fcn)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
612 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
613 int delim = 0;
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
614 int c;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
615
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
616 delim = **p;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
617 if (!delim)
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
618 {
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
619 register_error(as, l, 1, "Bad operand");
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
620 return;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
621 }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
622 *p += 1;
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
623 for (;;)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
624 {
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
625 c = pseudo_fcc_fetchchar(as, p);
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
626 if (c == delim || c < 0)
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
627 break;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
628
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
629 lwasm_emit(as, l, c);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
630 }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
631 lwasm_emit(as, l, 0);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
632 }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
633
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
634 OPFUNC(pseudo_fcb)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
635 {
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
636 int r, v;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
637
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
638 fcb_again:
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
639 r = lwasm_expr_result2(as, l, p, 0, &v, -1);
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
640 if (r < 0)
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
641 return;
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
642
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
643 if (r > 0)
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
644 {
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
645 register_error(as, l, 2, "Illegal external or inter-segment reference");
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
646 v = 0;
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
647 }
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
648
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
649 if (v < -127 || v > 255)
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
650 {
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
651 register_error(as, l, 1, "Byte overflow");
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
652 }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
653
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
654 lwasm_emit(as, l, v);
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
655 if (**p == ',')
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
656 {
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
657 (*p)++;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
658 goto fcb_again;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
659 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
660 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
661
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
662 // FIXME: handle external references in an intelligent way
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
663 OPFUNC(pseudo_fdb)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
664 {
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
665 int r, v;
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
666 int extseen = 0;
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
667 char *p1;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
668
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
669 fdb_again:
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
670 p1 = *p;
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
671 r = lwasm_expr_result2(as, l, p, 0, &v, -1);
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
672 if (r < 0)
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
673 return;
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
674
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
675 if (r > 0 && extseen == 1)
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
676 {
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
677 register_error(as, l, 2, "Illegal external or inter-segment reference (only 1 per FDB line)");
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
678 v = 0;
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
679 }
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
680 else if (r > 0)
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
681 {
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
682 l -> relocoff = as -> addr - l -> codeaddr;
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
683 *p = p1;
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
684 r = lwasm_expr_result2(as, l, p, 0, &v, 0);
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
685 }
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
686
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
687 lwasm_emit(as, l, v >> 8);
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
688 lwasm_emit(as, l, v & 0xff);
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
689 if (**p == ',')
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
690 {
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
691 (*p)++;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
692 goto fdb_again;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
693 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
694 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
695
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
696 // FIXME: handle external references in a sensible way
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
697 OPFUNC(pseudo_fqb)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
698 {
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
699 int r, v;
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
700
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
701 fqb_again:
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
702 r = lwasm_expr_result2(as, l, p, 0, &v, -1);
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
703 if (r < 0)
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
704 return;
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
705
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
706 if (r > 0)
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
707 {
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
708 register_error(as, l, 2, "Illegal external or inter-segment reference");
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
709 v = 0;
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
710 }
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
711
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
712 lwasm_emit(as, l, v >> 24);
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
713 lwasm_emit(as, l, v >> 16);
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
714 lwasm_emit(as, l, v >> 8);
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
715 lwasm_emit(as, l, v & 0xff);
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
716 if (**p == ',')
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
717 {
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
718 (*p)++;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
719 goto fqb_again;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
720 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
721 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
722
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
723 // don't need to do anything if we are executing one of these
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
724 OPFUNC(pseudo_endc)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
725 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
726 if (as -> skipcond && !(as -> skipmacro))
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
727 {
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
728 as -> skipcount -= 1;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
729 if (as -> skipcount <= 0)
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
730 {
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
731 as -> skipcond = 0;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
732 }
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
733 }
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
734 return;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
735 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
736
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
737 // if "else" executes, we must be going into an "ignore" state
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
738 OPFUNC(pseudo_else)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
739 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
740 if (as -> skipmacro)
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
741 return;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
742
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
743 if (as -> skipcond)
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
744 {
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
745 if (as -> skipcount == 1)
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
746 {
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
747 as -> skipcount = 0;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
748 as -> skipcond = 0;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
749 }
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
750 return;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
751 }
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
752
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
753 as -> skipcond = 1;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
754 as -> skipcount = 1;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
755 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
756
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
757 OPFUNC(pseudo_ifne)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
758 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
759 int v1;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
760 int rval;
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
761
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
762 if (as -> skipcond && !(as -> skipmacro))
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
763 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
764 as -> skipcount++;
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
765 skip_operand(p);
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
766 return;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
767 }
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
768
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
769 rval = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v1, 0);
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
770 if (rval != 0)
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
771 return;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
772 if (!v1)
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
773 {
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
774 as -> skipcond = 1;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
775 as -> skipcount = 1;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
776 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
777 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
778
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
779 OPFUNC(pseudo_ifdef)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
780 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
781 lwasm_symbol_ent_t *se;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
782 char *sym;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
783 char *p2;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
784
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
785 if (as -> skipcond && !(as -> skipmacro))
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
786 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
787 as -> skipcount++;
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
788 skip_operand(p);
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
789 return;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
790 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
791
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
792 if (as -> passnum != 1)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
793 {
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
794 skip_operand(p);
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
795 if (!(l -> fsize))
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
796 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
797 as -> skipcond = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
798 as -> skipcount = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
799 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
800 return;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
801 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
802
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
803 if (!**p)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
804 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
805 register_error(as, l, 1, "Need symbol name");
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
806 return;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
807 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
808
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
809 for (p2 = *p; **p && !isspace(**p); (*p)++)
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
810 /* do nothing */ ;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
811
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
812 sym = lwasm_alloc(*p - p2 + 1);
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
813 memcpy(sym, p2, *p - p2);
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
814 sym[*p - p2] = '\0';
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
815
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
816 // fprintf(stderr, "STUFF: %s; '%s'; '%s' (%d)\n", p2, *p, sym, as -> passnum);
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
817 se = lwasm_find_symbol(as, sym, l -> context);
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
818 if (!se)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
819 se = lwasm_find_symbol(as, sym, -1);
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
820
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
821 lwasm_free(sym);
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
822
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
823 if (!se)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
824 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
825 as -> skipcond = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
826 as -> skipcount = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
827 l -> fsize = 0;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
828 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
829 else
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
830 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
831 l -> fsize = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
832 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
833 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
834
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
835 OPFUNC(pseudo_ifndef)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
836 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
837 lwasm_symbol_ent_t *se;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
838 char *sym;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
839 char *p2;
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
840
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
841 if (as -> skipcond && !(as -> skipmacro))
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
842 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
843 as -> skipcount++;
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
844 skip_operand(p);
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
845 return;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
846 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
847
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
848 if (as -> passnum != 1)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
849 {
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
850 skip_operand(p);
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
851 if (l -> fsize)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
852 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
853 as -> skipcond = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
854 as -> skipcount = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
855 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
856 return;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
857 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
858
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
859 if (!**p)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
860 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
861 register_error(as, l, 1, "Need symbol name");
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
862 return;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
863 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
864
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
865 for (p2 = *p; *p2 && !isspace(*p2); p2++)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
866 /* do nothing */ ;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
867
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
868 sym = lwasm_alloc(p2 - *p + 1);
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
869 memcpy(sym, *p, p2 - *p);
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
870 sym[p2 - *p] = '\0';
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
871
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
872 *p = p2;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
873
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
874 // fprintf(stderr, "STUFF2: %s; '%s'; '%s' (%d)\n", *p, p2, sym, as -> passnum);
104
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
875 se = lwasm_find_symbol(as, sym, l -> context);
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
876 if (!se)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
877 se = lwasm_find_symbol(as, sym, -1);
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
878
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
879 lwasm_free(sym);
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
880
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
881 if (se)
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
882 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
883 as -> skipcond = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
884 as -> skipcount = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
885 l -> fsize = 0;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
886 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
887 else
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
888 {
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
889 l -> fsize = 1;
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
890 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
891 }
2ba8f9ef1417 Added ifdef/ifndef conditionals
lost
parents: 103
diff changeset
892
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
893 OPFUNC(pseudo_ifp1)
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
894 {
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
895 if (as -> skipcond && !(as -> skipmacro))
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
896 {
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
897 as -> skipcount++;
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
898 skip_operand(p);
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
899 return;
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
900 }
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
901
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
902 if (as -> passnum != 1)
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
903 {
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
904 as -> skipcond = 1;
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
905 as -> skipcount = 1;
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
906 }
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
907 }
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
908
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
909 OPFUNC(pseudo_ifp2)
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
910 {
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
911 if (as -> skipcond && !(as -> skipmacro))
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
912 {
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
913 as -> skipcount++;
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
914 skip_operand(p);
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
915 return;
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
916 }
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
917
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
918 if (as -> passnum != 2)
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
919 {
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
920 as -> skipcond = 1;
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
921 as -> skipcount = 1;
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
922 }
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
923 }
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
924
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
925 OPFUNC(pseudo_ifeq)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
926 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
927 int v1;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
928 int rval;
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
929
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
930 if (as -> skipcond && !(as -> skipmacro))
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
931 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
932 as -> skipcount++;
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
933 skip_operand(p);
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
934 return;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
935 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
936
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
937 rval = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v1, 0);
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
938 if (rval != 0)
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
939 return;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
940 if (v1)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
941 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
942 as -> skipcond = 1;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
943 as -> skipcount = 1;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
944 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
945 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
946
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
947 OPFUNC(pseudo_iflt)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
948 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
949 int v1;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
950 int rval;
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
951
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
952 if (as -> skipcond && !(as -> skipmacro))
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
953 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
954 as -> skipcount++;
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
955 skip_operand(p);
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
956 return;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
957 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
958
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
959 rval = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v1, 0);
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
960 if (rval != 0)
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
961 return;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
962 if (v1 >= 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
963 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
964 as -> skipcond = 1;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
965 as -> skipcount = 1;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
966 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
967 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
968
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
969 OPFUNC(pseudo_ifle)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
970 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
971 int v1;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
972 int rval;
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
973
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
974 if (as -> skipcond && !(as -> skipmacro))
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
975 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
976 as -> skipcount++;
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
977 skip_operand(p);
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
978 return;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
979 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
980
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
981 rval = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v1, 0);
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
982 if (rval != 0)
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
983 return;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
984 if (v1 > 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
985 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
986 as -> skipcond = 1;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
987 as -> skipcount = 1;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
988 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
989 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
990
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
991 OPFUNC(pseudo_ifgt)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
992 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
993 int v1;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
994 int rval;
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
995
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
996 if (as -> skipcond && !(as -> skipmacro))
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
997 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
998 as -> skipcount++;
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
999 skip_operand(p);
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1000 return;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1001 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1002
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
1003 rval = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v1, 0);
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
1004 if (rval != 0)
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1005 return;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1006 if (v1 <= 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1007 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1008 as -> skipcond = 1;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1009 as -> skipcount = 1;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1010 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1011 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1012
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1013 OPFUNC(pseudo_ifge)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1014 {
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1015 int v1;
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1016 int rval;
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1017
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1018 if (as -> skipcond && !(as -> skipmacro))
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1019 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1020 as -> skipcount++;
236
a58f49a77441 Added os9 target, pragma to control whether $ localizes a symbol, and fixed some condition nesting bugs
lost
parents: 235
diff changeset
1021 skip_operand(p);
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1022 return;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1023 }
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1024
103
26c058fa0bc1 Fixed up some issues with pseudo ops and object target
lost
parents: 99
diff changeset
1025 rval = lwasm_expr_result2(as, l, p, EXPR_SECTCONST | EXPR_PASS1CONST, &v1, 0);
79
d0ce3f5f6797 Checkpointing deployment of non-constant expression handling
lost
parents: 78
diff changeset
1026 if (rval != 0)
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1027 return;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1028 if (v1 < 0)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1029 {
57
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1030 as -> skipcond = 1;
035b95a3690f Added conditional assembly and macros
lost
parents: 56
diff changeset
1031 as -> skipcount = 1;
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1032 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1033 }
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1034
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
1035 OPFUNC(pseudo_error)
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1036 {
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
1037 register_error(as, l, 1, "User error: %s", *p);
0
57495da01900 Initial checking of LWASM
lost
parents:
diff changeset
1038 }
56
55260a178667 Added from f* pseudo ops
lost
parents: 54
diff changeset
1039
74
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1040
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1041 OPFUNC(pseudo_section)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1042 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1043 sectiontab_t *s;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1044 char *p2;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1045 char *sn;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1046 char *opts;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1047
99
3dcb12a6f4ff Fixed problem handling sections with options on pass 2
lost
parents: 95
diff changeset
1048
74
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1049 if (as -> outformat != OUTPUT_OBJ)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1050 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1051 register_error(as, l, 1, "Sections only supported for obj target");
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1052 return;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1053 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1054
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1055 if (as -> csect)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1056 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1057 as -> csect -> offset = as -> addr;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1058 as -> csect = NULL;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1059 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1060
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1061 if (!**p)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1062 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1063 register_error(as, l, 1, "Need section name");
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1064 return;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1065 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1066
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1067 for (p2 = *p; *p2 && !isspace(*p2); p2++)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1068 /* do nothing */ ;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1069
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1070 sn = lwasm_alloc(p2 - *p + 1);
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1071 memcpy(sn, *p, p2 - *p);
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1072 sn[p2 - *p] = '\0';
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1073
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1074 *p = p2;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1075
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1076 opts = strchr(sn, ',');
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1077 if (opts)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1078 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1079 *opts++ = '\0';
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1080 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1081
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1082 // have we seen the section name already?
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1083 for (s = as -> sections; s; s = s -> next)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1084 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1085 if (!strcmp(s -> name, sn))
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1086 break;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1087 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1088
99
3dcb12a6f4ff Fixed problem handling sections with options on pass 2
lost
parents: 95
diff changeset
1089 if (s && as -> passnum == 1)
74
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1090 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1091 lwasm_free(sn);
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1092 if (opts)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1093 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1094 register_error(as, l, 1, "Section options can only be specified the first time");
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1095 return;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1096 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1097 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1098 else if (!s)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1099 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1100 s = lwasm_alloc(sizeof(sectiontab_t));
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1101 s -> name = sn;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1102 s -> offset = 0;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1103 s -> flags = 0;
85
918be0c02239 Started adding object target output
lost
parents: 82
diff changeset
1104 s -> obytes = NULL;
918be0c02239 Started adding object target output
lost
parents: 82
diff changeset
1105 s -> oblen = 0;
918be0c02239 Started adding object target output
lost
parents: 82
diff changeset
1106 s -> obsize = 0;
86
033a328a10ae Checkpoint: object target output
lost
parents: 85
diff changeset
1107 s -> rl = NULL;
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1108 s -> exports = NULL;
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
1109 // if name of section is "bss" or ".bss", assume bss flag
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
1110 // which can be overridden with !bss flag
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
1111 if (!strcasecmp(sn, "bss") || !strcasecmp(sn, ".bss"))
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
1112 s -> flags = SECTION_BSS;
74
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1113 // parse options; only one "bss"
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1114 if (opts && as -> passnum == 1)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1115 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1116 if (!strcasecmp(opts, "bss"))
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1117 {
160
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
1118 s -> flags |= SECTION_BSS;
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
1119 }
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
1120 else if (!strcasecmp(opts, "!bss"))
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
1121 {
b061350c17e4 Added cescapes pragma and a few other compatibility pseudo ops
lost
parents: 158
diff changeset
1122 s -> flags &= ~SECTION_BSS;
74
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1123 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1124 else
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1125 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1126 register_error(as, l, 1, "Unrecognized section option '%s'", opts);
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1127 lwasm_free(s -> name);
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1128 lwasm_free(s);
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1129 return;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1130 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1131 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1132
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1133 s -> next = as -> sections;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1134 as -> sections = s;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1135 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1136 as -> addr = s -> offset;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1137 as -> csect = s;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1138 as -> context = lwasm_next_context(as);
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1139 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1140
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1141 OPFUNC(pseudo_endsection)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1142 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1143 if (as -> outformat != OUTPUT_OBJ)
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1144 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1145 register_error(as, l, 1, "Sections only supported for obj target");
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1146 return;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1147 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1148
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1149 if (!(as -> csect))
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1150 {
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1151 register_error(as, l, 1, "ENDSECTION when not in a section");
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1152 return;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1153 }
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1154
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1155 as -> csect -> offset = as -> addr;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1156 as -> addr = 0;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1157 as -> csect = 0;
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1158 as -> context = lwasm_next_context(as);
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1159 skip_operand(p);
74
c8c772ef5df9 Checkpointing object target implementation
lost
parents: 65
diff changeset
1160 }
82
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1161
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1162 OPFUNC(pseudo_extern)
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1163 {
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1164 if (as -> passnum != 1)
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1165 return;
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1166
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1167 if (as -> outformat != OUTPUT_OBJ)
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1168 {
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1169 register_error(as, l, 1, "External references only supported for obj target");
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1170 return;
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1171 }
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1172
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1173 if (as -> csect)
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1174 {
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1175 register_error(as, l, 1, "Cannot declare external symbols within a section");
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1176 return;
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1177 }
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1178
221
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1179 if (l -> sym)
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1180 {
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1181 lwasm_register_symbol(as, l, l -> sym, 0, SYMBOL_EXTERN);
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1182 for ( ; **p; (*p)++) ;
221
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1183 return;
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1184 }
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1185
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1186 while (**p)
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1187 {
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1188 char *sym2, *sym3;
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1189 for (sym2 = *p; **p && !isspace(**p) && **p != ','; (*p)++)
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1190 /* do nothing */ ;
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1191
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1192 if (l -> sym)
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1193 lwasm_free(l -> sym);
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1194
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1195 sym3 = lwasm_alloc(*p - sym2 + 1);
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1196 memcpy(sym3, sym2, *p - sym2);
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1197 sym3[*p - sym2] = '\0';
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1198
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1199 l -> sym = sym3;
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1200 debug_message(2, "import symbol: '%s'", sym3);
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1201 lwasm_register_symbol(as, l, l -> sym, 0, SYMBOL_EXTERN);
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1202 if (**p && (**p != ','))
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1203 {
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1204 register_error(as, l, 1, "Bad import list");
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1205 return;
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1206 }
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1207 if (**p == ',')
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1208 (*p)++;
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1209 }
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1210 if (!(l -> sym))
271c0ef9ea60 Fixed segfault in import/extern pseudo op
lost
parents: 212
diff changeset
1211 register_error(as, l, 1, "Bad import list");
82
03be43ae19cf Added EXTERN directive
lost
parents: 79
diff changeset
1212 }
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1213
243
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1214 OPFUNC(pseudo_extdep)
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1215 {
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1216 if (as -> passnum != 1)
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1217 return;
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1218
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1219 if (as -> outformat != OUTPUT_OBJ)
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1220 {
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1221 register_error(as, l, 1, "External references only supported for obj target");
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1222 return;
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1223 }
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1224
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1225 if (l -> sym)
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1226 {
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1227 // add symbol to the "ext dep" list
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1228 as -> extdeps = lwasm_realloc(as -> extdeps, sizeof(char *) * (as -> nextdeps + 1));
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1229 as -> extdeps[as -> nextdeps++] = lwasm_strdup(l -> sym);
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1230 return;
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1231 }
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1232 }
f9f01a499525 Added zero-width external references
lost
parents: 241
diff changeset
1233
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1234 OPFUNC(pseudo_export)
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1235 {
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1236 lwasm_symbol_ent_t *se;
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1237 export_list_t *ex;
158
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1238 char *sym2, *sym3;
192
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1239 int after = 0;
158
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1240
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1241 if (as -> outformat != OUTPUT_OBJ)
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1242 {
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1243 register_error(as, l, 1, "Symbol exports only supported for obj target");
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1244 return;
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1245 }
158
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1246
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1247 if (as -> passnum == 1)
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1248 {
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1249 skip_operand(p);
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1250 return;
229
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1251 }
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1252
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1253 if (l -> sym)
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1254 {
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1255 for ( ; **p; (*p)++) ;
59a138df0401 Fixed additional parsing problems with pseudo ops
lost
parents: 225
diff changeset
1256 }
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1257
192
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1258 again:
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1259 if (!(l -> sym) || after == 1)
158
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1260 {
192
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1261
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1262 after = 1;
158
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1263 // look for symbol after op
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1264 if (**p)
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1265 {
192
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1266 for (sym2 = *p; **p && !isspace(**p) && **p != ','; (*p)++)
162
02ada556bcc0 Fixed stupid error with for loop
lost
parents: 160
diff changeset
1267 /* do nothing */ ;
192
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1268
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1269 debug_message(2, "export expression: %s", sym2);
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1270 if (l -> sym)
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1271 lwasm_free(l -> sym);
158
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1272 sym3 = lwasm_alloc(*p - sym2 + 1);
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1273 memcpy(sym3, sym2, *p - sym2);
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1274 sym3[*p - sym2] = '\0';
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1275
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1276 l -> sym = sym3;
192
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1277 debug_message(2, "export symbol: '%s'", sym3);
158
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1278 }
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1279 }
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1280 if (!(l -> sym))
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1281 {
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1282 register_error(as, l, 2, "No symbol");
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1283 return;
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1284 }
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1285
f0527dc3804d Added support for .globl <sym>, .area <section>, .word, .byte, .blkb, and a .module directive that does nothing
lost
parents: 151
diff changeset
1286
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1287 // the symbol better be defined at this point (pass 2)
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1288 // local symbols cannot be exported nor can "global" symbols
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1289 se = lwasm_find_symbol(as, l -> sym, -1);
202
1a75121c3c3f Yet again try to get importing undefined exports working
lost
parents: 201
diff changeset
1290 if ((!se || (se -> flags & SYMBOL_EXTERN)) && (as -> pragmas & PRAGMA_IMPORTUNDEFEXPORT))
198
6ddc861a07d4 Allow export to import undefined symbols
lost
parents: 192
diff changeset
1291 {
201
7824f94c5786 take 2: importing undefined exports
lost
parents: 199
diff changeset
1292 void *p;
7824f94c5786 take 2: importing undefined exports
lost
parents: 199
diff changeset
1293 p = as -> csect;
7824f94c5786 take 2: importing undefined exports
lost
parents: 199
diff changeset
1294 as -> csect = NULL;
198
6ddc861a07d4 Allow export to import undefined symbols
lost
parents: 192
diff changeset
1295 lwasm_register_symbol(as, l, l -> sym, 0, SYMBOL_EXTERN);
201
7824f94c5786 take 2: importing undefined exports
lost
parents: 199
diff changeset
1296 as -> csect = p;
198
6ddc861a07d4 Allow export to import undefined symbols
lost
parents: 192
diff changeset
1297 }
199
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1298 else
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1299 {
201
7824f94c5786 take 2: importing undefined exports
lost
parents: 199
diff changeset
1300 if (!se)
199
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1301 {
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1302 register_error(as, l, 2, "Exported symbols must be fully defined within a section");
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1303 return;
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1304 }
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1305 if (se -> sect == NULL)
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1306 {
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1307 register_error(as, l, 2, "Only non-local symbols within a section can be exported");
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1308 return;
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1309 }
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1310
199
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1311 if (se -> flags & SYMBOL_SET)
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1312 {
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1313 register_error(as, l, 2, "You cannot export symbols defined with SET");
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1314 return;
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1315 }
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1316
199
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1317 // if the symbol is not already a simple value, re-evaluate it
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1318 // and see if it becomes simple
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1319
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1320
199
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1321 if (se -> flags & SYMBOL_COMPLEX)
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1322 {
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1323 register_error(as, l, 2, "Exported symbols must be fully resolved on pass 2");
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1324 return;
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1325 }
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1326
199
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1327 // search for existing export
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1328 for (ex = se -> sect -> exports; ex; ex = ex -> next)
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1329 if (!strcmp(l -> sym, ex -> sym))
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1330 break;
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1331 if (ex)
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1332 {
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1333 register_error(as, l, 2, "Symbol %s already exported", l -> sym);
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1334 return;
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1335 }
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1336
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1337 // add an external reference
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1338 ex = lwasm_alloc(sizeof(export_list_t));
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1339 ex -> next = se -> sect -> exports;
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1340 se -> sect -> exports = ex;
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1341 ex -> offset = se -> value;
188037f0397c Allow export to import undefined symbols
lost
parents: 198
diff changeset
1342 ex -> sym = lwasm_strdup(se -> sym);
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1343 }
202
1a75121c3c3f Yet again try to get importing undefined exports working
lost
parents: 201
diff changeset
1344 next:
192
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1345 if (after == 1)
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1346 {
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1347 if (**p == ',')
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1348 {
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1349 debug_message(2, "Export another symbol: %s", *p);
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1350 (*p)++;
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1351 for ( ; **p && isspace(**p); (*p)++)
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1352 /* do nothing */ ;
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1353 goto again;
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1354 }
bfd0fb0a85c2 Allow exporting multiple symbols on a single directive
lost
parents: 190
diff changeset
1355 }
90
6097cb1486f8 Added EXPORT pseudo op
lost
parents: 86
diff changeset
1356 }