Mercurial > hg-old > index.cgi

annotate lwasm/pseudo.c @ 208:06effa2faea1

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