#!/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 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 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