blob: 93c8667cd704dd0af10d85a32e2806422ccecfce [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001%{
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 *
Hannes Reinecke2628ed22006-01-24 10:41:45 +010041 * $Id: //depot/aic7xxx/aic7xxx/aicasm/aicasm_scan.l#20 $
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 *
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 }
Hannes Reinecke2628ed22006-01-24 10:41:45 +0100135else { return T_ELSE; }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136VERSION { 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; }
Hannes Reinecke3dbd10f2008-04-25 15:01:41 +0200165count { return T_COUNT; }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166access_mode { return T_ACCESS_MODE; }
Denys Vlasenkofa25b992008-09-22 14:56:40 -0700167dont_generate_debug_code { return T_DONT_GENERATE_DEBUG_CODE; }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168modes { 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178field { 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
Hannes Reinecke2628ed22006-01-24 10:41:45 +0100193 /* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 /* 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; }
Hannes Reinecke2628ed22006-01-24 10:41:45 +0100231
232 /* ARP2 16bit extensions */
Hannes Reinecke2b48aed2008-04-23 11:39:49 +0200233 /* 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; }*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
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, &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 */
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}