Path: utzoo!utgpu!cs.utexas.edu!uunet!pilchuck!ssc!markz
From: markz@ssc.UUCP (Mark Zenier)
Newsgroups: alt.sources
Subject: Frankenstein Cross Assemblers, Base source, Part 3 of 3
Message-ID: <594@ssc.UUCP>
Date: 4 Dec 90 07:49:20 GMT
Organization: SSC, Inc., Seattle, WA
Lines: 1314
Archive-name: Frankasm/Base03
Submitted-by: markz@ssc.uucp

---- Cut Here and feed the following to sh ----
#!/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


Brought to you by Super Global Mega Corp .com