drivers/scsi/aic7xxx/aicasm/aicasm_scan.l

   1 %{
   2 /*
   3  * Lexical Analyzer for the Aic7xxx SCSI Host adapter sequencer assembler.
   4  *
   5  * Copyright (c) 1997, 1998, 2000 Justin T. Gibbs.
   6  * Copyright (c) 2001, 2002 Adaptec Inc.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions, and the following disclaimer,
  14  *    without modification.
  15  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  16  *    substantially similar to the "NO WARRANTY" disclaimer below
  17  *    ("Disclaimer") and any redistribution must be conditioned upon
  18  *    including a substantially similar Disclaimer requirement for further
  19  *    binary redistribution.
  20  * 3. Neither the names of the above-listed copyright holders nor the names
  21  *    of any contributors may be used to endorse or promote products derived
  22  *    from this software without specific prior written permission.
  23  *
  24  * Alternatively, this software may be distributed under the terms of the
  25  * GNU General Public License ("GPL") version 2 as published by the Free
  26  * Software Foundation.
  27  *
  28  * NO WARRANTY
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  30  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  31  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  32  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  33  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  37  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  38  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  39  * POSSIBILITY OF SUCH DAMAGES.
  40  *
  41  * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm_scan.l#20 $
  42  *
  43  * $FreeBSD$
  44  */
  45
  46 #include <sys/types.h>
  47
  48 #include <inttypes.h>
  49 #include <limits.h>
  50 #include <regex.h>
  51 #include <stdio.h>
  52 #include <string.h>
  53 #include <sysexits.h>
  54 #ifdef __linux__
  55 #include "../queue.h"
  56 #else
  57 #include <sys/queue.h>
  58 #endif
  59
  60 #include "aicasm.h"
  61 #include "aicasm_symbol.h"
  62 #include "aicasm_gram.h"
  63
  64 /* This is used for macro body capture too, so err on the large size. */
  65 #define MAX_STR_CONST 4096
  66 static char string_buf[MAX_STR_CONST];
  67 static char *string_buf_ptr;
  68 static int  parren_count;
  69 static int  quote_count;
  70 static char buf[255];
  71 %}
  72
  73 PATH            ([/]*[-A-Za-z0-9_.])+
  74 WORD            [A-Za-z_][-A-Za-z_0-9]*
  75 SPACE           [ \t]+
  76 MCARG           [^(), \t]+
  77 MBODY           ((\\[^\n])*[^\n\\]*)+
  78
  79 %x COMMENT
  80 %x CEXPR
  81 %x INCLUDE
  82 %x STRING
  83 %x MACRODEF
  84 %x MACROARGLIST
  85 %x MACROCALLARGS
  86 %x MACROBODY
  87
  88 %%
  89 \n                      { ++yylineno; }
  90 \r                      ;
  91 "/*"                    { BEGIN COMMENT;  /* Enter comment eating state */ }
  92 <COMMENT>"/*"           { fprintf(stderr, "Warning! Comment within comment."); }
  93 <COMMENT>\n             { ++yylineno; }
  94 <COMMENT>[^*/\n]*       ;
  95 <COMMENT>"*"+[^*/\n]*   ;
  96 <COMMENT>"/"+[^*/\n]*   ;
  97 <COMMENT>"*"+"/"        { BEGIN INITIAL; }
  98 if[ \t]*\(              {
  99                                 string_buf_ptr = string_buf;
 100                                 parren_count = 1;
 101                                 BEGIN CEXPR;
 102                                 return T_IF;
 103                         }
 104 <CEXPR>\(               {       *string_buf_ptr++ = '('; parren_count++; }
 105 <CEXPR>\)               {
 106                                 parren_count--;
 107                                 if (parren_count == 0) {
 108                                         /* All done */
 109                                         BEGIN INITIAL;
 110                                         *string_buf_ptr = '\0';
 111                                         yylval.sym = symtable_get(string_buf);
 112                                         return T_CEXPR;
 113                                 } else {
 114                                         *string_buf_ptr++ = ')';
 115                                 }
 116                         }
 117 <CEXPR>\n               { ++yylineno; }
 118 <CEXPR>\r               ;
 119 <CEXPR>[^()\n]+ {
 120                                 char *yptr;
 121
 122                                 yptr = yytext;
 123                                 while (*yptr != '\0') {
 124                                         /* Remove duplicate spaces */
 125                                         if (*yptr == '\t')
 126                                                 *yptr = ' ';
 127                                         if (*yptr == ' '
 128                                          && string_buf_ptr != string_buf
 129                                          && string_buf_ptr[-1] == ' ')
 130                                                 yptr++;
 131                                         else
 132                                                 *string_buf_ptr++ = *yptr++;
 133                                 }
 134                         }
 135 else                    { return T_ELSE; }
 136 VERSION                 { return T_VERSION; }
 137 PREFIX                  { return T_PREFIX; }
 138 PATCH_ARG_LIST          { return T_PATCH_ARG_LIST; }
 139 \"                      {
 140                                 string_buf_ptr = string_buf;
 141                                 BEGIN STRING;
 142                         }
 143 <STRING>[^"]+           {
 144                                 char *yptr;
 145
 146                                 yptr = yytext;
 147                                 while (*yptr)
 148                                         *string_buf_ptr++ = *yptr++;
 149                         }
 150 <STRING>\"              {
 151                                 /* All done */
 152                                 BEGIN INITIAL;
 153                                 *string_buf_ptr = '\0';
 154                                 yylval.str = string_buf;
 155                                 return T_STRING;
 156                         }
 157 {SPACE}                  ;
 158
 159         /* Register/SCB/SRAM definition keywords */
 160 export                  { return T_EXPORT; }
 161 register                { return T_REGISTER; }
 162 const                   { yylval.value = FALSE; return T_CONST; }
 163 download                { return T_DOWNLOAD; }
 164 address                 { return T_ADDRESS; }
 165 count                   { return T_COUNT; }
 166 access_mode             { return T_ACCESS_MODE; }
 167 dont_generate_debug_code { return T_DONT_GENERATE_DEBUG_CODE; }
 168 modes                   { return T_MODES; }
 169 RW|RO|WO                {
 170                                  if (strcmp(yytext, "RW") == 0)
 171                                         yylval.value = RW;
 172                                  else if (strcmp(yytext, "RO") == 0)
 173                                         yylval.value = RO;
 174                                  else
 175                                         yylval.value = WO;
 176                                  return T_MODE;
 177                         }
 178 field                   { return T_FIELD; }
 179 enum                    { return T_ENUM; }
 180 mask                    { return T_MASK; }
 181 alias                   { return T_ALIAS; }
 182 size                    { return T_SIZE; }
 183 scb                     { return T_SCB; }
 184 scratch_ram             { return T_SRAM; }
 185 accumulator             { return T_ACCUM; }
 186 mode_pointer            { return T_MODE_PTR; }
 187 allones                 { return T_ALLONES; }
 188 allzeros                { return T_ALLZEROS; }
 189 none                    { return T_NONE; }
 190 sindex                  { return T_SINDEX; }
 191 A                       { return T_A; }
 192
 193         /* Instruction Formatting */
 194 PAD_PAGE                { return T_PAD_PAGE; }
 195 BEGIN_CRITICAL          { return T_BEGIN_CS; }
 196 END_CRITICAL            { return T_END_CS; }
 197 SET_SRC_MODE            { return T_SET_SRC_MODE; }
 198 SET_DST_MODE            { return T_SET_DST_MODE; }
 199
 200         /* Opcodes */
 201 shl                     { return T_SHL; }
 202 shr                     { return T_SHR; }
 203 ror                     { return T_ROR; }
 204 rol                     { return T_ROL; }
 205 mvi                     { return T_MVI; }
 206 mov                     { return T_MOV; }
 207 clr                     { return T_CLR; }
 208 jmp                     { return T_JMP; }
 209 jc                      { return T_JC;  }
 210 jnc                     { return T_JNC; }
 211 je                      { return T_JE;  }
 212 jne                     { return T_JNE; }
 213 jz                      { return T_JZ;  }
 214 jnz                     { return T_JNZ; }
 215 call                    { return T_CALL; }
 216 add                     { return T_ADD; }
 217 adc                     { return T_ADC; }
 218 bmov                    { return T_BMOV; }
 219 inc                     { return T_INC; }
 220 dec                     { return T_DEC; }
 221 stc                     { return T_STC; }
 222 clc                     { return T_CLC; }
 223 cmp                     { return T_CMP; }
 224 not                     { return T_NOT; }
 225 xor                     { return T_XOR; }
 226 test                    { return T_TEST;}
 227 and                     { return T_AND; }
 228 or                      { return T_OR;  }
 229 ret                     { return T_RET; }
 230 nop                     { return T_NOP; }
 231
 232         /* ARP2 16bit extensions */
 233         /* or16                 { return T_OR16; } */
 234         /* and16                        { return T_AND16; }*/
 235         /* xor16                        { return T_XOR16; }*/
 236         /* add16                        { return T_ADD16; }*/
 237         /* adc16                        { return T_ADC16; }*/
 238         /* mvi16                        { return T_MVI16; }*/
 239         /* test16                       { return T_TEST16; }*/
 240         /* cmp16                        { return T_CMP16; }*/
 241         /* cmpxchg                      { return T_CMPXCHG; }*/
 242
 243         /* Allowed Symbols */
 244 \<\<                    { return T_EXPR_LSHIFT; }
 245 \>\>                    { return T_EXPR_RSHIFT; }
 246 [-+,:()~|&."{};<>[\]/*!=] { return yytext[0]; }
 247
 248         /* Number processing */
 249 0[0-7]*                 {
 250                                 yylval.value = strtol(yytext, NULL, 8);
 251                                 return T_NUMBER;
 252                         }
 253
 254 0[xX][0-9a-fA-F]+       {
 255                                 yylval.value = strtoul(yytext + 2, NULL, 16);
 256                                 return T_NUMBER;
 257                         }
 258
 259 [1-9][0-9]*             {
 260                                 yylval.value = strtol(yytext, NULL, 10);
 261                                 return T_NUMBER;
 262                         }
 263         /* Include Files */
 264 #include{SPACE}         {
 265                                 BEGIN INCLUDE;
 266                                 quote_count = 0;
 267                                 return T_INCLUDE;
 268                         }
 269 <INCLUDE>[<]            { return yytext[0]; }
 270 <INCLUDE>[>]            { BEGIN INITIAL; return yytext[0]; }
 271 <INCLUDE>[\"]           {
 272                                 if (quote_count != 0)
 273                                         BEGIN INITIAL;
 274                                 quote_count++;
 275                                 return yytext[0];
 276                         }
 277 <INCLUDE>{PATH}         {
 278                                 char *yptr;
 279
 280                                 yptr = yytext;
 281                                 string_buf_ptr = string_buf;
 282                                 while (*yptr)
 283                                         *string_buf_ptr++ = *yptr++;
 284                                 yylval.str = string_buf;
 285                                 *string_buf_ptr = '\0';
 286                                 return T_PATH;
 287                         }
 288 <INCLUDE>.              { stop("Invalid include line", EX_DATAERR); }
 289 #define{SPACE}          {
 290                                 BEGIN MACRODEF;
 291                                 return T_DEFINE;
 292                         }
 293 <MACRODEF>{WORD}{SPACE} {
 294                                 char *yptr;
 295
 296                                 /* Strip space and return as a normal symbol */
 297                                 yptr = yytext;
 298                                 while (*yptr != ' ' && *yptr != '\t')
 299                                         yptr++;
 300                                 *yptr = '\0';
 301                                 yylval.sym = symtable_get(yytext);
 302                                 string_buf_ptr = string_buf;
 303                                 BEGIN MACROBODY;
 304                                 return T_SYMBOL;
 305                         }
 306 <MACRODEF>{WORD}\(      {
 307                                 /*
 308                                  * We store the symbol with its opening
 309                                  * parren so we can differentiate macros
 310                                  * that take args from macros with the
 311                                  * same name that do not take args as
 312                                  * is allowed in C.
 313                                  */
 314                                 BEGIN MACROARGLIST;
 315                                 yylval.sym = symtable_get(yytext);
 316                                 unput('(');
 317                                 return T_SYMBOL;
 318                         }
 319 <MACROARGLIST>{WORD}    {
 320                                 yylval.str = yytext;
 321                                 return T_ARG;
 322                         }
 323 <MACROARGLIST>{SPACE}   ;
 324 <MACROARGLIST>[(,]      {
 325                                 return yytext[0];
 326                         }
 327 <MACROARGLIST>[)]       {
 328                                 string_buf_ptr = string_buf;
 329                                 BEGIN MACROBODY;
 330                                 return ')';
 331                         }
 332 <MACROARGLIST>.         {
 333                                 snprintf(buf, sizeof(buf), "Invalid character "
 334                                          "'%c' in macro argument list",
 335                                          yytext[0]);
 336                                 stop(buf, EX_DATAERR);
 337                         }
 338 <MACROCALLARGS>{SPACE}  ;
 339 <MACROCALLARGS>\(       {
 340                                 parren_count++;
 341                                 if (parren_count == 1)
 342                                         return ('(');
 343                                 *string_buf_ptr++ = '(';
 344                         }
 345 <MACROCALLARGS>\)       {
 346                                 parren_count--;
 347                                 if (parren_count == 0) {
 348                                         BEGIN INITIAL;
 349                                         return (')');
 350                                 }
 351                                 *string_buf_ptr++ = ')';
 352                         }
 353 <MACROCALLARGS>{MCARG}  {
 354                                 char *yptr;
 355
 356                                 yptr = yytext;
 357                                 while (*yptr)
 358                                         *string_buf_ptr++ = *yptr++;
 359                         }
 360 <MACROCALLARGS>\,       {
 361                                 if (string_buf_ptr != string_buf) {
 362                                         /*
 363                                          * Return an argument and
 364                                          * rescan this comma so we
 365                                          * can return it as well.
 366                                          */
 367                                         *string_buf_ptr = '\0';
 368                                         yylval.str = string_buf;
 369                                         string_buf_ptr = string_buf;
 370                                         unput(',');
 371                                         return T_ARG;
 372                                 }
 373                                 return ',';
 374                         }
 375 <MACROBODY>\\\n         {
 376                                 /* Eat escaped newlines. */
 377                                 ++yylineno;
 378                         }
 379 <MACROBODY>\r           ;
 380 <MACROBODY>\n           {
 381                                 /* Macros end on the first unescaped newline. */
 382                                 BEGIN INITIAL;
 383                                 *string_buf_ptr = '\0';
 384                                 yylval.str = string_buf;
 385                                 ++yylineno;
 386                                 return T_MACROBODY;
 387                         }
 388 <MACROBODY>{MBODY}      {
 389                                 char *yptr;
 390                                 char c;
 391
 392                                 yptr = yytext;
 393                                 while (c = *yptr++) {
 394                                         /*
 395                                          * Strip carriage returns.
 396                                          */
 397                                         if (c == '\r')
 398                                                 continue;
 399                                         *string_buf_ptr++ = c;
 400                                 }
 401                         }
 402 {WORD}\(                {
 403                                 char *yptr;
 404                                 char *ycopy;
 405
 406                                 /* May be a symbol or a macro invocation. */
 407                                 yylval.sym = symtable_get(yytext);
 408                                 if (yylval.sym->type == MACRO) {
 409                                         YY_BUFFER_STATE old_state;
 410                                         YY_BUFFER_STATE temp_state;
 411
 412                                         ycopy = strdup(yytext);
 413                                         yptr = ycopy + yyleng;
 414                                         while (yptr > ycopy)
 415                                                 unput(*--yptr);
 416                                         old_state = YY_CURRENT_BUFFER;
 417                                         temp_state =
 418                                             yy_create_buffer(stdin,
 419                                                              YY_BUF_SIZE);
 420                                         yy_switch_to_buffer(temp_state);
 421                                         mm_switch_to_buffer(old_state);
 422                                         mmparse();
 423                                         mm_switch_to_buffer(temp_state);
 424                                         yy_switch_to_buffer(old_state);
 425                                         mm_delete_buffer(temp_state);
 426                                         expand_macro(yylval.sym);
 427                                 } else {
 428                                         if (yylval.sym->type == UNINITIALIZED) {
 429                                                 /* Try without the '(' */
 430                                                 symbol_delete(yylval.sym);
 431                                                 yytext[yyleng-1] = '\0';
 432                                                 yylval.sym =
 433                                                     symtable_get(yytext);
 434                                         }
 435                                         unput('(');
 436                                         return T_SYMBOL;
 437                                 }
 438                         }
 439 {WORD}                  {
 440                                 yylval.sym = symtable_get(yytext);
 441                                 if (yylval.sym->type == MACRO) {
 442                                         expand_macro(yylval.sym);
 443                                 } else {
 444                                         return T_SYMBOL;
 445                                 }
 446                         }
 447 .                       {
 448                                 snprintf(buf, sizeof(buf), "Invalid character "
 449                                          "'%c'", yytext[0]);
 450                                 stop(buf, EX_DATAERR);
 451                         }
 452 %%
 453
 454 typedef struct include {
 455         YY_BUFFER_STATE  buffer;
 456         int              lineno;
 457         char            *filename;
 458         SLIST_ENTRY(include) links;
 459 }include_t;
 460
 461 SLIST_HEAD(, include) include_stack;
 462
 463 void
 464 include_file(char *file_name, include_type type)
 465 {
 466         FILE *newfile;
 467         include_t *include;
 468
 469         newfile = NULL;
 470         /* Try the current directory first */
 471         if (includes_search_curdir != 0 || type == SOURCE_FILE)
 472                 newfile = fopen(file_name, "r");
 473
 474         if (newfile == NULL && type != SOURCE_FILE) {
 475                 path_entry_t include_dir;
 476                 for (include_dir = search_path.slh_first;
 477                      include_dir != NULL;
 478                      include_dir = include_dir->links.sle_next) {
 479                         char fullname[PATH_MAX];
 480
 481                         if ((include_dir->quoted_includes_only == TRUE)
 482                          && (type != QUOTED_INCLUDE))
 483                                 continue;
 484
 485                         snprintf(fullname, sizeof(fullname),
 486                                  "%s/%s", include_dir->directory, file_name);
 487
 488                         if ((newfile = fopen(fullname, "r")) != NULL)
 489                                 break;
 490                 }
 491         }
 492
 493         if (newfile == NULL) {
 494                 perror(file_name);
 495                 stop("Unable to open input file", EX_SOFTWARE);
 496                 /* NOTREACHED */
 497         }
 498
 499         if (type != SOURCE_FILE) {
 500                 include = (include_t *)malloc(sizeof(include_t));
 501                 if (include == NULL) {
 502                         stop("Unable to allocate include stack entry",
 503                              EX_SOFTWARE);
 504                         /* NOTREACHED */
 505                 }
 506                 include->buffer = YY_CURRENT_BUFFER;
 507                 include->lineno = yylineno;
 508                 include->filename = yyfilename;
 509                 SLIST_INSERT_HEAD(&include_stack, include, links);
 510         }
 511         yy_switch_to_buffer(yy_create_buffer(newfile, YY_BUF_SIZE));
 512         yylineno = 1;
 513         yyfilename = strdup(file_name);
 514 }
 515
 516 static void next_substitution(struct symbol *mac_symbol, const char *body_pos,
 517                               const char **next_match,
 518                               struct macro_arg **match_marg, regmatch_t *match);
 519
 520 void
 521 expand_macro(struct symbol *macro_symbol)
 522 {
 523         struct macro_arg *marg;
 524         struct macro_arg *match_marg;
 525         const char *body_head;
 526         const char *body_pos;
 527         const char *next_match;
 528
 529         /*
 530          * Due to the nature of unput, we must work
 531          * backwards through the macro body performing
 532          * any expansions.
 533          */
 534         body_head = macro_symbol->info.macroinfo->body;
 535         body_pos = body_head + strlen(body_head);
 536         while (body_pos > body_head) {
 537                 regmatch_t match;
 538
 539                 next_match = body_head;
 540                 match_marg = NULL;
 541                 next_substitution(macro_symbol, body_pos, &next_match,
 542                                   &match_marg, &match);
 543
 544                 /* Put back everything up until the replacement. */
 545                 while (body_pos > next_match)
 546                         unput(*--body_pos);
 547
 548                 /* Perform the replacement. */
 549                 if (match_marg != NULL) {
 550                         const char *strp;
 551
 552                         next_match = match_marg->replacement_text;
 553                         strp = next_match + strlen(next_match);
 554                         while (strp > next_match)
 555                                 unput(*--strp);
 556
 557                         /* Skip past the unexpanded macro arg. */
 558                         body_pos -= match.rm_eo - match.rm_so;
 559                 }
 560         }
 561
 562         /* Cleanup replacement text. */
 563         STAILQ_FOREACH(marg, &macro_symbol->info.macroinfo->args, links) {
 564                 free(marg->replacement_text);
 565         }
 566 }
 567
 568 /*
 569  * Find the next substitution in the macro working backwards from
 570  * body_pos until the beginning of the macro buffer.  next_match
 571  * should be initialized to the beginning of the macro buffer prior
 572  * to calling this routine.
 573  */
 574 static void
 575 next_substitution(struct symbol *mac_symbol, const char *body_pos,
 576                   const char **next_match, struct macro_arg **match_marg,
 577                   regmatch_t *match)
 578 {
 579         regmatch_t        matches[2];
 580         struct macro_arg *marg;
 581         const char       *search_pos;
 582         int               retval;
 583
 584         do {
 585                 search_pos = *next_match;
 586
 587                 STAILQ_FOREACH(marg, &mac_symbol->info.macroinfo->args, links) {
 588
 589                         retval = regexec(&marg->arg_regex, search_pos, 2,
 590                                          matches, 0);
 591                         if (retval == 0
 592                          && (matches[1].rm_eo + search_pos) <= body_pos
 593                          && (matches[1].rm_eo + search_pos) > *next_match) {
 594                                 *match = matches[1];
 595                                 *next_match = match->rm_eo + search_pos;
 596                                 *match_marg = marg;
 597                         }
 598                 }
 599         } while (search_pos != *next_match);
 600 }
 601
 602 int
 603 yywrap()
 604 {
 605         include_t *include;
 606
 607         yy_delete_buffer(YY_CURRENT_BUFFER);
 608         (void)fclose(yyin);
 609         if (yyfilename != NULL)
 610                 free(yyfilename);
 611         yyfilename = NULL;
 612         include = include_stack.slh_first;
 613         if (include != NULL) {
 614                 yy_switch_to_buffer(include->buffer);
 615                 yylineno = include->lineno;
 616                 yyfilename = include->filename;
 617                 SLIST_REMOVE_HEAD(&include_stack, links);
 618                 free(include);
 619                 return (0);
 620         }
 621         return (1);
 622 }