gas/config/bfin-lex.l

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