PageRenderTime 51ms CodeModel.GetById 16ms app.highlight 17ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/scsi/aic7xxx/aicasm/aicasm_gram.y

http://github.com/mirrors/linux
Happy | 2000 lines | 1779 code | 221 blank | 0 comment | 0 complexity | c6a8a0451b006739159fb5989fca396f MD5 | raw file
   1%{
   2/*
   3 * Parser 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_gram.y#30 $
  42 *
  43 * $FreeBSD$
  44 */
  45
  46#include <sys/types.h>
  47
  48#include <inttypes.h>
  49#include <regex.h>
  50#include <stdio.h>
  51#include <stdlib.h>
  52#include <string.h>
  53#include <sysexits.h>
  54
  55#include "../queue.h"
  56
  57#include "aicasm.h"
  58#include "aicasm_symbol.h"
  59#include "aicasm_insformat.h"
  60
  61int yylineno;
  62char *yyfilename;
  63char stock_prefix[] = "aic_";
  64char *prefix = stock_prefix;
  65char *patch_arg_list;
  66char *versions;
  67static char errbuf[255];
  68static char regex_pattern[255];
  69static symbol_t *cur_symbol;
  70static symbol_t *field_symbol;
  71static symbol_t *scb_or_sram_symbol;
  72static symtype cur_symtype;
  73static symbol_ref_t accumulator;
  74static symbol_ref_t mode_ptr;
  75static symbol_ref_t allones;
  76static symbol_ref_t allzeros;
  77static symbol_ref_t none;
  78static symbol_ref_t sindex;
  79static int instruction_ptr;
  80static int num_srams;
  81static int sram_or_scb_offset;
  82static int download_constant_count;
  83static int in_critical_section;
  84static u_int enum_increment;
  85static u_int enum_next_value;
  86
  87static void process_field(int field_type, symbol_t *sym, int mask);
  88static void initialize_symbol(symbol_t *symbol);
  89static void add_macro_arg(const char *argtext, int position);
  90static void add_macro_body(const char *bodytext);
  91static void process_register(symbol_t **p_symbol);
  92static void format_1_instr(int opcode, symbol_ref_t *dest,
  93			   expression_t *immed, symbol_ref_t *src, int ret);
  94static void format_2_instr(int opcode, symbol_ref_t *dest,
  95			   expression_t *places, symbol_ref_t *src, int ret);
  96static void format_3_instr(int opcode, symbol_ref_t *src,
  97			   expression_t *immed, symbol_ref_t *address);
  98static void test_readable_symbol(symbol_t *symbol);
  99static void test_writable_symbol(symbol_t *symbol);
 100static void type_check(symbol_ref_t *sym, expression_t *expression, int and_op);
 101static void make_expression(expression_t *immed, int value);
 102static void add_conditional(symbol_t *symbol);
 103static void add_version(const char *verstring);
 104static int  is_download_const(expression_t *immed);
 105static int  is_location_address(symbol_t *symbol);
 106void yyerror(const char *string);
 107
 108#define SRAM_SYMNAME "SRAM_BASE"
 109#define SCB_SYMNAME "SCB_BASE"
 110%}
 111
 112%union {
 113	u_int		value;
 114	char		*str;
 115	symbol_t	*sym;
 116	symbol_ref_t	sym_ref;
 117	expression_t	expression;
 118}
 119
 120%token T_REGISTER
 121
 122%token <value> T_CONST
 123
 124%token T_EXPORT
 125
 126%token T_DOWNLOAD
 127
 128%token T_SCB
 129
 130%token T_SRAM
 131
 132%token T_ALIAS
 133
 134%token T_SIZE
 135
 136%token T_EXPR_LSHIFT
 137
 138%token T_EXPR_RSHIFT
 139
 140%token <value> T_ADDRESS
 141
 142%token T_COUNT
 143
 144%token T_ACCESS_MODE
 145
 146%token T_DONT_GENERATE_DEBUG_CODE
 147
 148%token T_MODES
 149
 150%token T_DEFINE
 151
 152%token T_SET_SRC_MODE
 153
 154%token T_SET_DST_MODE
 155
 156%token <value> T_MODE
 157
 158%token T_BEGIN_CS
 159
 160%token T_END_CS
 161
 162%token T_PAD_PAGE
 163
 164%token T_FIELD
 165
 166%token T_ENUM
 167
 168%token T_MASK
 169
 170%token <value> T_NUMBER
 171
 172%token <str> T_PATH T_STRING T_ARG T_MACROBODY
 173
 174%token <sym> T_CEXPR
 175
 176%token T_EOF T_INCLUDE T_VERSION T_PREFIX T_PATCH_ARG_LIST
 177
 178%token <value> T_SHR T_SHL T_ROR T_ROL
 179
 180%token <value> T_MVI T_MOV T_CLR T_BMOV
 181
 182%token <value> T_JMP T_JC T_JNC T_JE T_JNE T_JNZ T_JZ T_CALL
 183
 184%token <value> T_ADD T_ADC
 185
 186%token <value> T_INC T_DEC
 187
 188%token <value> T_STC T_CLC
 189
 190%token <value> T_CMP T_NOT T_XOR
 191
 192%token <value> T_TEST T_AND
 193
 194%token <value> T_OR
 195
 196/* 16 bit extensions, not implemented
 197 * %token <value> T_OR16 T_AND16 T_XOR16 T_ADD16
 198 * %token <value> T_ADC16 T_MVI16 T_TEST16 T_CMP16 T_CMPXCHG
 199 */
 200%token T_RET
 201
 202%token T_NOP
 203
 204%token T_ACCUM T_ALLONES T_ALLZEROS T_NONE T_SINDEX T_MODE_PTR
 205
 206%token T_A
 207
 208%token <sym> T_SYMBOL
 209
 210%token T_NL
 211
 212%token T_IF T_ELSE T_ELSE_IF T_ENDIF
 213
 214%type <sym_ref> reg_symbol address destination source opt_source
 215
 216%type <expression> expression immediate immediate_or_a
 217
 218%type <value> export ret f1_opcode f2_opcode jmp_jc_jnc_call jz_jnz je_jne
 219
 220%type <value> mode_value mode_list macro_arglist
 221
 222%left '|'
 223%left '&'
 224%left T_EXPR_LSHIFT T_EXPR_RSHIFT
 225%left '+' '-'
 226%left '*' '/'
 227%right '~'
 228%nonassoc UMINUS
 229%%
 230
 231program:
 232	include
 233|	program include
 234|	prefix
 235|	program prefix
 236|	patch_arg_list
 237|	program patch_arg_list
 238|	version
 239|	program version
 240|	register
 241|	program register
 242|	constant
 243|	program constant
 244|	macrodefn
 245|	program macrodefn
 246|	scratch_ram
 247|	program scratch_ram
 248|	scb
 249|	program scb
 250|	label
 251|	program label
 252|	set_src_mode
 253|	program set_src_mode
 254|	set_dst_mode
 255|	program set_dst_mode
 256|	critical_section_start
 257|	program critical_section_start
 258|	critical_section_end
 259|	program critical_section_end
 260|	conditional
 261|	program conditional
 262|	code
 263|	program code
 264;
 265
 266include:
 267	T_INCLUDE '<' T_PATH '>'
 268	{
 269		include_file($3, BRACKETED_INCLUDE);
 270	}
 271|	T_INCLUDE '"' T_PATH '"'
 272	{
 273		include_file($3, QUOTED_INCLUDE);
 274	}
 275;
 276
 277prefix:
 278	T_PREFIX '=' T_STRING
 279	{
 280		if (prefix != stock_prefix)
 281			stop("Prefix multiply defined",
 282			     EX_DATAERR);
 283		prefix = strdup($3);
 284		if (prefix == NULL)
 285			stop("Unable to record prefix", EX_SOFTWARE);
 286	}
 287;
 288
 289patch_arg_list:
 290	T_PATCH_ARG_LIST '=' T_STRING
 291	{
 292		if (patch_arg_list != NULL)
 293			stop("Patch argument list multiply defined",
 294			     EX_DATAERR);
 295		patch_arg_list = strdup($3);
 296		if (patch_arg_list == NULL)
 297			stop("Unable to record patch arg list", EX_SOFTWARE);
 298	}
 299;
 300
 301version:
 302	T_VERSION '=' T_STRING
 303	{ add_version($3); }
 304;
 305
 306register:
 307	T_REGISTER { cur_symtype = REGISTER; } reg_definition
 308;
 309
 310reg_definition:
 311	T_SYMBOL '{'
 312		{
 313			if ($1->type != UNINITIALIZED) {
 314				stop("Register multiply defined", EX_DATAERR);
 315				/* NOTREACHED */
 316			}
 317			cur_symbol = $1;
 318			cur_symbol->type = cur_symtype;
 319			initialize_symbol(cur_symbol);
 320		}
 321		reg_attribute_list
 322	'}'
 323		{
 324			/*
 325			 * Default to allowing everything in for registers
 326			 * with no bit or mask definitions.
 327			 */
 328			if (cur_symbol->info.rinfo->valid_bitmask == 0)
 329				cur_symbol->info.rinfo->valid_bitmask = 0xFF;
 330
 331			if (cur_symbol->info.rinfo->size == 0)
 332				cur_symbol->info.rinfo->size = 1;
 333
 334			/*
 335			 * This might be useful for registers too.
 336			 */
 337			if (cur_symbol->type != REGISTER) {
 338				if (cur_symbol->info.rinfo->address == 0)
 339					cur_symbol->info.rinfo->address =
 340					    sram_or_scb_offset;
 341				sram_or_scb_offset +=
 342				    cur_symbol->info.rinfo->size;
 343			}
 344			cur_symbol = NULL;
 345		}
 346;
 347
 348reg_attribute_list:
 349	reg_attribute
 350|	reg_attribute_list reg_attribute
 351;
 352
 353reg_attribute:
 354	reg_address
 355|	size
 356|	count
 357|	access_mode
 358|	dont_generate_debug_code
 359|	modes
 360|	field_defn
 361|	enum_defn
 362|	mask_defn
 363|	alias
 364|	accumulator
 365|	mode_pointer
 366|	allones
 367|	allzeros
 368|	none
 369|	sindex
 370;
 371
 372reg_address:
 373	T_ADDRESS T_NUMBER
 374	{
 375		cur_symbol->info.rinfo->address = $2;
 376	}
 377;
 378
 379size:
 380	T_SIZE T_NUMBER
 381	{
 382		cur_symbol->info.rinfo->size = $2;
 383		if (scb_or_sram_symbol != NULL) {
 384			u_int max_addr;
 385			u_int sym_max_addr;
 386
 387			max_addr = scb_or_sram_symbol->info.rinfo->address
 388				 + scb_or_sram_symbol->info.rinfo->size;
 389			sym_max_addr = cur_symbol->info.rinfo->address
 390				     + cur_symbol->info.rinfo->size;
 391
 392			if (sym_max_addr > max_addr)
 393				stop("SCB or SRAM space exhausted", EX_DATAERR);
 394		}
 395	}
 396;
 397
 398count:
 399	T_COUNT T_NUMBER
 400	{
 401		cur_symbol->count += $2;
 402	}
 403;
 404
 405access_mode:
 406	T_ACCESS_MODE T_MODE
 407	{
 408		cur_symbol->info.rinfo->mode = $2;
 409	}
 410;
 411
 412dont_generate_debug_code:
 413	T_DONT_GENERATE_DEBUG_CODE
 414	{
 415		cur_symbol->dont_generate_debug_code = 1;
 416	}
 417;
 418
 419modes:
 420	T_MODES mode_list
 421	{
 422		cur_symbol->info.rinfo->modes = $2;
 423	}
 424;
 425
 426mode_list:
 427	mode_value
 428	{
 429		$$ = $1;
 430	}
 431|	mode_list ',' mode_value
 432	{
 433		$$ = $1 | $3;
 434	}
 435;
 436
 437mode_value:
 438	T_NUMBER
 439	{
 440		if ($1 > 4) {
 441			stop("Valid register modes range between 0 and 4.",
 442			     EX_DATAERR);
 443			/* NOTREACHED */
 444		}
 445
 446		$$ = (0x1 << $1);
 447	}
 448|	T_SYMBOL
 449	{
 450		symbol_t *symbol;
 451
 452		symbol = $1;
 453		if (symbol->type != CONST) {
 454			stop("Only \"const\" symbols allowed in "
 455			     "mode definitions.", EX_DATAERR);
 456			/* NOTREACHED */
 457		}
 458		if (symbol->info.cinfo->value > 4) {
 459			stop("Valid register modes range between 0 and 4.",
 460			     EX_DATAERR);
 461			/* NOTREACHED */
 462		}
 463		$$ = (0x1 << symbol->info.cinfo->value);
 464	}
 465;
 466
 467field_defn:
 468	T_FIELD
 469		{
 470			field_symbol = NULL;
 471			enum_next_value = 0;
 472			enum_increment = 1;
 473		}
 474	'{' enum_entry_list '}'
 475|	T_FIELD T_SYMBOL expression
 476		{
 477			process_field(FIELD, $2, $3.value);
 478			field_symbol = $2;
 479			enum_next_value = 0;
 480			enum_increment = 0x01 << (ffs($3.value) - 1);
 481		}
 482	'{' enum_entry_list '}'
 483|	T_FIELD T_SYMBOL expression
 484	{
 485		process_field(FIELD, $2, $3.value);
 486	}
 487;
 488
 489enum_defn:
 490	T_ENUM
 491		{
 492			field_symbol = NULL;
 493			enum_next_value = 0;
 494			enum_increment = 1;
 495		}
 496	'{' enum_entry_list '}'
 497|	T_ENUM T_SYMBOL expression
 498		{
 499			process_field(ENUM, $2, $3.value);
 500			field_symbol = $2;
 501			enum_next_value = 0;
 502			enum_increment = 0x01 << (ffs($3.value) - 1);
 503		}
 504	'{' enum_entry_list '}'
 505;
 506
 507enum_entry_list:
 508	enum_entry
 509|	enum_entry_list ',' enum_entry
 510;
 511
 512enum_entry:
 513	T_SYMBOL
 514	{
 515		process_field(ENUM_ENTRY, $1, enum_next_value);
 516		enum_next_value += enum_increment;
 517	}
 518|	T_SYMBOL expression
 519	{
 520		process_field(ENUM_ENTRY, $1, $2.value);
 521		enum_next_value = $2.value + enum_increment;
 522	}
 523;
 524
 525mask_defn:
 526	T_MASK T_SYMBOL expression
 527	{
 528		process_field(MASK, $2, $3.value);
 529	}
 530;
 531
 532alias:
 533	T_ALIAS	T_SYMBOL
 534	{
 535		if ($2->type != UNINITIALIZED) {
 536			stop("Re-definition of register alias",
 537			     EX_DATAERR);
 538			/* NOTREACHED */
 539		}
 540		$2->type = ALIAS;
 541		initialize_symbol($2);
 542		$2->info.ainfo->parent = cur_symbol;
 543	}
 544;
 545
 546accumulator:
 547	T_ACCUM
 548	{
 549		if (accumulator.symbol != NULL) {
 550			stop("Only one accumulator definition allowed",
 551			     EX_DATAERR);
 552			/* NOTREACHED */
 553		}
 554		accumulator.symbol = cur_symbol;
 555	}
 556;
 557
 558mode_pointer:
 559	T_MODE_PTR
 560	{
 561		if (mode_ptr.symbol != NULL) {
 562			stop("Only one mode pointer definition allowed",
 563			     EX_DATAERR);
 564			/* NOTREACHED */
 565		}
 566		mode_ptr.symbol = cur_symbol;
 567	}
 568;
 569
 570allones:
 571	T_ALLONES
 572	{
 573		if (allones.symbol != NULL) {
 574			stop("Only one definition of allones allowed",
 575			     EX_DATAERR);
 576			/* NOTREACHED */
 577		}
 578		allones.symbol = cur_symbol;
 579	}
 580;
 581
 582allzeros:
 583	T_ALLZEROS
 584	{
 585		if (allzeros.symbol != NULL) {
 586			stop("Only one definition of allzeros allowed",
 587			     EX_DATAERR);
 588			/* NOTREACHED */
 589		}
 590		allzeros.symbol = cur_symbol;
 591	}
 592;
 593
 594none:
 595	T_NONE
 596	{
 597		if (none.symbol != NULL) {
 598			stop("Only one definition of none allowed",
 599			     EX_DATAERR);
 600			/* NOTREACHED */
 601		}
 602		none.symbol = cur_symbol;
 603	}
 604;
 605
 606sindex:
 607	T_SINDEX
 608	{
 609		if (sindex.symbol != NULL) {
 610			stop("Only one definition of sindex allowed",
 611			     EX_DATAERR);
 612			/* NOTREACHED */
 613		}
 614		sindex.symbol = cur_symbol;
 615	}
 616;
 617
 618expression:
 619	expression '|' expression
 620	{
 621		 $$.value = $1.value | $3.value;
 622		 symlist_merge(&$$.referenced_syms,
 623			       &$1.referenced_syms,
 624			       &$3.referenced_syms);
 625	}
 626|	expression '&' expression
 627	{
 628		$$.value = $1.value & $3.value;
 629		symlist_merge(&$$.referenced_syms,
 630			       &$1.referenced_syms,
 631			       &$3.referenced_syms);
 632	}
 633|	expression '+' expression
 634	{
 635		$$.value = $1.value + $3.value;
 636		symlist_merge(&$$.referenced_syms,
 637			       &$1.referenced_syms,
 638			       &$3.referenced_syms);
 639	}
 640|	expression '-' expression
 641	{
 642		$$.value = $1.value - $3.value;
 643		symlist_merge(&($$.referenced_syms),
 644			       &($1.referenced_syms),
 645			       &($3.referenced_syms));
 646	}
 647|	expression '*' expression
 648	{
 649		$$.value = $1.value * $3.value;
 650		symlist_merge(&($$.referenced_syms),
 651			       &($1.referenced_syms),
 652			       &($3.referenced_syms));
 653	}
 654|	expression '/' expression
 655	{
 656		$$.value = $1.value / $3.value;
 657		symlist_merge(&($$.referenced_syms),
 658			       &($1.referenced_syms),
 659			       &($3.referenced_syms));
 660	}
 661|	expression T_EXPR_LSHIFT expression
 662	{
 663		$$.value = $1.value << $3.value;
 664		symlist_merge(&$$.referenced_syms,
 665			       &$1.referenced_syms,
 666			       &$3.referenced_syms);
 667	}
 668|	expression T_EXPR_RSHIFT expression
 669	{
 670		$$.value = $1.value >> $3.value;
 671		symlist_merge(&$$.referenced_syms,
 672			       &$1.referenced_syms,
 673			       &$3.referenced_syms);
 674	}
 675|	'(' expression ')'
 676	{
 677		$$ = $2;
 678	}
 679|	'~' expression
 680	{
 681		$$ = $2;
 682		$$.value = (~$$.value) & 0xFF;
 683	}
 684|	'-' expression %prec UMINUS
 685	{
 686		$$ = $2;
 687		$$.value = -$$.value;
 688	}
 689|	T_NUMBER
 690	{
 691		$$.value = $1;
 692		SLIST_INIT(&$$.referenced_syms);
 693	}
 694|	T_SYMBOL
 695	{
 696		symbol_t *symbol;
 697
 698		symbol = $1;
 699		switch (symbol->type) {
 700		case ALIAS:
 701			symbol = $1->info.ainfo->parent;
 702		case REGISTER:
 703		case SCBLOC:
 704		case SRAMLOC:
 705			$$.value = symbol->info.rinfo->address;
 706			break;
 707		case MASK:
 708		case FIELD:
 709		case ENUM:
 710		case ENUM_ENTRY:
 711			$$.value = symbol->info.finfo->value;
 712			break;
 713		case DOWNLOAD_CONST:
 714		case CONST:
 715			$$.value = symbol->info.cinfo->value;
 716			break;
 717		case UNINITIALIZED:
 718		default:
 719		{
 720			snprintf(errbuf, sizeof(errbuf),
 721				 "Undefined symbol %s referenced",
 722				 symbol->name);
 723			stop(errbuf, EX_DATAERR);
 724			/* NOTREACHED */
 725			break;
 726		}
 727		}
 728		SLIST_INIT(&$$.referenced_syms);
 729		symlist_add(&$$.referenced_syms, symbol, SYMLIST_INSERT_HEAD);
 730	}
 731;
 732
 733constant:
 734	T_CONST T_SYMBOL expression
 735	{
 736		if ($2->type != UNINITIALIZED) {
 737			stop("Re-definition of symbol as a constant",
 738			     EX_DATAERR);
 739			/* NOTREACHED */
 740		}
 741		$2->type = CONST;
 742		initialize_symbol($2);
 743		$2->info.cinfo->value = $3.value;
 744	}
 745|	T_CONST T_SYMBOL T_DOWNLOAD
 746	{
 747		if ($1) {
 748			stop("Invalid downloaded constant declaration",
 749			     EX_DATAERR);
 750			/* NOTREACHED */
 751		}
 752		if ($2->type != UNINITIALIZED) {
 753			stop("Re-definition of symbol as a downloaded constant",
 754			     EX_DATAERR);
 755			/* NOTREACHED */
 756		}
 757		$2->type = DOWNLOAD_CONST;
 758		initialize_symbol($2);
 759		$2->info.cinfo->value = download_constant_count++;
 760	}
 761;
 762
 763macrodefn_prologue:
 764	T_DEFINE T_SYMBOL
 765	{
 766		if ($2->type != UNINITIALIZED) {
 767			stop("Re-definition of symbol as a macro",
 768			     EX_DATAERR);
 769			/* NOTREACHED */
 770		}
 771		cur_symbol = $2;
 772		cur_symbol->type = MACRO;
 773		initialize_symbol(cur_symbol);
 774	}
 775;
 776
 777macrodefn:
 778	macrodefn_prologue T_MACROBODY
 779	{
 780		add_macro_body($2);
 781	}
 782|	macrodefn_prologue '(' macro_arglist ')' T_MACROBODY
 783	{
 784		add_macro_body($5);
 785		cur_symbol->info.macroinfo->narg = $3;
 786	}
 787;
 788
 789macro_arglist:
 790	{
 791		/* Macros can take no arguments */
 792		$$ = 0;
 793	}
 794|	T_ARG
 795	{
 796		$$ = 1;
 797		add_macro_arg($1, 0);
 798	}
 799|	macro_arglist ',' T_ARG
 800	{
 801		if ($1 == 0) {
 802			stop("Comma without preceding argument in arg list",
 803			     EX_DATAERR);
 804			/* NOTREACHED */
 805		}
 806		$$ = $1 + 1;
 807		add_macro_arg($3, $1);
 808	}
 809;
 810
 811scratch_ram:
 812	T_SRAM '{'
 813		{
 814			snprintf(errbuf, sizeof(errbuf), "%s%d", SRAM_SYMNAME,
 815				 num_srams);
 816			cur_symbol = symtable_get(SRAM_SYMNAME);
 817			cur_symtype = SRAMLOC;
 818			cur_symbol->type = SRAMLOC;
 819			initialize_symbol(cur_symbol);
 820			cur_symbol->count += 1;
 821		}
 822		reg_address
 823		{
 824			sram_or_scb_offset = cur_symbol->info.rinfo->address;
 825		}
 826		size
 827		{
 828			scb_or_sram_symbol = cur_symbol;
 829		}
 830		scb_or_sram_attributes
 831	'}'
 832		{
 833			cur_symbol = NULL;
 834			scb_or_sram_symbol = NULL;
 835		}
 836;
 837
 838scb:
 839	T_SCB '{'
 840		{
 841			cur_symbol = symtable_get(SCB_SYMNAME);
 842			cur_symtype = SCBLOC;
 843			if (cur_symbol->type != UNINITIALIZED) {
 844				stop("Only one SRAM definition allowed",
 845				     EX_SOFTWARE);
 846				/* NOTREACHED */
 847			}
 848			cur_symbol->type = SCBLOC;
 849			initialize_symbol(cur_symbol);
 850			/* 64 bytes of SCB space */
 851			cur_symbol->info.rinfo->size = 64;
 852			cur_symbol->count += 1;
 853		}
 854		reg_address
 855		{
 856			sram_or_scb_offset = cur_symbol->info.rinfo->address;
 857		}
 858		size
 859		{
 860			scb_or_sram_symbol = cur_symbol;
 861		}
 862		scb_or_sram_attributes
 863	'}'
 864		{
 865			cur_symbol = NULL;
 866			scb_or_sram_symbol = NULL;
 867		}
 868;
 869
 870scb_or_sram_attributes:
 871	/* NULL definition is okay */
 872|	modes
 873|	scb_or_sram_reg_list
 874|	modes scb_or_sram_reg_list
 875;
 876
 877scb_or_sram_reg_list:
 878	reg_definition
 879|	scb_or_sram_reg_list reg_definition
 880;
 881
 882reg_symbol:
 883	T_SYMBOL
 884	{
 885		process_register(&$1);
 886		$$.symbol = $1;
 887		$$.offset = 0;
 888	}
 889|	T_SYMBOL '[' T_SYMBOL ']'
 890	{
 891		process_register(&$1);
 892		if ($3->type != CONST) {
 893			stop("register offset must be a constant", EX_DATAERR);
 894			/* NOTREACHED */
 895		}
 896		if (($3->info.cinfo->value + 1) > $1->info.rinfo->size) {
 897			stop("Accessing offset beyond range of register",
 898			     EX_DATAERR);
 899			/* NOTREACHED */
 900		}
 901		$$.symbol = $1;
 902		$$.offset = $3->info.cinfo->value;
 903	}
 904|	T_SYMBOL '[' T_NUMBER ']'
 905	{
 906		process_register(&$1);
 907		if (($3 + 1) > $1->info.rinfo->size) {
 908			stop("Accessing offset beyond range of register",
 909			     EX_DATAERR);
 910			/* NOTREACHED */
 911		}
 912		$$.symbol = $1;
 913		$$.offset = $3;
 914	}
 915|	T_A
 916	{
 917		if (accumulator.symbol == NULL) {
 918			stop("No accumulator has been defined", EX_DATAERR);
 919			/* NOTREACHED */
 920		}
 921		$$.symbol = accumulator.symbol;
 922		$$.offset = 0;
 923	}
 924;
 925
 926destination:
 927	reg_symbol
 928	{
 929		test_writable_symbol($1.symbol);
 930		$$ = $1;
 931	}
 932;
 933
 934immediate:
 935	expression
 936	{ $$ = $1; }
 937;
 938
 939immediate_or_a:
 940	expression
 941	{
 942		if ($1.value == 0 && is_download_const(&$1) == 0) {
 943			snprintf(errbuf, sizeof(errbuf),
 944				 "\nExpression evaluates to 0 and thus "
 945				 "references the accumulator.\n "
 946				 "If this is the desired effect, use 'A' "
 947				 "instead.\n");
 948			stop(errbuf, EX_DATAERR);
 949		}
 950		$$ = $1;
 951	}
 952|	T_A
 953	{
 954		SLIST_INIT(&$$.referenced_syms);
 955		symlist_add(&$$.referenced_syms, accumulator.symbol,
 956			    SYMLIST_INSERT_HEAD);
 957		$$.value = 0;
 958	}
 959;
 960
 961source:
 962	reg_symbol
 963	{
 964		test_readable_symbol($1.symbol);
 965		$$ = $1;
 966	}
 967;
 968
 969opt_source:
 970	{
 971		$$.symbol = NULL;
 972		$$.offset = 0;
 973	}
 974|	',' source
 975	{ $$ = $2; }
 976;
 977
 978ret:
 979	{ $$ = 0; }
 980|	T_RET
 981	{ $$ = 1; }
 982;
 983
 984set_src_mode:
 985	T_SET_SRC_MODE T_NUMBER ';'
 986	{
 987		src_mode = $2;
 988	}
 989;
 990
 991set_dst_mode:
 992	T_SET_DST_MODE T_NUMBER ';'
 993	{
 994		dst_mode = $2;
 995	}
 996;
 997
 998critical_section_start:
 999	T_BEGIN_CS ';'
