annotate lwasm/pseudo.c @ 257:e27279180a73 2.x

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