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, &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}
623