gas/config/bfin-lex.l

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