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 66static char string_buf[MAX_STR_CONST]; 67static char *string_buf_ptr; 68static int parren_count; 69static int quote_count; 70static char buf[255]; 71%} 72 73PATH ([/]*[-A-Za-z0-9_.])+ 74WORD [A-Za-z_][-A-Za-z_0-9]* 75SPACE [ \t]+ 76MCARG [^(), \t]+ 77MBODY ((\\[^\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; } 98if[ \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 } 135else { return T_ELSE; } 136VERSION { return T_VERSION; } 137PREFIX { return T_PREFIX; } 138PATCH_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 */ 160export { return T_EXPORT; } 161register { return T_REGISTER; } 162const { yylval.value = FALSE; return T_CONST; } 163download { return T_DOWNLOAD; } 164address { return T_ADDRESS; } 165count { return T_COUNT; } 166access_mode { return T_ACCESS_MODE; } 167dont_generate_debug_code { return T_DONT_GENERATE_DEBUG_CODE; } 168modes { return T_MODES; } 169RW|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 } 178field { return T_FIELD; } 179enum { return T_ENUM; } 180mask { return T_MASK; } 181alias { return T_ALIAS; } 182size { return T_SIZE; } 183scb { return T_SCB; } 184scratch_ram { return T_SRAM; } 185accumulator { return T_ACCUM; } 186mode_pointer { return T_MODE_PTR; } 187allones { return T_ALLONES; } 188allzeros { return T_ALLZEROS; } 189none { return T_NONE; } 190sindex { return T_SINDEX; } 191A { return T_A; } 192 193 /* Instruction Formatting */ 194PAD_PAGE { return T_PAD_PAGE; } 195BEGIN_CRITICAL { return T_BEGIN_CS; } 196END_CRITICAL { return T_END_CS; } 197SET_SRC_MODE { return T_SET_SRC_MODE; } 198SET_DST_MODE { return T_SET_DST_MODE; } 199 200 /* Opcodes */ 201shl { return T_SHL; } 202shr { return T_SHR; } 203ror { return T_ROR; } 204rol { return T_ROL; } 205mvi { return T_MVI; } 206mov { return T_MOV; } 207clr { return T_CLR; } 208jmp { return T_JMP; } 209jc { return T_JC; } 210jnc { return T_JNC; } 211je { return T_JE; } 212jne { return T_JNE; } 213jz { return T_JZ; } 214jnz { return T_JNZ; } 215call { return T_CALL; } 216add { return T_ADD; } 217adc { return T_ADC; } 218bmov { return T_BMOV; } 219inc { return T_INC; } 220dec { return T_DEC; } 221stc { return T_STC; } 222clc { return T_CLC; } 223cmp { return T_CMP; } 224not { return T_NOT; } 225xor { return T_XOR; } 226test { return T_TEST;} 227and { return T_AND; } 228or { return T_OR; } 229ret { return T_RET; } 230nop { 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 */ 2490[0-7]* { 250 yylval.value = strtol(yytext, NULL, 8); 251 return T_NUMBER; 252 } 253 2540[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 454typedef struct include { 455 YY_BUFFER_STATE buffer; 456 int lineno; 457 char *filename; 458 SLIST_ENTRY(include) links; 459}include_t; 460 461SLIST_HEAD(, include) include_stack; 462 463void 464include_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 516static 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 520void 521expand_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, ¯o_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 */ 574static void 575next_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 602int 603yywrap() 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} 623