#!/bin/sh
# This is part 03 of Frankasm/Base
# ============= fryylex.c ==============
if test -f 'fryylex.c' -a X"$1" != X"-c"; then
        echo 'x - skipping fryylex.c (File already exists)'
else
echo 'x - extracting fryylex.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'fryylex.c' &&
X/*
XHEADER:        ;
XTITLE:                 Frankenstein Cross Assemblers;
XVERSION:       2.0;
XDESCRIPTION: " Reconfigurable Cross-assembler producing Intel (TM)
X               Hex format object records.  ";
XKEYWORDS:      cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809,
X               6811, tms7000, 8048, 8051, 8096, z8, z80;
XSYSTEM:        UNIX, MS-Dos ;
XFILENAME:      fryylex.c;
XWARNINGS:      "This software is in the public domain.
X               Any prior copyright claims are relinquished.
X
X               This software is distributed with no warranty whatever.
X               The author takes no responsibility for the consequences
X               of its use.
X
X               Yacc (or Bison) required to compile."  ;
XSEE-ALSO:      as*.y (yacc input files);
XAUTHORS:       Mark Zenier;
XCOMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
X               (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
X*/
X
X
X/*
X       description     lexical analyzer for framework cross assembler
X       usage           Framework cross assembler, Unix
X       history         September 13, 1987
X                       September 14, 1990  Dosify, 6 char unique names
X                       October, 1990  hand carved scanner
X*/
X
X#include <stdio.h>
X#include "frasmdat.h"
X#include "fraytok.h"
X
X#ifndef DEBUG
X#define DEBUG 0
X#endif
X
X       extern YYSTYPE yylval;
X
X       enum symflag {Symopcode, Symsym} whichsym = Symopcode;
X
X       FILE *yyin;
X
X       char finbuff[INBUFFSZ] = "L:";
X               /* initialization nonreusable, wiped out by pass 2 */
X       static char *frainptr = &finbuff[2];
X               /* point to null byte after L: on start up */
X       enum readacts nextreadact = Nra_normal;
X
X
Xfrareadrec()
X/*
X       description     read a line, on end of file, pop the include file
X                       stack.
X       return          FALSE   got a line
X                       TRUE    end of input
X*/
X{
X       while( fgets(&finbuff[2], INBUFFSZ -2, yyin) == (char *)NULL)
X       {
X               if(currfstk == 0)
X               {
X                       return TRUE;
X               }
X               else
X               {
X                       fclose(yyin);
X                       yyin = infilestk[--currfstk].fpt;
X                       fprintf(intermedf, "X:%s\n",infilestk[currfstk].fnm);
X               }
X       }
X       return FALSE;
X}
X
Xstatic int currtok=0; /* subscript of next token to return */
Xstatic int intokcnt=0; /* number of tokens in queue */
X
Xstatic struct
X{
X       char *textstrt, *textend;
X       YYSTYPE  lvalv;
X       int tokv;
X       enum {Yetprint, Yetsymbol, Yetreserved, Yetopcode,
X               Yetconstant, Yetstring, Yetunprint, Yetinvalid } errtype;
X}  scanqueue[INBUFFSZ], *lasttokfetch, *nexttokload;
X
Xstatic char tempstrpool[2*INBUFFSZ];
Xstatic char *tptrstr;
X
X#define         CXC00_SKIP     0
X#define         CXC01_SPACE    1
X#define         CXC02_NL       2
X#define         CXC03_LETTER   3
X#define         CXC04_QUOTE    4
X#define         CXC05_OTHER    5
X#define         CXC06_DOLLAR   6
X#define         CXC07_PERCENT  7
X#define         CXC08_APP      8
X#define         CXC09_BIN      9
X#define         CXC10_OCT      10
X#define         CXC11_DEC      11
X#define         CXC12_SEMIC    12
X#define         CXC13_LT       13
X#define         CXC14_EQ       14
X#define         CXC15_GT       15
X#define         CXC16_AT       16
X#define         CXC17_HEXU     17
X#define         CXC18_B        18
X#define         CXC19_D        19
X#define         CXC20_H        20
X#define         CXC21_OQ       21
X#define         CXC22_HEXL     22
X#define         CXC23_BL       23
X#define         CXC24_DL       24
X#define         CXC25_BSLASH   25
X#define  NUMCHARSETS   26
X
Xstatic char chartrantab[128] = {
X/* 00 nul soh stx etx*/  CXC00_SKIP, CXC00_SKIP, CXC00_SKIP, CXC00_SKIP,
X/* 04 eot enq ack bel*/  CXC00_SKIP, CXC00_SKIP, CXC00_SKIP, CXC00_SKIP,
X/* 08 bs  ht  nl  vt */  CXC00_SKIP, CXC01_SPACE, CXC02_NL, CXC00_SKIP,
X/* 0c np  cr  so  si */  CXC00_SKIP, CXC00_SKIP, CXC00_SKIP, CXC00_SKIP,
X/* 10 dle dc1 dc2 dc3*/  CXC00_SKIP, CXC00_SKIP, CXC00_SKIP, CXC00_SKIP,
X/* 14 dc4 nak syn etb*/  CXC00_SKIP, CXC00_SKIP, CXC00_SKIP, CXC00_SKIP,
X/* 18 can em  sub esc*/  CXC00_SKIP, CXC00_SKIP, CXC00_SKIP, CXC00_SKIP,
X/* 1c fs  gs  rs  us */  CXC00_SKIP, CXC00_SKIP, CXC00_SKIP, CXC00_SKIP,
X/* 20 sp  !  "  # */  CXC01_SPACE, CXC03_LETTER, CXC04_QUOTE, CXC05_OTHER,
X/* 24  $  %  &  ' */  CXC06_DOLLAR, CXC07_PERCENT, CXC03_LETTER, CXC08_APP,
X/* 28  (  )  *  + */  CXC05_OTHER, CXC05_OTHER, CXC05_OTHER, CXC05_OTHER,
X/* 2c  ,  -  .  / */  CXC05_OTHER, CXC05_OTHER, CXC05_OTHER, CXC05_OTHER,
X/* 30  0  1  2  3 */  CXC09_BIN, CXC09_BIN, CXC10_OCT, CXC10_OCT,
X/* 34  4  5  6  7 */  CXC10_OCT, CXC10_OCT, CXC10_OCT, CXC10_OCT,
X/* 38  8  9  :  ; */  CXC11_DEC, CXC11_DEC, CXC05_OTHER, CXC12_SEMIC,
X/* 3c  <  =  >  ? */  CXC13_LT, CXC14_EQ, CXC15_GT, CXC05_OTHER,
X/* 40  @  A  B  C */  CXC16_AT, CXC17_HEXU, CXC18_B, CXC17_HEXU,
X/* 44  D  E  F  G */  CXC19_D, CXC17_HEXU, CXC17_HEXU, CXC03_LETTER,
X/* 48  H  I  J  K */  CXC20_H, CXC03_LETTER, CXC03_LETTER, CXC03_LETTER,
X/* 4c  L  M  N  O */  CXC03_LETTER, CXC03_LETTER, CXC03_LETTER, CXC21_OQ,
X/* 50  P  Q  R  S */  CXC03_LETTER, CXC21_OQ, CXC03_LETTER, CXC03_LETTER,
X/* 54  T  U  V  W */  CXC03_LETTER, CXC03_LETTER, CXC03_LETTER, CXC03_LETTER,
X/* 58  X  Y  Z  [ */  CXC03_LETTER, CXC03_LETTER, CXC03_LETTER, CXC05_OTHER,
X/* 5c  \  ]  ^  _ */  CXC25_BSLASH, CXC05_OTHER, CXC03_LETTER, CXC03_LETTER,
X/* 60  `  a  b  c */  CXC05_OTHER, CXC22_HEXL, CXC23_BL, CXC22_HEXL,
X/* 64  d  e  f  g */  CXC24_DL, CXC22_HEXL, CXC22_HEXL, CXC03_LETTER,
X/* 68  h  i  j  k */  CXC20_H, CXC03_LETTER, CXC03_LETTER, CXC03_LETTER,
X/* 6c  l  m  n  o */  CXC03_LETTER, CXC03_LETTER, CXC03_LETTER, CXC21_OQ,
X/* 70  p  q  r  s */  CXC03_LETTER, CXC21_OQ, CXC03_LETTER, CXC03_LETTER,
X/* 74  t  u  v  w */  CXC03_LETTER, CXC03_LETTER, CXC03_LETTER, CXC03_LETTER,
X/* 78  x  y  z  { */  CXC03_LETTER, CXC03_LETTER, CXC03_LETTER, CXC05_OTHER,
X/* 7c vb  }  ~  del*/  CXC05_OTHER, CXC05_OTHER, CXC03_LETTER, CXC00_SKIP } ;
X
X
X#if DEBUG
X
Xstatic char * statelab[] = {
X               " 0 start of label",
X               " 1 comment",
X               " 2 label",
X               " 3 rest of line",
X               " 4 symbol",
X               " 5 dollar",
X               " 6 hex dollar",
X               " 7 at sign",
X               " 8 octal at",
X               " 9 percent",
X               "10 bin percent",
X               "11 quote string",
X               "12 appos. string",
X               "13 greater than",
X               "14 less than",
X               "15 base 2 maybe",
X               "16 base 8 maybe",
X               "17 base 10 maybe",
X               "18 hex",
X               "19 found b ",
X               "20 found d",
X               "21 bslash quote",
X               "22 bslash appos",
X               };
X
Xstatic char *actlab[] = {
X               " 0 skip/no op",
X               " 1 load EOL token",
X               " 2 start string",
X               " 3 process label",
X               " 4 save string char",
X               " 5 load single char token",
X               " 6 load EQ token",
X               " 7 process symbol",
X               " 8 load $ token",
X               " 9 setup for $hex",
X               "10 accumulate 0-9 constant",
X               "11 accumulate A-F constant",
X               "12 accumulate a-f constant",
X               "13 load Constant token",
X               "14 load @ token",
X               "15 setup for @octal",
X               "16 setup for %binary",
X               "17 load % token",
X               "18 load String token",
X               "19 load GE token",
X               "20 load GT token",
X               "21 load LE token",
X               "22 load NE token",
X               "23 load LT token",
X               "24 save numeric char 0-9",
X               "25 save numeric char A-F",
X               "26 save numeric char a-f",
X               "27 convert numeric string base 2",
X               "28 convert numeric string base 8",
X               "29 convert numeric string base 10",
X               "30 convert numeric string base 16",
X               "31 save numeric 0xb",
X               "32 save numeric 0xd",
X               "33 set text start",
X               "34 token choke"
X               };
X
X#endif  /* DEBUG */
X
Xstatic struct
X{
X       char action;
X       char nextstate;
X       char contin;
X}      *thisact, characttab [23][NUMCHARSETS] =
X{
X/*
X       STATE 0 =       {start of label}
X*/
X       {
X       /* SKIP    */   /* SPACE   */   /* NL      */   /* LETTER  */
X       /* QUOTE   */   /* OTHER   */   /* DOLLAR  */   /* PERCENT */
X       /* APP     */   /* BIN     */   /* OCT     */   /* DEC     */
X       /* SEMIC   */   /* LT      */   /* EQ      */   /* GT      */
X       /* AT      */   /* HEXU    */   /* B       */   /* D       */
X       /* H       */   /* OQ      */   /* HEXL    */   /* BL      */
X       /* DL      */   /* BSLASH  */
X       {0, 0, FALSE},  {0, 3, FALSE},  {1, 0, FALSE},  {2, 2, TRUE},
X       {2,11, FALSE},  {5, 3, FALSE},  {33, 5, FALSE}, {33, 9, FALSE},
X       {2,12, FALSE},  {2,15, TRUE},   {2,16, TRUE},   {2,17, TRUE},
X       {0, 1, FALSE},  {0,14, FALSE},  {6, 3, FALSE},  {0,13, FALSE},
X       {33, 7, FALSE}, {2, 2, TRUE},   {2, 2, TRUE},   {2, 2, TRUE},
X       {2, 2, TRUE},   {2, 2, TRUE},   {2, 2, TRUE},   {2, 2, TRUE},
X       {2, 2, TRUE},   {5, 3, FALSE}
X       },
X
X/*
X       STATE 1 =       {comment}
X*/
X       {
X       {0, 1, FALSE},  {0, 1, FALSE},  {1, 0, FALSE},  {0, 1, FALSE},
X       {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},
X       {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},
X       {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},
X       {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},
X       {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},  {0, 1, FALSE},
X       {0, 1, FALSE},  {0, 1, FALSE}
X       },
X
X/*
X       STATE 2 =       {label}
X*/
X       {
X       {0, 2, FALSE},  {3, 3, FALSE},  {3, 3, TRUE},   {4, 2, FALSE},
X       {3, 3, TRUE},   {3, 3, TRUE},   {3, 3, TRUE},   {3, 3, TRUE},
X       {3, 3, TRUE},   {4, 2, FALSE},  {4, 2, FALSE},  {4, 2, FALSE},
X       {3, 1, FALSE},  {3,14, FALSE},  {3, 3, TRUE},   {3,13, FALSE},
X       {3, 3, TRUE},   {4, 2, FALSE},  {4, 2, FALSE},  {4, 2, FALSE},
X       {4, 2, FALSE},  {4, 2, FALSE},  {4, 2, FALSE},  {4, 2, FALSE},
X       {4, 2, FALSE},  {3, 3, TRUE}
X       },
X
X/*
X       STATE 3  =      {rest of line}
X*/
X       {
X       {0, 3, FALSE},  {0, 3, FALSE},  {1, 0, FALSE},  {2, 4, TRUE},
X       {2,11, FALSE},  {5, 3, FALSE},  {33, 5, FALSE}, {33, 9, FALSE},
X       {2,12, FALSE},  {2,15, TRUE},   {2,16, TRUE},   {2,17, TRUE},
X       {0, 1, FALSE},  {0,14, FALSE},  {6, 3, FALSE},  {0,13, FALSE},
X       {33, 7, FALSE}, {2, 4, TRUE},   {2, 4, TRUE},   {2, 4, TRUE},
X       {2, 4, TRUE},   {2, 4, TRUE},   {2, 4, TRUE},   {2, 4, TRUE},
X       {2, 4, TRUE} ,  {5, 3, FALSE}
X       },
X
X/*
X       STATE 4 =       {symbol}
X*/
X       {
X       {0, 4, FALSE},  {7, 3, FALSE},  {7, 3, TRUE},   {4, 4, FALSE},
X       {7, 3, TRUE},   {7, 3, TRUE},   {7, 3, TRUE},   {7, 3, TRUE},
X       {7, 3, TRUE},   {4, 4, FALSE},  {4, 4, FALSE},  {4, 4, FALSE},
X       {7, 1, FALSE},  {7,14, FALSE},  {7, 3, TRUE},   {7,13, FALSE},
X       {7, 3, TRUE},   {4, 4, FALSE},  {4, 4, FALSE},  {4, 4, FALSE},
X       {4, 4, FALSE},  {4, 4, FALSE},  {4, 4, FALSE},  {4, 4, FALSE},
X       {4, 4, FALSE},  {7, 3, TRUE}
X       },
X
X/*
X       STATE 5 =       {dollar}
X*/
X       {
X       {0, 5, FALSE},  {8, 3, FALSE},  {8, 3, TRUE},   {8, 3, TRUE},
X       {8, 3, TRUE},   {8, 3, TRUE},   {8, 3, TRUE},   {8, 3, TRUE},
X       {8, 3, TRUE},   {9, 6, TRUE},   {9, 6, TRUE},   {9, 6, TRUE},
X       {8, 1, FALSE},  {8,14, FALSE},  {8, 3, TRUE},   {8,13, FALSE},
X       {8, 3, TRUE},   {9, 6, TRUE},   {9, 6, TRUE},   {9, 6, TRUE},
X       {8, 3, TRUE},   {8, 3, TRUE},   {9, 6, TRUE},   {9, 6, TRUE},
X       {9, 6, TRUE} ,  {8, 3, TRUE}
X       },
X
X/*
X       STATE 6 =       {dollar hex}
X*/
X
X       {
X       {0, 6, FALSE},  {13, 3, FALSE}, {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {10, 6, FALSE}, {10, 6, FALSE}, {10, 6, FALSE},
X       {13, 1, FALSE}, {13,14, FALSE}, {13, 3, TRUE},  {13,13, FALSE},
X       {13, 3, TRUE},  {11, 6, FALSE}, {11, 6, FALSE}, {11, 6, FALSE},
X       {13, 3, TRUE},  {13, 3, TRUE},  {12, 6, FALSE}, {12, 6, FALSE},
X       {12, 6, FALSE}, {13, 3, TRUE}
X       },
X/*
X       STATE 7 =       {at sign}
X*/
X       {
X       {0, 7, FALSE},  {14, 3, FALSE}, {14, 3, TRUE},  {14, 3, TRUE},
X       {14, 3, TRUE},  {14, 3, TRUE},  {14, 3, TRUE},  {14, 3, TRUE},
X       {14, 3, TRUE},  {15, 8, TRUE},  {15, 8, TRUE},  {14, 3, TRUE},
X       {14, 1, FALSE}, {14,14, FALSE}, {14, 3, TRUE},  {14,13, FALSE},
X       {14, 3, TRUE},  {14, 3, TRUE},  {14, 3, TRUE},  {14, 3, TRUE},
X       {14, 3, TRUE},  {14, 3, TRUE},  {14, 3, TRUE},  {14, 3, TRUE},
X       {14, 3, TRUE},  {14, 3, TRUE}
X       },
X
X/*
X       STATE 8 =       {at octal}
X*/
X       {
X       {0, 8, FALSE},  {13, 3, FALSE}, {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {10, 8, FALSE}, {10, 8, FALSE}, {13, 3, TRUE},
X       {13, 1, FALSE}, {13,14, FALSE}, {13, 3, TRUE},  {13,13, FALSE},
X       {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {13, 3, TRUE}
X       },
X
X/*
X       STATE 9 =       {percent}
X*/
X       {
X       {0, 9, FALSE},  {17, 3, FALSE}, {17, 3, TRUE},  {17, 3, TRUE},
X       {17, 3, TRUE},  {17, 3, TRUE},  {17, 3, TRUE},  {17, 3, TRUE},
X       {17, 3, TRUE},  {16,10, TRUE},  {17, 3, TRUE},  {17, 3, TRUE},
X       {17, 1, FALSE}, {17,14, FALSE}, {17, 3, TRUE},  {17,13, FALSE},
X       {17, 3, TRUE},  {17, 3, TRUE},  {17, 3, TRUE},  {17, 3, TRUE},
X       {17, 3, TRUE},  {17, 3, TRUE},  {17, 3, TRUE},  {17, 3, TRUE},
X       {17, 3, TRUE},  {17, 3, TRUE}
X       },
X
X/*
X       STATE 10 =      {percent binary}
X*/
X       {
X       {0,10, FALSE},  {13, 3, FALSE}, {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {10,10, FALSE}, {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 1, FALSE}, {13,14, FALSE}, {13, 3, TRUE},  {13,13, FALSE},
X       {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},  {13, 3, TRUE},
X       {13, 3, TRUE},  {13, 3, TRUE}
X       },
X
X/*
X       STATE 11 =      {quote string}
X*/
X       {
X       {0,11, FALSE},  {4,11, FALSE},  {34, 3, TRUE},  {4,11, FALSE},
X       {18, 3, FALSE}, {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,21, FALSE}
X       },
X
X/*
X       STATE 12 =      {app string}
X*/
X       {
X       {0,12, FALSE},  {4,12, FALSE},  {34, 3, TRUE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {18, 3, FALSE}, {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,22, FALSE}
X       },
X
X/*
X       STATE 13 =      {greater than}
X*/
X       {
X       {0,13, FALSE},  {20, 3, FALSE}, {20, 3, TRUE},  {20, 3, TRUE},
X       {20, 3, TRUE},  {20, 3, TRUE},  {20, 3, TRUE},  {20, 3, TRUE},
X       {20, 3, TRUE},  {20, 3, TRUE},  {20, 3, TRUE},  {20, 3, TRUE},
X       {20, 1, FALSE}, {20,14, FALSE}, {19, 3, FALSE}, {20,13, FALSE},
X       {20, 3, TRUE},  {20, 3, TRUE},  {20, 3, TRUE},  {20, 3, TRUE},
X       {20, 3, TRUE},  {20, 3, TRUE},  {20, 3, TRUE},  {20, 3, TRUE},
X       {20, 3, TRUE},  {20, 3, TRUE}
X       },
X
X/*
X       STATE 14 =      {less than}
X*/
X       {
X       {0,14, FALSE},  {23, 3, FALSE}, {23, 3, TRUE},  {23, 3, TRUE},
X       {23, 3, TRUE},  {23, 3, TRUE},  {23, 3, TRUE},  {23, 3, TRUE},
X       {23, 3, TRUE},  {23, 3, TRUE},  {23, 3, TRUE},  {23, 3, TRUE},
X       {23, 1, FALSE}, {23,14, FALSE}, {21, 3, FALSE}, {22,13, FALSE},
X       {23, 3, TRUE},  {23, 3, TRUE},  {23, 3, TRUE},  {23, 3, TRUE},
X       {23, 3, TRUE},  {23, 3, TRUE},  {23, 3, TRUE},  {23, 3, TRUE},
X       {23, 3, TRUE},  {23, 3, TRUE}
X       },
X
X/*
X       STATE 15 =      {base 2 maybe}
X*/
X       {
X       {0,15, FALSE},  {29, 3, FALSE}, {29, 3, TRUE},  {29, 3, TRUE},
X       {29, 3, TRUE},  {29, 3, TRUE},  {29, 3, TRUE},  {29, 3, TRUE},
X       {29, 3, TRUE},  {24,15, FALSE}, {24,16, FALSE}, {24,17, FALSE},
X       {29, 1, FALSE}, {29,14, FALSE}, {29, 3, TRUE},  {29,13, FALSE},
X       {29, 3, TRUE},  {25,18, FALSE}, {0,19, FALSE},  {0,20, FALSE},
X       {30, 3, FALSE}, {28, 3, FALSE}, {26,18, FALSE}, {0,19, FALSE},
X       {0,20, FALSE},  {29, 3, TRUE}
X       },
X
X/*
X       STATE 16 =      {base 8 maybe}
X*/
X       {
X       {0,16, FALSE},  {29, 3, FALSE}, {29, 3, TRUE},  {29, 3, TRUE},
X       {29, 3, TRUE},  {29, 3, TRUE},  {29, 3, TRUE},  {29, 3, TRUE},
X       {29, 3, TRUE},  {24,16, FALSE}, {24,16, FALSE}, {24,17, FALSE},
X       {29, 1, FALSE}, {29,14, FALSE}, {29, 3, TRUE},  {29,13, FALSE},
X       {29, 3, TRUE},  {25,18, FALSE}, {25,18, FALSE}, {0,20, FALSE},
X       {30, 3, FALSE}, {28, 3, FALSE}, {26,18, FALSE}, {26,18, FALSE},
X       {0,20, FALSE},  {29, 3, TRUE}
X       },
X
X/*
X       STATE 17 =      {base10 maybe}
X*/
X       {
X       {0,17, FALSE},  {29, 3, FALSE}, {29, 3, TRUE},  {29, 3, TRUE},
X       {29, 3, TRUE},  {29, 3, TRUE},  {29, 3, TRUE},  {29, 3, TRUE},
X       {29, 3, TRUE},  {24,17, FALSE}, {24,17, FALSE}, {24,17, FALSE},
X       {29, 1, FALSE}, {29,14, FALSE}, {29, 3, TRUE},  {29,13, FALSE},
X       {29, 3, TRUE},  {25,18, FALSE}, {25,18, FALSE}, {0,20, FALSE},
X       {30, 3, FALSE}, {34, 3, FALSE}, {26,18, FALSE}, {26,18, FALSE},
X       {0,20, FALSE},  {29, 3, TRUE}
X       },
X
X/*
X       STATE 18 =      {hex}
X*/
X       {
X       {0,18, FALSE},  {34, 3, FALSE}, {34, 3, TRUE},  {34, 3, TRUE},
X       {34, 3, TRUE},  {34, 3, TRUE},  {34, 3, TRUE},  {34, 3, TRUE},
X       {34, 3, TRUE},  {24,18, FALSE}, {24,18, FALSE}, {24,18, FALSE},
X       {34, 1, FALSE}, {34,14, FALSE}, {34, 3, TRUE},  {34,13, FALSE},
X       {34, 3, TRUE},  {25,18, FALSE}, {25,18, FALSE}, {25,18, FALSE},
X       {30, 3, FALSE}, {34, 3, TRUE},  {26,18, FALSE}, {26,18, FALSE},
X       {26,18, FALSE}, {34, 3, TRUE}
X       },
X
X/*
X       STATE 19 =      {bin or hex}
X*/
X       {
X       {0,19, FALSE},  {27, 3, FALSE}, {27, 3, TRUE},  {27, 3, TRUE},
X       {27, 3, TRUE},  {27, 3, TRUE},  {27, 3, TRUE},  {27, 3, TRUE},
X       {27, 3, TRUE},  {31,18, TRUE},  {31,18, TRUE},  {31,18, TRUE},
X       {27, 1, FALSE}, {27,14, FALSE}, {27, 3, TRUE},  {27,13, FALSE},
X       {27, 3, TRUE},  {31,18, TRUE},  {31,18, TRUE},  {31,18, TRUE},
X       {31,18, TRUE},  {27, 3, TRUE},  {31,18, TRUE},  {31,18, TRUE},
X       {31,18, TRUE},  {27, 3, TRUE}
X       },
X
X/*
X       STATE 20 =      {dec or hex}
X*/
X       {
X       {0,20, FALSE},  {29, 3, FALSE}, {29, 3, TRUE},  {29, 3, TRUE},
X       {29, 3, TRUE},  {29, 3, TRUE},  {29, 3, TRUE},  {29, 3, TRUE},
X       {29, 3, TRUE},  {32,18, TRUE},  {32,18, TRUE},  {32,18, TRUE},
X       {29, 1, FALSE}, {29,14, FALSE}, {29, 3, TRUE},  {29,13, FALSE},
X       {29, 3, TRUE},  {32,18, TRUE},  {32,18, TRUE},  {32,18, TRUE},
X       {32,18, TRUE},  {29, 3, TRUE},  {32,18, TRUE},  {32,18, TRUE},
X       {32,18, TRUE},  {29, 3, TRUE}
X       },
X
X/*
X       STATE 21 =      {bslash quote}
X*/
X       {
X       {0,21, FALSE},  {4,11, FALSE},  {34, 3, TRUE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},  {4,11, FALSE},
X       {4,11, FALSE},  {4,11, FALSE}
X       },
X
X/*
X       STATE 22 =      {bslash appos}
X*/
X       {
X       {0,22, FALSE},  {4,12, FALSE},  {34, 3, TRUE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},  {4,12, FALSE},
X       {4,12, FALSE},  {4,12, FALSE}
X       }
X};
X
X#define YEXL 32
Xstatic char yytext[YEXL];
X
Xstatic char *erryytextex(type)
X       int type;
X{
X       char * strptr, *endptr;
X       int charcnt;
X
X       strptr = (lasttokfetch -> textstrt) - 1;
X       if(type == STRING)
X       {
X               endptr = (lasttokfetch -> textend) - 1;
X               if(*endptr == '\n')
X                       endptr --;
X       }
X       else
X       {
X               endptr = (lasttokfetch -> textend) - 2;
X       }
X
X       for(charcnt = 0; (strptr <= endptr) && charcnt < (YEXL - 1); charcnt ++)
X       {
X               yytext[charcnt] = *strptr++;
X       }
X       yytext[charcnt] = '\0';
X}
X
Xint yylex()
X{
X       int scanstate;
X       char *thistokstart;
X       register char nextchar;
X       int charset;
X       long consaccum, consbase;
X
X
X
X       if(currtok >= intokcnt)
X       {
X               switch(nextreadact)
X               {
X               case Nra_new:  /* access next file */
X                       fprintf(intermedf, "F:%s\n", infilestk[++currfstk].fnm);
X                       yyin = infilestk[currfstk].fpt;
X                       nextreadact = Nra_normal;
X               case Nra_normal:
X                       if(frareadrec())
X                       {
X                               /* EOF */;
X                               return 0;
X                       }
X                       break;
X
X               case Nra_end:  /* pop file and access previous */
X                       if(currfstk > 0)
X                       {
X                               fclose(yyin);
X                               yyin = infilestk[--currfstk].fpt;
X                               fprintf(intermedf, "X:%s\n",
X                                       infilestk[currfstk].fnm);
X                               if(frareadrec())
X                               {
X                                       /* EOF */;
X                                       return 0;
X                               }
X                               else
X                               {
X                                       nextreadact = Nra_normal;
X                               }
X                       }
X                       else
X                       {
X                               /* EOF */;
X                               return 0;
X                       }
X                       break;
X               }
X
X               if(listflag)
X               {
X                       fputs(finbuff, intermedf);
X               }
X               else
X               {
X                       fputs("L:\n", intermedf);
X               }
X
X               /* Scan a line */
X
X               frainptr = &finbuff[2];
X
X               currtok = intokcnt = 0;
X               nexttokload = & scanqueue[0];
X
X               tptrstr = &tempstrpool[0];
X               scanstate = 0;
X               whichsym = Symopcode;
X
X               while( (nextchar = *frainptr++) != '\0' )
X               {
X                       charset = chartrantab[nextchar & 0x7f];
X                       do {
X                               thisact =  & characttab [scanstate][charset];
X
X#if DEBUG
X       if(isprint(nextchar))
X               printf("%c    ", nextchar);
X       else
X               printf("0x%2.2x ", nextchar);
X       printf("%-18s %-33s %-11s  %2.2d\n",
X               statelab[scanstate],
X               actlab[thisact -> action],
X               thisact -> contin ? "Continue" : "Swallow",
X               thisact -> nextstate);
X#endif
X
X                               switch(thisact -> action)
X                               {
X                               case 0: /* skip/no op */
X                                       break;
X
X                               case 1: /* load EOL token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = EOL;
X                                       nexttokload -> errtype = Yetunprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 2: /* start string */
X                                       thistokstart = tptrstr;
X                                       nexttokload -> textstrt = frainptr;
X                                       break;
X
X                               case 3: /* process label */
X                                       {
X                       struct symel *tempsym;
X
X                       *tptrstr++ = '\0';
X                       tempsym = symbentry(thistokstart, SYMBOL);
X                       if((tempsym -> seg) != SSG_RESV)
X                       {
X                               nexttokload -> tokv = LABEL;
X                               nexttokload -> errtype = Yetsymbol;
X                               nexttokload -> lvalv.symb = tempsym;
X                       }
X                       else
X                       {
X                               nexttokload -> tokv = tempsym -> tok;
X                               nexttokload -> errtype = Yetreserved;
X                               nexttokload -> lvalv.intv = tempsym -> value;
X                       }
X                       nexttokload -> textend = frainptr;
X                       nexttokload++;
X                       intokcnt++;
X                                       }
X                                       break;
X
X                               case 4: /* save string char */
X                                       *tptrstr++ = nextchar;
X                                       break;
X
X                               case 5: /* load single char token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = nextchar;
X                                       nexttokload -> errtype = Yetprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 6: /* load EQ token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = KEOP_EQ;
X                                       nexttokload -> errtype = Yetunprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 7: /* process symbol */
X                                       {
X                       register struct symel *symp;
X                       register char *ytp;
X                       int tempov;
X
X                       *tptrstr++ = '\0';
X                       if(whichsym == Symopcode)
X                       {
X                               for(ytp = thistokstart; *ytp != '\0';
X                                       ytp++)
X                               {
X                                       if(islower(*ytp))
X                                       {
X                                               *ytp = toupper(*ytp);
X                                       }
X                               }
X                               nexttokload -> lvalv.intv
X                                       = tempov = findop(thistokstart);
X                               nexttokload -> tokv =
X                                       optab[tempov].token;
X                               nexttokload -> errtype = Yetopcode;
X                               whichsym = Symsym;
X                       }
X                       else
X                       {
X                               symp = symbentry(thistokstart,SYMBOL);
X                               if(symp -> seg != SSG_RESV)
X                               {
X                                       nexttokload -> lvalv.symb = symp;
X                                       nexttokload -> errtype = Yetsymbol;
X                               }
X                               else
X                               {
X                                       nexttokload -> lvalv.intv
X                                               = symp->value;
X                                       nexttokload -> errtype = Yetreserved;
X                               }
X
X                               nexttokload -> tokv = symp -> tok;
X                       }
X
X                       nexttokload -> textend = frainptr;
X                       nexttokload++;
X                       intokcnt++;
X                                       }
X                                       break;
X
X                               case 8: /* load $ token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = '$';
X                                       nexttokload -> errtype = Yetprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 9: /* setup for $hex */
X                                       consbase = 16;
X                                       consaccum = 0;
X                                       break;
X
X                               case 10: /* accumulate 0-9 constant */
X                                       consaccum = (consaccum * consbase)
X                                               + (nextchar - '0');
X                                       break;
X
X                               case 11: /* accumulate A-F constant  */
X                                       consaccum = (consaccum * consbase)
X                                               + (nextchar - 'A' + 10);
X                                       break;
X
X                               case 12: /* accumulate a-f constant */
X                                       consaccum = (consaccum * consbase)
X                                               + (nextchar - 'a' + 10);
X                                       break;
X
X                               case 13: /* load Constant token */
X                                       nexttokload -> lvalv.longv =
X                                               consaccum;
X                                       nexttokload -> tokv = CONSTANT;
X                                       nexttokload -> errtype = Yetconstant;
X                                       nexttokload -> textend = frainptr;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 14: /* load @ token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = '@';
X                                       nexttokload -> errtype = Yetprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 15: /* setup for @octal */
X                                       consbase = 8;
X                                       consaccum = 0;
X                                       break;
X
X                               case 16: /* setup for %binary */
X                                       consbase = 2;
X                                       consaccum = 0;
X                                       break;
X
X                               case 17: /* load % token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = '%';
X                                       nexttokload -> errtype = Yetprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 18: /* load String token */
X                                       *tptrstr++  = '\0';
X                                       nexttokload -> lvalv.strng =
X                                               thistokstart;
X                                       nexttokload -> tokv = STRING;
X                                       nexttokload -> errtype = Yetstring;
X                                       nexttokload -> textend = frainptr;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 19: /* load GE token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = KEOP_GE;
X                                       nexttokload -> errtype = Yetunprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 20: /* load GT token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = KEOP_GT;
X                                       nexttokload -> errtype = Yetunprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 21: /* load LE token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = KEOP_LE;
X                                       nexttokload -> errtype = Yetunprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 22: /* load NE token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = KEOP_NE;
X                                       nexttokload -> errtype = Yetunprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 23: /* load LT token */
X                                       nexttokload -> lvalv.longv = 0;
X                                       nexttokload -> tokv = KEOP_LT;
X                                       nexttokload -> errtype = Yetunprint;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X
X                               case 24: /* save numeric char 0-9 */
X                                       *tptrstr++ = nextchar - '0';
X                                       break;
X
X                               case 25: /* save numeric char A-F */
X                                       *tptrstr++ = nextchar - 'A' + 10;
X                                       break;
X
X                               case 26: /* save numeric char a-f */
X                                       *tptrstr++ = nextchar - 'a' + 10;
X                                       break;
X
X                               case 27: /* convert numeric string base 2 */
X                                       {
X                       consaccum = 0;
X                       while(thistokstart < tptrstr)
X                       {
X                               consaccum = (consaccum * 2) + *thistokstart++;
X                       }
X                       nexttokload -> lvalv.longv = consaccum;
X                       nexttokload -> tokv = CONSTANT;
X                       nexttokload -> errtype = Yetconstant;
X                       nexttokload -> textend = frainptr;
X                       nexttokload++;
X                       intokcnt++;
X                                       }
X                                       break;
X
X                               case 28: /* convert numeric string base 8 */
X                                       {
X                       consaccum = 0;
X                       while(thistokstart < tptrstr)
X                       {
X                               consaccum = (consaccum * 8) + *thistokstart++;
X                       }
X                       nexttokload -> lvalv.longv = consaccum;
X                       nexttokload -> tokv = CONSTANT;
X                       nexttokload -> errtype = Yetconstant;
X                       nexttokload -> textend = frainptr;
X                       nexttokload++;
X                       intokcnt++;
X                                       }
X                                       break;
X
X                               case 29: /* convert numeric string base 10 */
X                                       {
X                       consaccum = 0;
X                       while(thistokstart < tptrstr)
X                       {
X                               consaccum = (consaccum * 10) + *thistokstart++;
X                       }
X                       nexttokload -> lvalv.longv = consaccum;
X                       nexttokload -> tokv = CONSTANT;
X                       nexttokload -> errtype = Yetconstant;
X                       nexttokload -> textend = frainptr;
X                       nexttokload++;
X                       intokcnt++;
X                                       }
X                                       break;
X
X                               case 30: /* convert numeric string base 16 */
X                                       {
X                       consaccum = 0;
X                       while(thistokstart < tptrstr)
X                       {
X                               consaccum = (consaccum * 16) + *thistokstart++;
X                       }
X                       nexttokload -> lvalv.longv = consaccum;
X                       nexttokload -> tokv = CONSTANT;
X                       nexttokload -> errtype = Yetconstant;
X                       nexttokload -> textend = frainptr;
X                       nexttokload++;
X                       intokcnt++;
X                                       }
X                                       break;
X
X                               case 31: /* save numeric 0xb */
X                                       *tptrstr++ = 0xb;
X                                       break;
X
X                               case 32: /* save numeric 0xd */
X                                       *tptrstr++ = 0xd;
X                                       break;
X
X                               case 33: /* set text start */
X                                       nexttokload -> textstrt = frainptr;
X                                       break;
X
X                               case 34: /* token choke */
X                                       nexttokload -> lvalv.longv = 0L;
X                                       nexttokload -> tokv = KTK_invalid;
X                                       nexttokload -> errtype = Yetinvalid;
X                                       nexttokload -> textend = frainptr;
X                                       nexttokload++;
X                                       intokcnt++;
X                                       break;
X                               }
X
X                               scanstate = thisact -> nextstate;
X
X                       }  while( thisact -> contin);
X               }
X
X               if(intokcnt <= 0)
X               { /* no tokens in line (comment or whitespace overlength) */
X                       scanqueue[0].tokv = EOL;
X                       scanqueue[0].errtype = Yetunprint;
X                       scanqueue[0].lvalv.longv = 0;
X                       intokcnt = 1;
X               }
X
X               if(scanstate != 0)
X               { /* no EOL */
X                       fraerror("Overlength/Unterminated Line");
X               }
X       }
X       lasttokfetch = &scanqueue[currtok++];
X       yylval = lasttokfetch -> lvalv;
X       return lasttokfetch -> tokv;
X}
X
X
Xyyerror(str)
X       char *str;
X/*
X       description     first pass - output a parser error to intermediate file
X*/
X{
X       char * taglab;
X
X       switch(lasttokfetch -> errtype)
X       {
X       case Yetprint:
X               if( ! isprint(lasttokfetch -> tokv))
X               {
X                       fprintf(intermedf,
X                               "E: ERROR - %s at/before character \"^%c\"\n",
X                               str, PRINTCTRL(lasttokfetch -> tokv));
X               }
X               else
X               {
X                       fprintf(intermedf,
X                               "E: ERROR - %s at/before character \"%c\"\n",
X                               str, lasttokfetch -> tokv );
X               }
X               break;
X
X       case Yetsymbol:
X       case Yetreserved:
X       case Yetopcode:
X       case Yetconstant:
X               erryytextex(SYMBOL);
X               fprintf(intermedf, "E: ERROR - %s at/before token \"%s\" \n",
X                       str, yytext);
X               break;
X
X       case Yetinvalid:
X               erryytextex(SYMBOL);
X               fprintf(intermedf, "E: ERROR - %s at invalid token \"%s\" \n",
X                       str, yytext);
X               break;
X
X       case Yetstring:
X               erryytextex(STRING);
X               fprintf(intermedf, "E: ERROR - %s at/before string %s \n",
X                       str, yytext);
X               break;
X
X       case Yetunprint:
X               switch(lasttokfetch -> tokv)
X               {
X               case EOL:
X                       taglab = "End of Line";
X                       break;
X               case KEOP_EQ:
X                       taglab = "\"=\"";
X                       break;
X               case KEOP_GE:
X                       taglab = "\">=\"";
X                       break;
X               case KEOP_GT:
X                       taglab = "\">\"";
X                       break;
X               case KEOP_LE:
X                       taglab = "\"<=\"";
X                       break;
X               case KEOP_NE:
X                       taglab = "\"<>\"";
X                       break;
X               case KEOP_LT:
X                       taglab = "\"<\"";
X                       break;
X               default:
X                       taglab = "Undeterminable Symbol";
X                       break;
X               }
X               fprintf(intermedf, "E: ERROR - %s at/before %s\n",
X                       str, taglab);
X               break;
X
X       default:
X               fprintf(intermedf, "E: ERROR - %s - undetermined yyerror type\n"
,
X                       str);
X               break;
X       }
X
X       errorcnt++;
X}
SHAR_EOF
true || echo 'restore of fryylex.c failed'
fi
# ============= getopt.h ==============
if test -f 'getopt.h' -a X"$1" != X"-c"; then
        echo 'x - skipping getopt.h (File already exists)'
else
echo 'x - extracting getopt.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'getopt.h' &&
X
X
X/*
XHEADER:        ;
XTITLE:                 Frankenstein Cross Assemblers;
XVERSION:       2.0;
XDESCRIPTION: " Reconfigurable Cross-assembler producing Intel (TM)
X               Hex format object records.  ";
XSYSTEM:        UNIX, MS-Dos ;
XFILENAME:      getopt.h;
XWARNINGS:      "This is some ancient code I found on a version 7 system
X               when I was running the original port.  Asking for help from
X               the original authors is not advised.  (Especially after
X               the hack job I did on it.  Mark Zenier.)  "  ;
XSEE-ALSO:      frasmain.c;
XAUTHORS:       Keith Bostic, Rich $alz;
X*/
X/*
X**  This is a public domain version of getopt(3).
X**  Bugs, fixes to:
X**             Keith Bostic
X**                     ARPA: keith@seismo
X**                     UUCP: seismo!keith
X**  Added NO_STDIO, opterr handling, Rich $alz (mirror!rs).
X
X  Framework Cross Assembler
X       use strchr
X       remove NO_STDIO code
X       Mark Zenier     Specialized Systems Consultants, Inc.
X*/
X
X/*
X**  Error macro.  Maybe we want stdio, maybe we don't.
X**  The (undocumented?) variable opterr tells us whether or not
X**  to print errors.
X*/
X
X#define tell(s)
\
X       if (opterr)                                                     \
X           (void)fputs(*nargv, stderr),                                \
X           (void)fputs(s,stderr),                                      \
X           (void)fputc(optopt, stderr),                                \
X           (void)fputc('\n', stderr)
X
X
X
X/* Global variables. */
Xstatic char     EMSG[] = "";
Xint             opterr = 1;            /* undocumented error-suppressor*/
Xint             optind = 1;            /* index into argv vector       */
Xint             optopt;                /* char checked for validity    */
Xchar           *optarg;                /* arg associated with option   */
X
X
Xgetopt(nargc, nargv, ostr)
X    int                          nargc;
X    char               **nargv;
X    char                *ostr;
X{
X    static char                 *place = EMSG; /* option letter processing
*/
X    register char       *oli;          /* option letter list index     */
X
X    if (!*place)                       /* update scanning pointer      */
X    {
X       if (optind >= nargc || *(place = nargv[optind]) != '-' || !*++place)
X           return(EOF);
X       if (*place == '-')              /* found "--"                   */
X       {
X           optind++;
X           return(EOF);
X       }
X    }
X    /* option letter okay? */
X    if ((optopt = *place++) == ':' || (oli = strchr(ostr, optopt)) == NULL)
X    {
X       if (!*place)
X           optind++;
X       tell(": illegal option -- ");
X       goto Bad;
X    }
X    if (*++oli != ':')                 /* don't need argument          */
X    {
X       optarg = NULL;
X       if (!*place)
X           optind++;
X    }
X    else                               /* need an argument             */
X    {
X       if (*place)
X           optarg = place;             /* no white space               */
X       else
X           if (nargc <= ++optind)
X           {
X               place = EMSG;
X               tell(": option requires an argument -- ");
X               goto Bad;
X           }
X           else
X               optarg = nargv[optind]; /* white space                  */
X       place = EMSG;
X       optind++;
X    }
X    return(optopt);                    /* dump back option letter      */
XBad:
X    return('?');
X}
X
SHAR_EOF
true || echo 'restore of getopt.h failed'
fi
# ============= makefile.dos ==============
if test -f 'makefile.dos' -a X"$1" != X"-c"; then
        echo 'x - skipping makefile.dos (File already exists)'
else
echo 'x - extracting makefile.dos (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'makefile.dos' &&
X#
X# HEADER:      ;
X# TITLE:       Frankenstein Cross Assemblers;
X# VERSION:     2.0;
X# SYSTEM:      MS-DOS;
X# FILENAME:    makefile (dos);
X# DESCRIPTION: "Reconfigurable Cross-assembler producing Intel (TM)
X#              Hex format object records.  ";
X# KEYWORDS:    cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809,
X#              6811, tms7000, 8048, 8051, 8096, z8, z80;
X# WARNINGS:    "the bison simple parser, simple.prs in the version
X#              used, must be accessable.
X#
X#              The version of bison used produces output files named
X#              {name}.c and {name}.h as opposed to the original
X#              {name}.tab.[ch].
X#
X#              This software is in the public domain.
X#              Any prior copyright claims are relinquished.
X#
X#              This software is distributed with no warranty whatever.
X#              The author takes no responsibility for the consequences
X#              of its use.
X#
X#              Yacc (or Bison) required to compile."  ;
X# AUTHORS:     Mark Zenier;
X# COMPILERS:   Turbo C v 1.5, Bison (Cug disk 285, January 1989);
X#
X#      usage
X#              make -DTARGET=as1805
X#
X#
X#      Conditional Compilation Flags
X#
X#      DOSTMP          use the current directory for temporary intermediate
X#                      file
X#      NOGETOPT        use the getopt.h file
X#      USEINDEX        redefine the strchr() library function to use
X#                      the older equivalent name index()
X#      NOSTRING        use internal definitions if the <string.h> include
X#                      file does not exist
X#
X
XCFLAGS =
XYACCLEXLIB =
XLEXNEEDS =
XMAINNEEDS = -DDOSTMP -DNOGETOPT
XMAINDEPENDS = getopt.h
X
X
X$(TARGET) : frasmain.obj frapsub.obj fryylex.obj $(TARGET).obj fraosub.obj
X       tcc $(CFLAGS) -e$(TARGET) frasmain.obj frapsub.obj\
X               fraosub.obj fryylex.obj $(TARGET).obj $(YACCLEXLIB)
X       del fraytok.h
X
Xfrasmain.obj : frasmain.c  frasmdat.h $(MAINDEPENDS)
X       tcc $(CFLAGS) $(MAINNEEDS) -c frasmain.c
X
Xfryylex.obj : fryylex.c fraytok.h  frasmdat.h
X       tcc $(CFLAGS) $(LEXNEEDS) -c fryylex.c
X
X$(TARGET).c $(TARGET).h : $(TARGET).y
X       bison -d $(TARGET).y
X
Xfraytok.h : $(TARGET).h
X       copy $(TARGET).h fraytok.h
X
X$(TARGET).obj : $(TARGET).c  frasmdat.h fragcon.h
X       tcc $(CFLAGS) -c $(TARGET).c
X
Xfrapsub.obj : frapsub.c fragcon.h frasmdat.h fraeuni.h fraebin.h
X       tcc $(CFLAGS) -c frapsub.c
X
Xfraosub.obj : fraosub.c  frasmdat.h fragcon.h fraeuni.h fraebin.h
X       tcc $(CFLAGS) -c fraosub.c
X
SHAR_EOF
true || echo 'restore of makefile.dos failed'
fi
# ============= makeone.bat ==============
if test -f 'makeone.bat' -a X"$1" != X"-c"; then
        echo 'x - skipping makeone.bat (File already exists)'
else
echo 'x - extracting makeone.bat (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'makeone.bat' &&
Xmake -DTARGET=%1
X%1 -l test.out %1.tst
Xfc test.out %1.tut
SHAR_EOF
true || echo 'restore of makeone.bat failed'
fi
exit 0