1000	{
1001		critical_section_t *cs;
1002
1003		if (in_critical_section != FALSE) {
1004			stop("Critical Section within Critical Section",
1005			     EX_DATAERR);
1006			/* NOTREACHED */
1007		}
1008		cs = cs_alloc();
1009		cs->begin_addr = instruction_ptr;
1010		in_critical_section = TRUE;
1011	}
1012;
1013
1014critical_section_end:
1015	T_END_CS ';'
1016	{
1017		critical_section_t *cs;
1018
1019		if (in_critical_section == FALSE) {
1020			stop("Unballanced 'end_cs'", EX_DATAERR);
1021			/* NOTREACHED */
1022		}
1023		cs = TAILQ_LAST(&cs_tailq, cs_tailq);
1024		cs->end_addr = instruction_ptr;
1025		in_critical_section = FALSE;
1026	}
1027;
1028
1029export:
1030	{ $$ = 0; }
1031|	T_EXPORT
1032	{ $$ = 1; }
1033;
1034
1035label:
1036	export T_SYMBOL ':'
1037	{
1038		if ($2->type != UNINITIALIZED) {
1039			stop("Program label multiply defined", EX_DATAERR);
1040			/* NOTREACHED */
1041		}
1042		$2->type = LABEL;
1043		initialize_symbol($2);
1044		$2->info.linfo->address = instruction_ptr;
1045		$2->info.linfo->exported = $1;
1046	}
1047;
1048
1049address:
1050	T_SYMBOL
1051	{
1052		$$.symbol = $1;
1053		$$.offset = 0;
1054	}
1055|	T_SYMBOL '+' T_NUMBER
1056	{
1057		$$.symbol = $1;
1058		$$.offset = $3;
1059	}
1060|	T_SYMBOL '-' T_NUMBER
1061	{
1062		$$.symbol = $1;
1063		$$.offset = -$3;
1064	}
1065|	'.'
1066	{
1067		$$.symbol = NULL;
1068		$$.offset = 0;
1069	}
1070|	'.' '+' T_NUMBER
1071	{
1072		$$.symbol = NULL;
1073		$$.offset = $3;
1074	}
1075|	'.' '-' T_NUMBER
1076	{
1077		$$.symbol = NULL;
1078		$$.offset = -$3;
1079	}
1080;
1081
1082conditional:
1083	T_IF T_CEXPR '{'
1084	{
1085		scope_t *new_scope;
1086
1087		add_conditional($2);
1088		new_scope = scope_alloc();
1089		new_scope->type = SCOPE_IF;
1090		new_scope->begin_addr = instruction_ptr;
1091		new_scope->func_num = $2->info.condinfo->func_num;
1092	}
1093|	T_ELSE T_IF T_CEXPR '{'
1094	{
1095		scope_t *new_scope;
1096		scope_t *scope_context;
1097		scope_t *last_scope;
1098
1099		/*
1100		 * Ensure that the previous scope is either an
1101		 * if or and else if.
1102		 */
1103		scope_context = SLIST_FIRST(&scope_stack);
1104		last_scope = TAILQ_LAST(&scope_context->inner_scope,
1105					scope_tailq);
1106		if (last_scope == NULL
1107		 || last_scope->type == T_ELSE) {
1108
1109			stop("'else if' without leading 'if'", EX_DATAERR);
1110			/* NOTREACHED */
1111		}
1112		add_conditional($3);
1113		new_scope = scope_alloc();
1114		new_scope->type = SCOPE_ELSE_IF;
1115		new_scope->begin_addr = instruction_ptr;
1116		new_scope->func_num = $3->info.condinfo->func_num;
1117	}
1118|	T_ELSE '{'
1119	{
1120		scope_t *new_scope;
1121		scope_t *scope_context;
1122		scope_t *last_scope;
1123
1124		/*
1125		 * Ensure that the previous scope is either an
1126		 * if or and else if.
1127		 */
1128		scope_context = SLIST_FIRST(&scope_stack);
1129		last_scope = TAILQ_LAST(&scope_context->inner_scope,
1130					scope_tailq);
1131		if (last_scope == NULL
1132		 || last_scope->type == SCOPE_ELSE) {
1133
1134			stop("'else' without leading 'if'", EX_DATAERR);
1135			/* NOTREACHED */
1136		}
1137		new_scope = scope_alloc();
1138		new_scope->type = SCOPE_ELSE;
1139		new_scope->begin_addr = instruction_ptr;
1140	}
1141;
1142
1143conditional:
1144	'}'
1145	{
1146		scope_t *scope_context;
1147
1148		scope_context = SLIST_FIRST(&scope_stack);
1149		if (scope_context->type == SCOPE_ROOT) {
1150			stop("Unexpected '}' encountered", EX_DATAERR);
1151			/* NOTREACHED */
1152		}
1153
1154		scope_context->end_addr = instruction_ptr;
1155
1156		/* Pop the scope */
1157		SLIST_REMOVE_HEAD(&scope_stack, scope_stack_links);
1158
1159		process_scope(scope_context);
1160
1161		if (SLIST_FIRST(&scope_stack) == NULL) {
1162			stop("Unexpected '}' encountered", EX_DATAERR);
1163			/* NOTREACHED */
1164		}
1165	}
1166;
1167
1168f1_opcode:
1169	T_AND { $$ = AIC_OP_AND; }
1170|	T_XOR { $$ = AIC_OP_XOR; }
1171|	T_ADD { $$ = AIC_OP_ADD; }
1172|	T_ADC { $$ = AIC_OP_ADC; }
1173;
1174
1175code:
1176	f1_opcode destination ',' immediate_or_a opt_source ret ';'
1177	{
1178		format_1_instr($1, &$2, &$4, &$5, $6);
1179	}
1180;
1181
1182code:
1183	T_OR reg_symbol ',' immediate_or_a opt_source ret ';'
1184	{
1185		format_1_instr(AIC_OP_OR, &$2, &$4, &$5, $6);
1186	}
1187;
1188
1189code:
1190	T_INC destination opt_source ret ';'
1191	{
1192		expression_t immed;
1193
1194		make_expression(&immed, 1);
1195		format_1_instr(AIC_OP_ADD, &$2, &immed, &$3, $4);
1196	}
1197;
1198
1199code:
1200	T_DEC destination opt_source ret ';'
1201	{
1202		expression_t immed;
1203
1204		make_expression(&immed, -1);
1205		format_1_instr(AIC_OP_ADD, &$2, &immed, &$3, $4);
1206	}
1207;
1208
1209code:
1210	T_CLC ret ';'
1211	{
1212		expression_t immed;
1213
1214		make_expression(&immed, -1);
1215		format_1_instr(AIC_OP_ADD, &none, &immed, &allzeros, $2);
1216	}
1217|	T_CLC T_MVI destination ',' immediate_or_a ret ';'
1218	{
1219		format_1_instr(AIC_OP_ADD, &$3, &$5, &allzeros, $6);
1220	}
1221;
1222
1223code:
1224	T_STC ret ';'
1225	{
1226		expression_t immed;
1227
1228		make_expression(&immed, 1);
1229		format_1_instr(AIC_OP_ADD, &none, &immed, &allones, $2);
1230	}
1231|	T_STC destination ret ';'
1232	{
1233		expression_t immed;
1234
1235		make_expression(&immed, 1);
1236		format_1_instr(AIC_OP_ADD, &$2, &immed, &allones, $3);
1237	}
1238;
1239
1240code:
1241	T_BMOV destination ',' source ',' immediate ret ';'
1242	{
1243		format_1_instr(AIC_OP_BMOV, &$2, &$6, &$4, $7);
1244	}
1245;
1246
1247code:
1248	T_MOV destination ',' source ret ';'
1249	{
1250		expression_t immed;
1251
1252		make_expression(&immed, 1);
1253		format_1_instr(AIC_OP_BMOV, &$2, &immed, &$4, $5);
1254	}
1255;
1256
1257code:
1258	T_MVI destination ',' immediate ret ';'
1259	{
1260		if ($4.value == 0
1261		 && is_download_const(&$4) == 0) {
1262			expression_t immed;
1263
1264			/*
1265			 * Allow move immediates of 0 so that macros,
1266			 * that can't know the immediate's value and
1267			 * otherwise compensate, still work.
1268			 */
1269			make_expression(&immed, 1);
1270			format_1_instr(AIC_OP_BMOV, &$2, &immed, &allzeros, $5);
1271		} else {
1272			format_1_instr(AIC_OP_OR, &$2, &$4, &allzeros, $5);
1273		}
1274	}
1275;
1276
1277code:
1278	T_NOT destination opt_source ret ';'
1279	{
1280		expression_t immed;
1281
1282		make_expression(&immed, 0xff);
1283		format_1_instr(AIC_OP_XOR, &$2, &immed, &$3, $4);
1284	}
1285;
1286
1287code:
1288	T_CLR destination ret ';'
1289	{
1290		expression_t immed;
1291
1292		make_expression(&immed, 0xff);
1293		format_1_instr(AIC_OP_AND, &$2, &immed, &allzeros, $3);
1294	}
1295;
1296
1297code:
1298	T_NOP ret ';'
1299	{
1300		expression_t immed;
1301
1302		make_expression(&immed, 0xff);
1303		format_1_instr(AIC_OP_AND, &none, &immed, &allzeros, $2);
1304	}
1305;
1306
1307code:
1308	T_RET ';'
1309	{
1310		expression_t immed;
1311
1312		make_expression(&immed, 0xff);
1313		format_1_instr(AIC_OP_AND, &none, &immed, &allzeros, TRUE);
1314	}
1315;
1316
1317	/*
1318	 * This grammar differs from the one in the aic7xxx
1319	 * reference manual since the grammar listed there is
1320	 * ambiguous and causes a shift/reduce conflict.
1321	 * It also seems more logical as the "immediate"
1322	 * argument is listed as the second arg like the
1323	 * other formats.
1324	 */
1325
1326f2_opcode:
1327	T_SHL { $$ = AIC_OP_SHL; }
1328|	T_SHR { $$ = AIC_OP_SHR; }
1329|	T_ROL { $$ = AIC_OP_ROL; }
1330|	T_ROR { $$ = AIC_OP_ROR; }
1331;
1332
1333/*
1334 * 16bit opcodes, not used
1335 *
1336 *f4_opcode:
1337 *	T_OR16	{ $$ = AIC_OP_OR16; }
1338 *|	T_AND16 { $$ = AIC_OP_AND16; }
1339 *|	T_XOR16 { $$ = AIC_OP_XOR16; }
1340 *|	T_ADD16 { $$ = AIC_OP_ADD16; }
1341 *|	T_ADC16 { $$ = AIC_OP_ADC16; }
1342 *|	T_MVI16 { $$ = AIC_OP_MVI16; }
1343 *;
1344 */
1345
1346code:
1347	f2_opcode destination ',' expression opt_source ret ';'
1348	{
1349		format_2_instr($1, &$2, &$4, &$5, $6);
1350	}
1351;
1352
1353jmp_jc_jnc_call:
1354	T_JMP	{ $$ = AIC_OP_JMP; }
1355|	T_JC	{ $$ = AIC_OP_JC; }
1356|	T_JNC	{ $$ = AIC_OP_JNC; }
1357|	T_CALL	{ $$ = AIC_OP_CALL; }
1358;
1359
1360jz_jnz:
1361	T_JZ	{ $$ = AIC_OP_JZ; }
1362|	T_JNZ	{ $$ = AIC_OP_JNZ; }
1363;
1364
1365je_jne:
1366	T_JE	{ $$ = AIC_OP_JE; }
1367|	T_JNE	{ $$ = AIC_OP_JNE; }
1368;
1369
1370code:
1371	jmp_jc_jnc_call address ';'
1372	{
1373		expression_t immed;
1374
1375		make_expression(&immed, 0);
1376		format_3_instr($1, &sindex, &immed, &$2);
1377	}
1378;
1379
1380code:
1381	T_OR reg_symbol ',' immediate jmp_jc_jnc_call address ';'
1382	{
1383		type_check(&$2, &$4, AIC_OP_OR);
1384		format_3_instr($5, &$2, &$4, &$6);
1385	}
1386;
1387
1388code:
1389	T_TEST source ',' immediate_or_a jz_jnz address ';'
1390	{
1391		format_3_instr($5, &$2, &$4, &$6);
1392	}
1393;
1394
1395code:
1396	T_CMP source ',' immediate_or_a je_jne address ';'
1397	{
1398		format_3_instr($5, &$2, &$4, &$6);
1399	}
1400;
1401
1402code:
1403	T_MOV source jmp_jc_jnc_call address ';'
1404	{
1405		expression_t immed;
1406
1407		make_expression(&immed, 0);
1408		format_3_instr($3, &$2, &immed, &$4);
1409	}
1410;
1411
1412code:
1413	T_MVI immediate jmp_jc_jnc_call address ';'
1414	{
1415		format_3_instr($3, &allzeros, &$2, &$4);
1416	}
1417;
1418
1419%%
1420
1421static void
1422process_field(int field_type, symbol_t *sym, int value)
1423{
1424	/*
1425	 * Add the current register to its
1426	 * symbol list, if it already exists,
1427	 * warn if we are setting it to a
1428	 * different value, or in the bit to
1429	 * the "allowed bits" of this register.
1430	 */
1431	if (sym->type == UNINITIALIZED) {
1432		sym->type = field_type;
1433		initialize_symbol(sym);
1434		sym->info.finfo->value = value;
1435		if (field_type != ENUM_ENTRY) {
1436			if (field_type != MASK && value == 0) {
1437				stop("Empty Field, or Enum", EX_DATAERR);
1438				/* NOTREACHED */
1439			}
1440			sym->info.finfo->value = value;
1441			sym->info.finfo->mask = value;
1442		} else if (field_symbol != NULL) {
1443			sym->info.finfo->mask = field_symbol->info.finfo->value;
1444		} else {
1445			sym->info.finfo->mask = 0xFF;
1446		}
1447	} else if (sym->type != field_type) {
1448		stop("Field definition mirrors a definition of the same "
1449		     " name, but a different type", EX_DATAERR);
1450		/* NOTREACHED */
1451	} else if (value != sym->info.finfo->value) {
1452		stop("Field redefined with a conflicting value", EX_DATAERR);
1453		/* NOTREACHED */
1454	}
1455	/* Fail if this symbol is already listed */
1456	if (symlist_search(&(sym->info.finfo->symrefs),
1457			   cur_symbol->name) != NULL) {
1458		stop("Field defined multiple times for register", EX_DATAERR);
1459		/* NOTREACHED */
1460	}
1461	symlist_add(&(sym->info.finfo->symrefs), cur_symbol,
1462		    SYMLIST_INSERT_HEAD);
1463	cur_symbol->info.rinfo->valid_bitmask |= sym->info.finfo->mask;
1464	cur_symbol->info.rinfo->typecheck_masks = TRUE;
1465	symlist_add(&(cur_symbol->info.rinfo->fields), sym, SYMLIST_SORT);
1466}
1467
1468static void
1469initialize_symbol(symbol_t *symbol)
1470{
1471	switch (symbol->type) {
1472	case UNINITIALIZED:
1473		stop("Call to initialize_symbol with type field unset",
1474		     EX_SOFTWARE);
1475		/* NOTREACHED */
1476		break;
1477	case REGISTER:
1478	case SRAMLOC:
1479	case SCBLOC:
1480		symbol->info.rinfo =
1481		    (struct reg_info *)malloc(sizeof(struct reg_info));
1482		if (symbol->info.rinfo == NULL) {
1483			stop("Can't create register info", EX_SOFTWARE);
1484			/* NOTREACHED */
1485		}
1486		memset(symbol->info.rinfo, 0,
1487		       sizeof(struct reg_info));
1488		SLIST_INIT(&(symbol->info.rinfo->fields));
1489		/*
1490		 * Default to allowing access in all register modes
1491		 * or to the mode specified by the SCB or SRAM space
1492		 * we are in.
1493		 */
1494		if (scb_or_sram_symbol != NULL)
1495			symbol->info.rinfo->modes =
1496			    scb_or_sram_symbol->info.rinfo->modes;
1497		else
1498			symbol->info.rinfo->modes = ~0;
1499		break;
1500	case ALIAS:
1501		symbol->info.ainfo =
1502		    (struct alias_info *)malloc(sizeof(struct alias_info));
1503		if (symbol->info.ainfo == NULL) {
1504			stop("Can't create alias info", EX_SOFTWARE);
1505			/* NOTREACHED */
1506		}
1507		memset(symbol->info.ainfo, 0,
1508		       sizeof(struct alias_info));
1509		break;
1510	case MASK:
1511	case FIELD:
1512	case ENUM:
1513	case ENUM_ENTRY:
1514		symbol->info.finfo =
1515		    (struct field_info *)malloc(sizeof(struct field_info));
1516		if (symbol->info.finfo == NULL) {
1517			stop("Can't create field info", EX_SOFTWARE);
1518			/* NOTREACHED */
1519		}
1520		memset(symbol->info.finfo, 0, sizeof(struct field_info));
1521		SLIST_INIT(&(symbol->info.finfo->symrefs));
1522		break;
1523	case CONST:
1524	case DOWNLOAD_CONST:
1525		symbol->info.cinfo =
1526		    (struct const_info *)malloc(sizeof(struct const_info));
1527		if (symbol->info.cinfo == NULL) {
1528			stop("Can't create alias info", EX_SOFTWARE);
1529			/* NOTREACHED */
1530		}
1531		memset(symbol->info.cinfo, 0,
1532		       sizeof(struct const_info));
1533		break;
1534	case LABEL:
1535		symbol->info.linfo =
1536		    (struct label_info *)malloc(sizeof(struct label_info));
1537		if (symbol->info.linfo == NULL) {
1538			stop("Can't create label info", EX_SOFTWARE);
1539			/* NOTREACHED */
1540		}
1541		memset(symbol->info.linfo, 0,
1542		       sizeof(struct label_info));
1543		break;
1544	case CONDITIONAL:
1545		symbol->info.condinfo =
1546		    (struct cond_info *)malloc(sizeof(struct cond_info));
1547		if (symbol->info.condinfo == NULL) {
1548			stop("Can't create conditional info", EX_SOFTWARE);
1549			/* NOTREACHED */
1550		}
1551		memset(symbol->info.condinfo, 0,
1552		       sizeof(struct cond_info));
1553		break;
1554	case MACRO:
1555		symbol->info.macroinfo =
1556		    (struct macro_info *)malloc(sizeof(struct macro_info));
1557		if (symbol->info.macroinfo == NULL) {
1558			stop("Can't create macro info", EX_SOFTWARE);
1559			/* NOTREACHED */
1560		}
1561		memset(symbol->info.macroinfo, 0,
1562		       sizeof(struct macro_info));
1563		STAILQ_INIT(&symbol->info.macroinfo->args);
1564		break;
1565	default:
1566		stop("Call to initialize_symbol with invalid symbol type",
1567		     EX_SOFTWARE);
1568		/* NOTREACHED */
1569		break;
1570	}
1571}
1572
1573static void
1574add_macro_arg(const char *argtext, int argnum)
1575{
1576	struct macro_arg *marg;
1577	int i;
1578	int retval;
1579
1580	if (cur_symbol == NULL || cur_symbol->type != MACRO) {
1581		stop("Invalid current symbol for adding macro arg",
1582		     EX_SOFTWARE);
1583		/* NOTREACHED */
1584	}
1585
1586	marg = (struct macro_arg *)malloc(sizeof(*marg));
1587	if (marg == NULL) {
1588		stop("Can't create macro_arg structure", EX_SOFTWARE);
1589		/* NOTREACHED */
1590	}
1591	marg->replacement_text = NULL;
1592	retval = snprintf(regex_pattern, sizeof(regex_pattern),
1593			  "[^-/A-Za-z0-9_](%s)([^-/A-Za-z0-9_]|$)",
1594			  argtext);
1595	if (retval >= sizeof(regex_pattern)) {
1596		stop("Regex text buffer too small for arg",
1597		     EX_SOFTWARE);
1598		/* NOTREACHED */
1599	}
1600	retval = regcomp(&marg->arg_regex, regex_pattern, REG_EXTENDED);
1601	if (retval != 0) {
1602		stop("Regex compilation failed", EX_SOFTWARE);
1603		/* NOTREACHED */
1604	}
1605	STAILQ_INSERT_TAIL(&cur_symbol->info.macroinfo->args, marg, links);
1606}
1607
1608static void
1609add_macro_body(const char *bodytext)
1610{
1611	if (cur_symbol == NULL || cur_symbol->type != MACRO) {
1612		stop("Invalid current symbol for adding macro arg",
1613		     EX_SOFTWARE);
1614		/* NOTREACHED */
1615	}
1616	cur_symbol->info.macroinfo->body = strdup(bodytext);
1617	if (cur_symbol->info.macroinfo->body == NULL) {
1618		stop("Can't duplicate macro body text", EX_SOFTWARE);
1619		/* NOTREACHED */
1620	}
1621}
1622
1623static void
1624process_register(symbol_t **p_symbol)
1625{
1626	symbol_t *symbol = *p_symbol;
1627
1628	if (symbol->type == UNINITIALIZED) {
1629		snprintf(errbuf, sizeof(errbuf), "Undefined register %s",
1630			 symbol->name);
1631		stop(errbuf, EX_DATAERR);
1632		/* NOTREACHED */
1633	} else if (symbol->type == ALIAS) {
1634		*p_symbol = symbol->info.ainfo->parent;
1635	} else if ((symbol->type != REGISTER)
1636		&& (symbol->type != SCBLOC)
1637		&& (symbol->type != SRAMLOC)) {
1638		snprintf(errbuf, sizeof(errbuf),
1639			 "Specified symbol %s is not a register",
1640			 symbol->name);
1641		stop(errbuf, EX_DATAERR);
1642	}
1643}
1644
1645static void
1646format_1_instr(int opcode, symbol_ref_t *dest, expression_t *immed,
1647	       symbol_ref_t *src, int ret)
1648{
1649	struct instruction *instr;
1650	struct ins_format1 *f1_instr;
1651
1652	if (src->symbol == NULL)
1653		src = dest;
1654
1655	/* Test register permissions */
1656	test_writable_symbol(dest->symbol);
1657	test_readable_symbol(src->symbol);
1658
1659	if (!is_location_address(dest->symbol)) {
1660		/* Ensure that immediate makes sense for this destination */
1661		type_check(dest, immed, opcode);
1662	}
1663
1664	/* Allocate sequencer space for the instruction and fill it out */
1665	instr = seq_alloc();
1666	f1_instr = &instr->format.format1;
1667	f1_instr->ret = ret ? 1 : 0;
1668	f1_instr->opcode = opcode;
1669	f1_instr->destination = dest->symbol->info.rinfo->address
1670			      + dest->offset;
1671	f1_instr->source = src->symbol->info.rinfo->address
1672			 + src->offset;
1673	f1_instr->immediate = immed->value;
1674
1675	if (is_download_const(immed))
1676		f1_instr->parity = 1;
1677	else if (dest->symbol == mode_ptr.symbol) {
1678		u_int src_value;
1679		u_int dst_value;
1680
1681		/*
1682		 * Attempt to update mode information if
1683		 * we are operating on the mode register.
1684		 */
1685		if (src->symbol == allones.symbol)
1686			src_value = 0xFF;
1687		else if (src->symbol == allzeros.symbol)
1688			src_value = 0;
1689		else if (src->symbol == mode_ptr.symbol)
1690			src_value = (dst_mode << 4) | src_mode;
1691		else
1692			goto cant_update;
1693
1694		switch (opcode) {
1695		case AIC_OP_AND:
1696			dst_value = src_value & immed->value;
1697			break;
1698		case AIC_OP_XOR:
1699			dst_value = src_value ^ immed->value;
1700			break;
1701		case AIC_OP_ADD:
1702			dst_value = (src_value + immed->value) & 0xFF;
1703			break;
1704		case AIC_OP_OR:
1705			dst_value = src_value | immed->value;
1706			break;
1707		case AIC_OP_BMOV:
1708			dst_value = src_value;
1709			break;
1710		default:
1711			goto cant_update;
1712		}
1713		src_mode = dst_value & 0xF;
1714		dst_mode = (dst_value >> 4) & 0xF;
1715	}
1716
1717cant_update:
1718	symlist_free(&immed->referenced_syms);
1719	instruction_ptr++;
1720}
1721
1722static void
1723format_2_instr(int opcode, symbol_ref_t *dest, expression_t *places,
1724	       symbol_ref_t *src, int ret)
1725{
1726	struct instruction *instr;
1727	struct ins_format2 *f2_instr;
1728	uint8_t shift_control;
1729
1730	if (src->symbol == NULL)
1731		src = dest;
1732
1733	/* Test register permissions */
1734	test_writable_symbol(dest->symbol);
1735	test_readable_symbol(src->symbol);
1736
1737	/* Allocate sequencer space for the instruction and fill it out */
1738	instr = seq_alloc();
1739	f2_instr = &instr->format.format2;
1740	f2_instr->ret = ret ? 1 : 0;
1741	f2_instr->opcode = AIC_OP_ROL;
1742	f2_instr->destination = dest->symbol->info.rinfo->address
1743			      + dest->offset;
1744	f2_instr->source = src->symbol->info.rinfo->address
1745			 + src->offset;
1746	if (places->value > 8 || places->value <= 0) {
1747		stop("illegal shift value", EX_DATAERR);
1748		/* NOTREACHED */
1749	}
1750	switch (opcode) {
1751	case AIC_OP_SHL:
1752		if (places->value == 8)
1753			shift_control = 0xf0;
1754		else
1755			shift_control = (places->value << 4) | places->value;
1756		break;
1757	case AIC_OP_SHR:
1758		if (places->value == 8) {
1759			shift_control = 0xf8;
1760		} else {
1761			shift_control = (places->value << 4)
1762				      | (8 - places->value)
1763				      | 0x08;
1764		}
1765		break;
1766	case AIC_OP_ROL:
1767		shift_control = places->value & 0x7;
1768		break;
1769	case AIC_OP_ROR:
1770		shift_control = (8 - places->value) | 0x08;
1771		break;
1772	default:
1773		shift_control = 0; /* Quiet Compiler */
1774		stop("Invalid shift operation specified", EX_SOFTWARE);
1775		/* NOTREACHED */
1776		break;
1777	};
1778	f2_instr->shift_control = shift_control;
1779	symlist_free(&places->referenced_syms);
1780	instruction_ptr++;
1781}
1782
1783static void
1784format_3_instr(int opcode, symbol_ref_t *src,
1785	       expression_t *immed, symbol_ref_t *address)
1786{
1787	struct instruction *instr;
1788	struct ins_format3 *f3_instr;
1789	int addr;
1790
1791	/* Test register permissions */
1792	test_readable_symbol(src->symbol);
1793
1794	/* Allocate sequencer space for the instruction and fill it out */
1795	instr = seq_alloc();
1796	f3_instr = &instr->format.format3;
1797	if (address->symbol == NULL) {
1798		/* 'dot' reference.  Use the current instruction pointer */
1799		addr = instruction_ptr + address->offset;
1800	} else if (address->symbol->type == UNINITIALIZED) {
1801		/* forward reference */
1802		addr = address->offset;
1803		instr->patch_label = address->symbol;
1804	} else
1805		addr = address->symbol->info.linfo->address + address->offset;
1806	f3_instr->opcode = opcode;
1807	f3_instr->address = addr;
1808	f3_instr->source = src->symbol->info.rinfo->address
1809			 + src->offset;
1810	f3_instr->immediate = immed->value;
1811
1812	if (is_download_const(immed))
1813		f3_instr->parity = 1;
1814
1815	symlist_free(&immed->referenced_syms);
1816	instruction_ptr++;
1817}
1818
1819static void
1820test_readable_symbol(symbol_t *symbol)
1821{
1822	if ((symbol->info.rinfo->modes & (0x1 << src_mode)) == 0) {
1823		snprintf(errbuf, sizeof(errbuf),
1824			"Register %s unavailable in source reg mode %d",
1825			symbol->name, src_mode);
1826		stop(errbuf, EX_DATAERR);
1827	}
1828
1829	if (symbol->info.rinfo->mode == WO) {
1830		stop("Write Only register specified as source",
1831		     EX_DATAERR);
1832		/* NOTREACHED */
1833	}
1834}
1835
1836static void
1837test_writable_symbol(symbol_t *symbol)
1838{
1839	if ((symbol->info.rinfo->modes & (0x1 << dst_mode)) == 0) {
1840		snprintf(errbuf, sizeof(errbuf),
1841			"Register %s unavailable in destination reg mode %d",
1842			symbol->name, dst_mode);
1843		stop(errbuf, EX_DATAERR);
1844	}
1845
1846	if (symbol->info.rinfo->mode == RO) {
1847		stop("Read Only register specified as destination",
1848		     EX_DATAERR);
1849		/* NOTREACHED */
1850	}
1851}
1852
1853static void
1854type_check(symbol_ref_t *sym, expression_t *expression, int opcode)
1855{
1856	symbol_t *symbol = sym->symbol;
1857	symbol_node_t *node;
1858	int and_op;
1859	int8_t value, mask;
1860
1861	and_op = FALSE;
1862	/*
1863	 * Make sure that we aren't attempting to write something
1864	 * that hasn't been defined.  If this is an and operation,
1865	 * this is a mask, so "undefined" bits are okay.
1866	 */
1867	if (opcode == AIC_OP_AND || opcode == AIC_OP_JNZ ||
1868	    opcode == AIC_OP_JZ  || opcode == AIC_OP_JNE ||
1869	    opcode == AIC_OP_BMOV)
1870		and_op = TRUE;
1871
1872	/*
1873	 * Defaulting to 8 bit logic
1874	 */
1875	mask = (int8_t)~symbol->info.rinfo->valid_bitmask;
1876	value = (int8_t)expression->value;
1877
1878	if (and_op == FALSE && (mask & value) != 0 ) {
1879		snprintf(errbuf, sizeof(errbuf),
1880			 "Invalid bit(s) 0x%x in immediate written to %s",
1881			 (mask & value),
1882			 symbol->name);
1883		stop(errbuf, EX_DATAERR);
1884		/* NOTREACHED */
1885	}
1886
1887	/*
1888	 * Now make sure that all of the symbols referenced by the
1889	 * expression are defined for this register.
1890	 */
1891	if (symbol->info.rinfo->typecheck_masks != FALSE) {
1892		for(node = expression->referenced_syms.slh_first;
1893		    node != NULL;
1894		    node = node->links.sle_next) {
1895			if ((node->symbol->type == MASK
1896			  || node->symbol->type == FIELD
1897			  || node->symbol->type == ENUM
1898			  || node->symbol->type == ENUM_ENTRY)
1899			 && symlist_search(&node->symbol->info.finfo->symrefs,
1900					   symbol->name) == NULL) {
1901				snprintf(errbuf, sizeof(errbuf),
1902					 "Invalid field or mask %s "
1903					 "for register %s",
1904					 node->symbol->name, symbol->name);
1905				stop(errbuf, EX_DATAERR);
1906				/* NOTREACHED */
1907			}
1908		}
1909	}
1910}
1911
1912static void
1913make_expression(expression_t *immed, int value)
1914{
1915	SLIST_INIT(&immed->referenced_syms);
1916	immed->value = value & 0xff;
1917}
1918
1919static void
1920add_conditional(symbol_t *symbol)
1921{
1922	static int numfuncs;
1923
1924	if (numfuncs == 0) {
1925		/* add a special conditional, "0" */
1926		symbol_t *false_func;
1927
1928		false_func = symtable_get("0");
1929		if (false_func->type != UNINITIALIZED) {
1930			stop("Conditional expression '0' "
1931			     "conflicts with a symbol", EX_DATAERR);
1932			/* NOTREACHED */
1933		}
1934		false_func->type = CONDITIONAL;
1935		initialize_symbol(false_func);
1936		false_func->info.condinfo->func_num = numfuncs++;
1937		symlist_add(&patch_functions, false_func, SYMLIST_INSERT_HEAD);
1938	}
1939
1940	/* This condition has occurred before */
1941	if (symbol->type == CONDITIONAL)
1942		return;
1943
1944	if (symbol->type != UNINITIALIZED) {
1945		stop("Conditional expression conflicts with a symbol",
1946		     EX_DATAERR);
1947		/* NOTREACHED */
1948	}
1949
1950	symbol->type = CONDITIONAL;
1951	initialize_symbol(symbol);
1952	symbol->info.condinfo->func_num = numfuncs++;
1953	symlist_add(&patch_functions, symbol, SYMLIST_INSERT_HEAD);
1954}
1955
1956static void
1957add_version(const char *verstring)
1958{
1959	const char prefix[] = " * ";
1960	int newlen;
1961	int oldlen;
1962
1963	newlen = strlen(verstring) + strlen(prefix);
1964	oldlen = 0;
1965	if (versions != NULL)
1966		oldlen = strlen(versions);
1967	versions = realloc(versions, newlen + oldlen + 2);
1968	if (versions == NULL)
1969		stop("Can't allocate version string", EX_SOFTWARE);
1970	strcpy(&versions[oldlen], prefix);
1971	strcpy(&versions[oldlen + strlen(prefix)], verstring);
1972	versions[newlen + oldlen] = '\n';
1973	versions[newlen + oldlen + 1] = '\0';
1974}
1975
1976void
1977yyerror(const char *string)
1978{
1979	stop(string, EX_DATAERR);
1980}
1981
1982static int
1983is_download_const(expression_t *immed)
1984{
1985	if ((immed->referenced_syms.slh_first != NULL)
1986	 && (immed->referenced_syms.slh_first->symbol->type == DOWNLOAD_CONST))
1987		return (TRUE);
1988
1989	return (FALSE);
1990}
1991
1992static int
1993is_location_address(symbol_t *sym)
1994{
1995	if (sym->type == SCBLOC ||
1996	    sym->type == SRAMLOC)
1997		return (TRUE);
1998	return (FALSE);
1999}
2000