]>
Commit | Line | Data |
---|---|---|
2cedb9eb BR |
1 | %option noyywrap |
2 | ||
07c1b327 | 3 | /* bfin-lex.l ADI Blackfin lexer |
a2c58332 | 4 | Copyright (C) 2005-2022 Free Software Foundation, Inc. |
07c1b327 CM |
5 | |
6 | This file is part of GAS, the GNU Assembler. | |
7 | ||
8 | GAS is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
ec2655a6 | 10 | the Free Software Foundation; either version 3, or (at your option) |
07c1b327 CM |
11 | any later version. |
12 | ||
13 | GAS is distributed in the hope that it will be useful, | |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with GAS; see the file COPYING. If not, write to the Free | |
20 | Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA | |
21 | 02110-1301, USA. */ | |
22 | %{ | |
07c1b327 | 23 | #include "bfin-defs.h" |
55add51e | 24 | #include "config/bfin-parse.h" |
07c1b327 CM |
25 | |
26 | static long parse_int (char **end); | |
27 | static int parse_halfreg (Register *r, int cl, char *hr); | |
28 | static int parse_reg (Register *r, int type, char *rt); | |
29 | int yylex (void); | |
30 | ||
31 | #define _REG yylval.reg | |
32 | ||
adb0bd8f MF |
33 | /* Flex generates static functions "input" & "unput" which are not used. */ |
34 | #define YY_NO_INPUT | |
35 | #define YY_NO_UNPUT | |
07c1b327 CM |
36 | |
37 | %} | |
38 | ||
39 | /* Define Start States ... Actually we will use exclusion. | |
40 | If no start state is specified it should match any state | |
41 | and <INITIAL> would match some keyword rules only with | |
42 | initial. */ | |
43 | %s KEYWORD | |
65646555 | 44 | %s FLAGS |
07c1b327 CM |
45 | |
46 | %% | |
47 | [sS][fF][tT][rR][eE][sS][eE][tT] _REG.regno = REG_sftreset; return REG; | |
48 | [oO][mM][oO][dD][eE] _REG.regno = REG_omode; return REG; | |
49 | [iI][dD][lL][eE]_[rR][eE][qQ] _REG.regno = REG_idle_req; return REG; | |
50 | [hH][wW][eE][rR][rR][cC][aA][uU][sS][eE] _REG.regno = REG_hwerrcause; return REG; | |
51 | [eE][xX][cC][aA][uU][sS][eE] _REG.regno = REG_excause; return REG; | |
52 | [eE][mM][uU][cC][aA][uU][sS][eE] _REG.regno = REG_emucause; return REG; | |
65646555 MF |
53 | <FLAGS>[zZ] return Z; |
54 | <FLAGS>[xX] return X; | |
07c1b327 CM |
55 | [wW]32 yylval.value = M_W32; return MMOD; |
56 | [wW] return W; | |
57 | [vV][iI][tT]_[mM][aA][xX] return VIT_MAX; | |
58 | [vV] return V; /* Special: V is a statflag and a modifier. */ | |
59 | [uU][sS][pP] _REG.regno = REG_USP; return REG; | |
60 | [tT][lL] return TL; | |
61 | [tT][hH] return TH; | |
62 | [tT][fF][uU] yylval.value = M_TFU; return MMOD; | |
63 | [tT][eE][sS][tT][sS][eE][tT] return TESTSET; | |
65646555 MF |
64 | <FLAGS>[tT] yylval.value = M_T; return MMOD; |
65 | <FLAGS>[sS] return S; | |
07c1b327 CM |
66 | [sS][yY][sS][cC][fF][gG] _REG.regno = REG_SYSCFG; return REG; |
67 | [sS][tT][iI] return STI; | |
68 | [sS][sS][yY][nN][cC] return SSYNC; | |
f31bf2c6 JZ |
69 | [sS][pP]"."[lL] _REG.regno = REG_SP; _REG.flags = F_REG_LOW; return HALF_REG; |
70 | [sS][pP]"."[hH] _REG.regno = REG_SP; _REG.flags = F_REG_HIGH; return HALF_REG; | |
07c1b327 CM |
71 | [sS][pP] _REG.regno = REG_SP; return REG; |
72 | [sS][iI][gG][nN][bB][iI][tT][sS] return SIGNBITS; | |
73 | [sS][iI][gG][nN] return SIGN; | |
74 | [sS][eE][qQ][sS][tT][aA][tT] _REG.regno = REG_SEQSTAT; return REG; | |
75 | [sS][eE][aA][rR][cC][hH] return SEARCH; | |
76 | [sS][hH][iI][fF][tT] return SHIFT; | |
77 | [sS][cC][oO] return SCO; | |
78 | ||
79 | [sS][aA][aA] return SAA; | |
80 | [sS]2[rR][nN][dD] yylval.value = M_S2RND; return MMOD; | |
81 | [rR][tT][xX] return RTX; | |
82 | [rR][tT][sS] return RTS; | |
83 | [rR][tT][nN] return RTN; | |
84 | [rR][tT][iI] return RTI; | |
85 | [rR][tT][eE] return RTE; | |
86 | [rR][oO][tT] return ROT; | |
87 | [rR][nN][dD]20 return RND20; | |
88 | [rR][nN][dD]12 return RND12; | |
89 | [rR][nN][dD][lL] return RNDL; | |
90 | [rR][nN][dD][hH] return RNDH; | |
91 | [rR][nN][dD] return RND; | |
92 | ||
93 | [rR][0-7]"."[lLhHbB] return parse_halfreg(&yylval.reg, T_REG_R, yytext); | |
94 | ||
95 | [rR][eE][tT][sS] _REG.regno = REG_RETS; return REG; | |
96 | [rR][eE][tT][iI] _REG.regno = REG_RETI; return REG; | |
97 | [rR][eE][tT][xX] _REG.regno = REG_RETX; return REG; | |
98 | [rR][eE][tT][nN] _REG.regno = REG_RETN; return REG; | |
99 | [rR][eE][tT][eE] _REG.regno = REG_RETE; return REG; | |
100 | [eE][mM][uU][dD][aA][tT] _REG.regno = REG_EMUDAT; return REG; | |
101 | [rR][aA][iI][sS][eE] return RAISE; | |
102 | ||
103 | [rR][0-7] return parse_reg (&yylval.reg, T_REG_R, yytext); | |
104 | ||
105 | [rR] return R; | |
106 | [pP][rR][nN][tT] return PRNT; | |
107 | [pP][cC] return PC; | |
108 | [pP][aA][cC][kK] return PACK; | |
109 | ||
110 | [pP][0-5]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_P, yytext); | |
111 | [pP][0-5] return parse_reg (&yylval.reg, T_REG_P, yytext); | |
112 | ||
113 | [oO][uU][tT][cC] return OUTC; | |
114 | [oO][nN][eE][sS] return ONES; | |
115 | ||
116 | [nN][oO][tT] return NOT; | |
117 | [nN][oO][pP] return NOP; | |
118 | [mM][nN][oO][pP] return MNOP; | |
119 | [nN][sS] return NS; | |
120 | ||
121 | ||
122 | [mM][iI][nN] return MIN; | |
123 | [mM][aA][xX] return MAX; | |
124 | ||
125 | [mM][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_M, yytext); | |
126 | [mM][0-3] return parse_reg (&yylval.reg, T_REG_M, yytext); | |
127 | ||
65646555 | 128 | <FLAGS>[mM] return M; |
07c1b327 CM |
129 | [lL][tT] return LT; |
130 | [lL][sS][hH][iI][fF][tT] return LSHIFT; | |
131 | [lL][sS][eE][tT][uU][pP] return LSETUP; | |
132 | [lL][oO][oO][pP] return LOOP; | |
133 | [lL][oO][oO][pP]_[bB][eE][gG][iI][nN] return LOOP_BEGIN; | |
134 | [lL][oO][oO][pP]_[eE][nN][dD] return LOOP_END; | |
135 | ||
136 | [lL][eE] return LE; | |
137 | [lL][cC]0 _REG.regno = REG_LC0; return REG; | |
138 | [lL][tT]0 _REG.regno = REG_LT0; return REG; | |
139 | [lL][bB]0 _REG.regno = REG_LB0; return REG; | |
140 | [lL][cC]1 _REG.regno = REG_LC1; return REG; | |
141 | [lL][tT]1 _REG.regno = REG_LT1; return REG; | |
142 | [lL][bB]1 _REG.regno = REG_LB1; return REG; | |
143 | ||
144 | [lL][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_L, yytext); | |
145 | [lL][0-3] return parse_reg (&yylval.reg, T_REG_L, yytext); | |
146 | [lL][oO] return LO; | |
147 | [jJ][uU][mM][pP]"."[sS] { BEGIN 0; return JUMP_DOT_S;} | |
148 | [jJ][uU][mM][pP]"."[lL] { BEGIN 0; return JUMP_DOT_L;} | |
149 | [jJ][uU][mM][pP] { BEGIN 0; return JUMP;} | |
150 | [jJ][uU][mM][pP]"."[xX] { BEGIN 0; return JUMP_DOT_L; } | |
151 | [iI][uU] yylval.value = M_IU; return MMOD; | |
152 | [iI][sS][sS]2 yylval.value = M_ISS2; return MMOD; | |
153 | [iI][sS] yylval.value = M_IS; return MMOD; | |
154 | [iI][hH] yylval.value = M_IH; return MMOD; | |
155 | [iI][fF] return IF; | |
156 | [iI][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_I, yytext); | |
157 | [iI][0-3] return parse_reg (&yylval.reg, T_REG_I, yytext); | |
158 | [hH][lL][tT] return HLT; | |
159 | [hH][iI] return HI; | |
160 | [gG][tT] return GT; | |
161 | [gG][eE] return GE; | |
162 | [fF][uU] yylval.value = M_FU; return MMOD; | |
163 | [fF][pP] _REG.regno = REG_FP; return REG; | |
f31bf2c6 JZ |
164 | [fF][pP]"."[lL] _REG.regno = REG_FP; _REG.flags = F_REG_LOW; return HALF_REG; |
165 | [fF][pP]"."[hH] _REG.regno = REG_FP; _REG.flags = F_REG_HIGH; return HALF_REG; | |
07c1b327 CM |
166 | |
167 | [eE][xX][tT][rR][aA][cC][tT] return EXTRACT; | |
168 | [eE][xX][pP][aA][dD][jJ] return EXPADJ; | |
169 | [eE][xX][cC][pP][tT] return EXCPT; | |
170 | [eE][mM][uU][eE][xX][cC][pP][tT] return EMUEXCPT; | |
171 | [dD][iI][vV][sS] return DIVS; | |
172 | [dD][iI][vV][qQ] return DIVQ; | |
173 | [dD][iI][sS][aA][lL][gG][nN][eE][xX][cC][pP][tT] return DISALGNEXCPT; | |
174 | [dD][eE][pP][oO][sS][iI][tT] return DEPOSIT; | |
175 | [dD][bB][gG][hH][aA][lL][tT] return DBGHALT; | |
176 | [dD][bB][gG][cC][mM][pP][lL][xX] return DBGCMPLX; | |
177 | [dD][bB][gG][aA][lL] return DBGAL; | |
178 | [dD][bB][gG][aA][hH] return DBGAH; | |
179 | [dD][bB][gG][aA] return DBGA; | |
180 | [dD][bB][gG] return DBG; | |
181 | [cC][yY][cC][lL][eE][sS]2 { _REG.regno = REG_CYCLES2; return REG; } | |
182 | [cC][yY][cC][lL][eE][sS] { _REG.regno = REG_CYCLES; return REG; } | |
183 | [cC][sS][yY][nN][cC] return CSYNC; | |
184 | [cC][oO] return CO; | |
185 | [cC][lL][iI] return CLI; | |
186 | ||
187 | [cC][cC] _REG.regno = REG_CC; return CCREG; | |
188 | [cC][aA][lL][lL]"."[xX] { BEGIN 0; return CALL;} | |
189 | [cC][aA][lL][lL] { BEGIN 0; return CALL;} | |
190 | [bB][yY][tT][eE][uU][nN][pP][aA][cC][kK] return BYTEUNPACK; | |
191 | [bB][yY][tT][eE][pP][aA][cC][kK] return BYTEPACK; | |
192 | [bB][yY][tT][eE][oO][pP]16[mM] return BYTEOP16M; | |
193 | [bB][yY][tT][eE][oO][pP]16[pP] return BYTEOP16P; | |
194 | [bB][yY][tT][eE][oO][pP]3[pP] return BYTEOP3P; | |
07c1b327 CM |
195 | [bB][yY][tT][eE][oO][pP]2[pP] return BYTEOP2P; |
196 | [bB][yY][tT][eE][oO][pP]1[pP] return BYTEOP1P; | |
197 | [bB][yY] return BY; | |
198 | [bB][xX][oO][rR][sS][hH][iI][fF][tT] return BXORSHIFT; | |
199 | [bB][xX][oO][rR] return BXOR; | |
200 | ||
201 | [bB][rR][eE][vV] return BREV; | |
202 | [bB][pP] return BP; | |
203 | [bB][iI][tT][tT][sS][tT] return BITTST; | |
204 | [bB][iI][tT][tT][gG][lL] return BITTGL; | |
205 | [bB][iI][tT][sS][eE][tT] return BITSET; | |
206 | [bB][iI][tT][mM][uU][xX] return BITMUX; | |
207 | [bB][iI][tT][cC][lL][rR] return BITCLR; | |
208 | [bB][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_B, yytext); | |
209 | [bB][0-3] return parse_reg (&yylval.reg, T_REG_B, yytext); | |
210 | [bB] return B; | |
211 | [aA][zZ] _REG.regno = S_AZ; return STATUS_REG; | |
212 | [aA][nN] _REG.regno = S_AN; return STATUS_REG; | |
22215ae0 MF |
213 | [aA][cC]0_[cC][oO][pP][yY] _REG.regno = S_AC0_COPY; return STATUS_REG; |
214 | [vV]_[cC][oO][pP][yY] _REG.regno = S_V_COPY; return STATUS_REG; | |
07c1b327 CM |
215 | [aA][qQ] _REG.regno = S_AQ; return STATUS_REG; |
216 | [aA][cC]0 _REG.regno = S_AC0; return STATUS_REG; | |
217 | [aA][cC]1 _REG.regno = S_AC1; return STATUS_REG; | |
218 | [aA][vV]0 _REG.regno = S_AV0; return STATUS_REG; | |
219 | [aA][vV]0[sS] _REG.regno = S_AV0S; return STATUS_REG; | |
220 | [aA][vV]1 _REG.regno = S_AV1; return STATUS_REG; | |
221 | [aA][vV]1[sS] _REG.regno = S_AV1S; return STATUS_REG; | |
07c1b327 | 222 | [vV][sS] _REG.regno = S_VS; return STATUS_REG; |
22215ae0 | 223 | [rR][nN][dD]_[mM][oO][dD] _REG.regno = S_RND_MOD; return STATUS_REG; |
07c1b327 CM |
224 | |
225 | ||
226 | [aA][sS][tT][aA][tT] _REG.regno = REG_ASTAT; return REG; | |
227 | [aA][sS][hH][iI][fF][tT] return ASHIFT; | |
228 | [aA][sS][lL] return ASL; | |
229 | [aA][sS][rR] return ASR; | |
230 | [aA][lL][iI][gG][nN]8 return ALIGN8; | |
231 | [aA][lL][iI][gG][nN]16 return ALIGN16; | |
232 | [aA][lL][iI][gG][nN]24 return ALIGN24; | |
233 | [aA]1"."[lL] return A_ONE_DOT_L; | |
234 | [aA]0"."[lL] return A_ZERO_DOT_L; | |
235 | [aA]1"."[hH] return A_ONE_DOT_H; | |
236 | [aA]0"."[hH] return A_ZERO_DOT_H; | |
237 | [aA][bB][sS] return ABS; | |
1b182c3c | 238 | [aA][bB][oO][rR][tT] return ABORT; |
07c1b327 CM |
239 | [aA]1"."[xX] _REG.regno = REG_A1x; return REG; |
240 | [aA]1"."[wW] _REG.regno = REG_A1w; return REG; | |
241 | [aA]1 _REG.regno = REG_A1; return REG_A_DOUBLE_ONE; | |
242 | [aA]0"."[xX] _REG.regno = REG_A0x; return REG; | |
243 | [aA]0"."[wW] _REG.regno = REG_A0w; return REG; | |
244 | [aA]0 _REG.regno = REG_A0; return REG_A_DOUBLE_ZERO; | |
245 | [Gg][Oo][Tt] return GOT; | |
1ac4baed BS |
246 | [Gg][Oo][Tt]"17"[Mm]"4" return GOT17M4; |
247 | [Ff][Uu][Nn][Cc][Dd][Ee][Ss][Cc]"_"[Gg][Oo][Tt]"17"[Mm]"4" return FUNCDESC_GOT17M4; | |
07c1b327 CM |
248 | [Pp][Ll][Tt][Pp][Cc] return PLTPC; |
249 | ||
250 | ||
251 | "~" return TILDA; | |
252 | "|=" return _BAR_ASSIGN; | |
253 | "|" return BAR; | |
254 | "^=" return _CARET_ASSIGN; | |
255 | "^" return CARET; | |
256 | "]" return RBRACK; | |
257 | "[" return LBRACK; | |
258 | ">>>=" return _GREATER_GREATER_GREATER_THAN_ASSIGN; | |
259 | ">>=" return _GREATER_GREATER_ASSIGN; | |
260 | ">>>" return _GREATER_GREATER_GREATER; | |
261 | ">>" return GREATER_GREATER; | |
262 | "==" return _ASSIGN_ASSIGN; | |
263 | "=" return ASSIGN; | |
264 | "<=" return _LESS_THAN_ASSIGN; | |
265 | "<<=" return _LESS_LESS_ASSIGN; | |
266 | "<<" return LESS_LESS; | |
267 | "<" return LESS_THAN; | |
65646555 MF |
268 | "(" BEGIN(FLAGS); return LPAREN; |
269 | ")" BEGIN(INITIAL); return RPAREN; | |
07c1b327 CM |
270 | ":" return COLON; |
271 | "/" return SLASH; | |
272 | "-=" return _MINUS_ASSIGN; | |
273 | "+|+" return _PLUS_BAR_PLUS; | |
274 | "-|+" return _MINUS_BAR_PLUS; | |
275 | "+|-" return _PLUS_BAR_MINUS; | |
276 | "-|-" return _MINUS_BAR_MINUS; | |
277 | "--" return _MINUS_MINUS; | |
278 | "-" return MINUS; | |
279 | "," return COMMA; | |
280 | "+=" return _PLUS_ASSIGN; | |
281 | "++" return _PLUS_PLUS; | |
282 | "+" return PLUS; | |
283 | "*=" return _STAR_ASSIGN; | |
284 | "*" return STAR; | |
285 | "&=" return _AMPERSAND_ASSIGN; | |
286 | "&" return AMPERSAND; | |
287 | "%" return PERCENT; | |
288 | "!" return BANG; | |
289 | ";" return SEMICOLON; | |
290 | "=!" return _ASSIGN_BANG; | |
291 | "||" return DOUBLE_BAR; | |
292 | "@" return AT; | |
293 | <KEYWORD>[pP][rR][eE][fF][eE][tT][cC][hH] return PREFETCH; | |
294 | <KEYWORD>[uU][nN][lL][iI][nN][kK] return UNLINK; | |
295 | <KEYWORD>[lL][iI][nN][kK] return LINK; | |
296 | <KEYWORD>[iI][dD][lL][eE] return IDLE; | |
297 | <KEYWORD>[iI][fF][lL][uU][sS][hH] return IFLUSH; | |
298 | <KEYWORD>[fF][lL][uU][sS][hH][iI][nN][vV] return FLUSHINV; | |
299 | <KEYWORD>[fF][lL][uU][sS][hH] return FLUSH; | |
fec82760 | 300 | ([0-9]+)|(0[xX][0-9a-fA-F]+)|([bhfodBHOFD]#[0-9a-fA-F]+)|(0"."[0-9]+) { |
07c1b327 CM |
301 | yylval.value = parse_int (&yytext); |
302 | return NUMBER; | |
303 | } | |
efda0242 | 304 | [[:alpha:]\x80-\xff_$.][[:alnum:]\x80-\xff_$.]* { |
07c1b327 CM |
305 | yylval.symbol = symbol_find_or_make (yytext); |
306 | symbol_mark_used (yylval.symbol); | |
ee9e7c78 | 307 | return SYMBOL; |
07c1b327 CM |
308 | } |
309 | [0-9][bfBF] { | |
310 | char *name; | |
311 | char *ref = strdup (yytext); | |
312 | if (ref[1] == 'b' || ref[1] == 'B') | |
313 | { | |
19f7966e | 314 | name = fb_label_name (ref[0] - '0', 0); |
07c1b327 CM |
315 | yylval.symbol = symbol_find (name); |
316 | ||
317 | if ((yylval.symbol != NULL) | |
318 | && (S_IS_DEFINED (yylval.symbol))) | |
319 | return SYMBOL; | |
ee9e7c78 MF |
320 | as_bad ("backward reference to unknown label %d:", |
321 | (int) (ref[0] - '0')); | |
07c1b327 CM |
322 | } |
323 | else if (ref[1] == 'f' || ref[1] == 'F') | |
324 | { | |
325 | /* Forward reference. Expect symbol to be undefined or | |
326 | unknown. undefined: seen it before. unknown: never seen | |
327 | it before. | |
328 | ||
329 | Construct a local label name, then an undefined symbol. | |
330 | Just return it as never seen before. */ | |
331 | ||
19f7966e | 332 | name = fb_label_name (ref[0] - '0', 1); |
07c1b327 CM |
333 | yylval.symbol = symbol_find_or_make (name); |
334 | /* We have no need to check symbol properties. */ | |
335 | return SYMBOL; | |
ee9e7c78 MF |
336 | } |
337 | } | |
07c1b327 CM |
338 | [ \t\n] ; |
339 | "/*".*"*/" ; | |
340 | . return yytext[0]; | |
341 | %% | |
342 | static long parse_int (char **end) | |
343 | { | |
344 | char fmt = '\0'; | |
345 | int not_done = 1; | |
346 | int shiftvalue = 0; | |
adb0bd8f | 347 | const char *char_bag; |
251150ad | 348 | unsigned long value = 0; |
07c1b327 CM |
349 | char *arg = *end; |
350 | ||
351 | while (*arg && *arg == ' ') | |
352 | arg++; | |
353 | ||
354 | switch (*arg) | |
355 | { | |
356 | case '1': | |
357 | case '2': | |
358 | case '3': | |
359 | case '4': | |
360 | case '5': | |
361 | case '6': | |
362 | case '7': | |
363 | case '8': | |
364 | case '9': | |
365 | fmt = 'd'; | |
366 | break; | |
367 | ||
8f02b5ad | 368 | case '0': /* Accept different formatted integers hex octal and binary. */ |
07c1b327 | 369 | { |
62fb9fe1 | 370 | char c = *++arg; |
07c1b327 CM |
371 | arg++; |
372 | if (c == 'x' || c == 'X') /* Hex input. */ | |
373 | fmt = 'h'; | |
374 | else if (c == 'b' || c == 'B') | |
375 | fmt = 'b'; | |
376 | else if (c == '.') | |
377 | fmt = 'f'; | |
378 | else | |
379 | { /* Octal. */ | |
380 | arg--; | |
381 | fmt = 'o'; | |
382 | } | |
383 | break; | |
384 | } | |
385 | ||
386 | case 'd': | |
387 | case 'D': | |
388 | case 'h': | |
389 | case 'H': | |
390 | case 'o': | |
391 | case 'O': | |
392 | case 'b': | |
393 | case 'B': | |
394 | case 'f': | |
395 | case 'F': | |
396 | { | |
397 | fmt = *arg++; | |
398 | if (*arg == '#') | |
399 | arg++; | |
400 | } | |
401 | } | |
402 | ||
403 | switch (fmt) | |
404 | { | |
405 | case 'h': | |
406 | case 'H': | |
407 | shiftvalue = 4; | |
408 | char_bag = "0123456789ABCDEFabcdef"; | |
409 | break; | |
410 | ||
411 | case 'o': | |
412 | case 'O': | |
413 | shiftvalue = 3; | |
414 | char_bag = "01234567"; | |
415 | break; | |
416 | ||
417 | case 'b': | |
418 | case 'B': | |
419 | shiftvalue = 1; | |
420 | char_bag = "01"; | |
421 | break; | |
422 | ||
423 | /* The assembler allows for fractional constants to be created | |
ee9e7c78 | 424 | by either the 0.xxxx or the f#xxxx format |
07c1b327 CM |
425 | |
426 | i.e. 0.5 would result in 0x4000 | |
427 | ||
428 | note .5 would result in the identifier .5. | |
429 | ||
430 | The assembler converts to fractional format 1.15 by the simple rule: | |
431 | ||
432 | value = (short) (finput * (1 << 15)). */ | |
433 | ||
434 | case 'f': | |
435 | case 'F': | |
436 | { | |
437 | float fval = 0.0; | |
438 | float pos = 10.0; | |
439 | while (1) | |
440 | { | |
441 | int c; | |
442 | c = *arg++; | |
443 | ||
444 | if (c >= '0' && c <= '9') | |
445 | { | |
446 | float digit = (c - '0') / pos; | |
447 | fval = fval + digit; | |
448 | pos = pos * 10.0; | |
449 | } | |
450 | else | |
451 | { | |
452 | *--arg = c; | |
453 | value = (short) (fval * (1 << 15)); | |
454 | break; | |
455 | } | |
456 | } | |
457 | *end = arg+1; | |
458 | return value; | |
459 | } | |
460 | ||
461 | case 'd': | |
462 | case 'D': | |
463 | default: | |
464 | { | |
465 | while (1) | |
466 | { | |
62fb9fe1 | 467 | char c; |
07c1b327 CM |
468 | c = *arg++; |
469 | if (c >= '0' && c <= '9') | |
470 | value = (value * 10) + (c - '0'); | |
471 | else | |
472 | { | |
473 | /* Constants that are suffixed with k|K are multiplied by 1024 | |
474 | This suffix is only allowed on decimal constants. */ | |
475 | if (c == 'k' || c == 'K') | |
476 | value *= 1024; | |
477 | else | |
478 | *--arg = c; | |
479 | break; | |
480 | } | |
481 | } | |
482 | *end = arg+1; | |
483 | return value; | |
484 | } | |
485 | } | |
486 | ||
487 | while (not_done) | |
488 | { | |
489 | char c; | |
490 | c = *arg++; | |
048e5b80 | 491 | if (c == 0 || !strchr (char_bag, c)) |
07c1b327 CM |
492 | { |
493 | not_done = 0; | |
494 | *--arg = c; | |
495 | } | |
496 | else | |
497 | { | |
498 | if (c >= 'a' && c <= 'z') | |
499 | c = c - ('a' - '9') + 1; | |
500 | else if (c >= 'A' && c <= 'Z') | |
501 | c = c - ('A' - '9') + 1; | |
502 | ||
503 | c -= '0'; | |
504 | value = (value << shiftvalue) + c; | |
505 | } | |
506 | } | |
507 | *end = arg+1; | |
508 | return value; | |
509 | } | |
510 | ||
511 | ||
512 | static int parse_reg (Register *r, int cl, char *rt) | |
513 | { | |
514 | r->regno = cl | (rt[1] - '0'); | |
f31bf2c6 | 515 | r->flags = F_REG_NONE; |
07c1b327 CM |
516 | return REG; |
517 | } | |
518 | ||
519 | static int parse_halfreg (Register *r, int cl, char *rt) | |
520 | { | |
521 | r->regno = cl | (rt[1] - '0'); | |
522 | ||
523 | switch (rt[3]) | |
524 | { | |
525 | case 'b': | |
526 | case 'B': | |
527 | return BYTE_DREG; | |
528 | ||
529 | case 'l': | |
530 | case 'L': | |
f31bf2c6 | 531 | r->flags = F_REG_LOW; |
07c1b327 CM |
532 | break; |
533 | ||
534 | case 'h': | |
535 | case 'H': | |
f31bf2c6 | 536 | r->flags = F_REG_HIGH; |
07c1b327 CM |
537 | break; |
538 | } | |
539 | ||
540 | return HALF_REG; | |
541 | } | |
542 | ||
543 | /* Our start state is KEYWORD as we have | |
544 | command keywords such as PREFETCH. */ | |
545 | ||
ee9e7c78 | 546 | void |
07c1b327 CM |
547 | set_start_state (void) |
548 | { | |
549 | BEGIN KEYWORD; | |
550 | } |