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