drivers/scsi/aic7xxx/aicasm/aicasm_gram.y

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