#!/bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #!/bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
#	as6502.1
#	assm.d1
#	assm.d2
#	assm0.c
#	assm1.c
# This archive created: Tue Apr  2 14:21:10 1985
# By:	James Van Ornum (AT&T-Bell Laboratories)
export PATH; PATH=/bin:$PATH
if test -f 'as6502.1'
then
	echo shar: over-writing existing file "'as6502.1'"
fi
cat << \SHAR_EOF > 'as6502.1'
.TH AS6502 1 11/5/84 
.SH NAME
as6502 \- assembler for MOS Technology 650X microprocessors
.SH SYNOPSIS
.B as6502
[ option ] file ...
.SH DESCRIPTION
.I As6502
assembles the named files and produces
a listing on the standard output.
Available options are:
.TP 4
.B \-i
ignore .nlst pseudo ops in the source file.
.TP
.B \-l
produce only an error listing on the standard output.
.TP
.B \-n
print address in normal <high byte><low byte> format,
rather than split <low byte>:<high byte> format.
.TP
.B \-o
generate the ASCII object file
.B "6502.out."
The per-line format of that file is:
.br
    ;<address low byte><address high byte><data>...
.TP
.B \-s
print symbol table at the end of the assembly listing.
.TP
Symbol conventions:
.br
.tr ~|
Up to 19 alphanumeric (a-z ~ A-Z ~ 0-9 ~ . ~ _) characters,
.tr ~~
with initial character non-numeric.
.sp
Asterisk (*) is symbolic name of the location counter.
.TP
.B \-v
print version of assembler.
.TP
Op code mnemonics (upper and/or lower case):
.br
ADC   BIT   BVS   CPX   INC   LDX   PHP   RTI   SEI  TAY
.br
AND   BMI   CLC   CPY   INX   LDY   PLA   RTS   STA  TSX
.br
ASL   BNE   CLD   DEC   INY   LSR   PLP   SBC   STX  TXA
.br
BCC   BPL   CLI   DEX   JMP   NOP   ROL   SEC   STY  TXS
.br
BCS   BRK   CLV   DEY   JSR   ORA   ROR   SED   TAX  TYA
.br
BEQ   BVC   CMP   EOR   LDA   PHA
.TP
Pseudo op mnemonics:
.br
=      equate label to operand value.
.br
*=     equate location counter to operand value.
.br
 .WORD  assign 16 bit operand value to next 2 locations.
.br
 .DBYT  assign 16 bit value to next 2 locations, reverse.
.br
 .BYTE  assign 8 bit operand value to next location.
.br
 .NLST  turn listing mode off.
.br
 .LIST  turn listing mode on.
.TP
Constant types:
.br
%       binary number prefix.
.br
@ or 0  octal number prefix.
.br
$       hexadecimal number prefix.
.br
 '       ASCII character prefix.
.br
 "       ASCII character string prefix and suffix.
.br
default (leading digit 1 through 9)  decimal number.
.TP
Operand field operators:
.br
+     addition               ^     logical exclusive OR
.br
-     subtraction            ~     logical 1's complement
.br
/     integer division       $     logical AND
.br
.tr ||
*     multiplication         |     logical OR
.br
%     modulo                 <     low byte
.br
                             >     high byte
.SH FILES
.PD 0
.TP
/BIN/as6502   the assembler
.TP
6502.out      object (with -o option)
.SH "SEE ALSO"
.TP
J. H. Van Ornum, "as6502 User Notes"
.SH DIAGNOSTICS
.in 0
File handling diagnostics:
.in 15
.ti 5
Invalid argument count - as6502 invoked without a source file or
with too many source files.
.ti 5
Open error for file <name> - as6502 cannot open source file.
.ti 5
Create error (6502.out) - as6502 cannot create object file.
.ti 5
Close error - as6502 cannot close the source file.
.ti 5
Close error (6502.out) - as6502 cannot close object file.
.in 0
Assembly error diagnostics:
.in 15
.ti 5
Symbol table full - symbol table overflowed allotted space.
Number of symbols is a function of symbol sizes.
.ti 5
Label multiply defined - symbol defined more than once.
.ti 5
Sync error - the pass 2 value of symbol in the label field is different
than the pass 1 value.
.ti 5
Invalid operation code - op code mnemonic is invalid.
.ti 5
Operand field missing - the op code mnemonic requires an operand, and none was
found.
.ti 5
Invalid operand field - operand field contains an operator which is not
recognized by as6502.
.ti 5
Invalid branch address - branch instruction to a location which is out of range.
.ti 5
Invalid addressing mode - tried to use an addressing mode which is not
available to the operation code.
.ti 5
Operand field size error - operand is larger than hex FF.
.ti 5
Undefined symbol in operand field - a symbol in the operand field never
appeared in the label field.
.SH BUGS
SHAR_EOF
if test -f 'assm.d1'
then
	echo shar: over-writing existing file "'assm.d1'"
fi
cat << \SHAR_EOF > 'assm.d1'
#define LAST_CH_POS	132
#define SFIELD	23
#define STABSZ	16000
#define SBOLSZ	20

/*
 * symbol flags
 */
#define DEFZRO	2	/* defined - page zero address	*/
#define MDEF	3	/* multiply defined		*/
#define UNDEF	1	/* undefined - may be zero page */
#define DEFABS	4	/* defined - two byte address	*/
#define UNDEFAB 5	/* undefined - two byte address */

/*
 * operation code flags
 */
#define PSEUDO	0x6000
#define CLASS1	0x2000
#define CLASS2	0x4000
#define IMM1	0x1000		/* opval + 0x00	2 byte	*/
#define IMM2	0x0800		/* opval + 0x08	2 byte	*/
#define ABS	0x0400		/* opval + 0x0C	3 byte	*/
#define ZER	0x0200		/* opval + 0x04	2 byte	*/
#define INDX	0x0100		/* opval + 0x00	2 byte	*/
#define ABSY2	0x0080		/* opval + 0x1C	3 byte	*/
#define INDY	0x0040		/* opval + 0x10	2 byte	*/
#define ZERX	0x0020		/* opval + 0x14	2 byte	*/
#define ABSX	0x0010		/* opval + 0x1C	3 byte	*/
#define ABSY	0x0008		/* opval + 0x18	3 byte	*/
#define ACC	0x0004		/* opval + 0x08	1 byte	*/
#define IND	0x0002		/* opval + 0x2C	3 byte	*/
#define ZERY	0x0001		/* opval + 0x14	2 byte	*/

/*
 * pass flags
 */
#define FIRST_PASS	0
#define LAST_PASS	1
#define DONE		2
SHAR_EOF
if test -f 'assm.d2'
then
	echo shar: over-writing existing file "'assm.d2'"
fi
cat << \SHAR_EOF > 'assm.d2'
extern	FILE	*optr;
extern	FILE	*iptr;
extern	int	dflag;		/* debug flag */
extern	int	errcnt;		/* error counter */
extern	int	hash_tbl[];	/* pointers to starting links in symtab */
extern	char	hex[];		/* hexadecimal character buffer */
extern	int	iflag;		/* ignore .nlst flag */
extern	int	lablptr;	/* label pointer into symbol table */
extern	int	lflag;		/* disable listing flag */
extern	int	loccnt;		/* location counter	*/
extern	int	nflag;		/* normal/split address mode */
extern	int	nxt_free;	/* next free location in symtab */
extern	int	objcnt;		/* object byte counter */
extern	int	oflag;		/* object output flag */
extern	int	opflg;		/* operation code flags */
extern	int	opval;		/* operation code value */
extern	int	pass;		/* pass counter		*/
extern	char	prlnbuf[];	/* print line buffer	*/
extern	int	sflag;		/* symbol table output flag */
extern	int	slnum;		/* source line number counter */
extern	char	symtab[];	/* symbol table		*/
extern	char	symbol[];	/* temporary symbol storage	*/
extern	int	udtype;		/* undefined symbol type	*/
extern	int	undef;		/* undefined symbol in expression flg  */
extern	int	value;		/* operand field value */
extern	char	zpref;		/* zero page reference flag	*/
extern  int	msb;		/* most significant bit for bytes	*/
SHAR_EOF
if test -f 'assm0.c'
then
	echo shar: over-writing existing file "'assm0.c'"
fi
cat << \SHAR_EOF > 'assm0.c'
#include "stdio.h"
#include "assm.d1"

/*  Assembler for the MOS Technology 650X series of microprocessors
 *  Written by J. H. Van Ornum (201) 949-1781
 *		AT&T Bell Laboratories
 *		 Holmdel, NJ
 */

FILE	*optr;
FILE	*iptr;
int	dflag;			/* debug flag */
int	errcnt;			/* error counter */
int	hash_tbl[128];		/* pointers to starting links in symtab */
char	hex[5];			/* hexadecimal character buffer */
int	iflag;			/* ignore .nlst flag */
int	lablptr;		/* label pointer into symbol table */
int	lflag;			/* disable listing flag */
int	loccnt;			/* location counter	*/
int	nflag;			/* normal/split address mode */
int	nxt_free;		/* next free location in symtab */
int	objcnt;			/* object byte counter */
int	oflag;			/* object output flag */
int	opflg;			/* operation code flags */
int	opval;			/* operation code value */
int	pass;			/* pass counter		*/
char	prlnbuf[LAST_CH_POS+1]; /* print line buffer	*/
int	sflag;			/* symbol table output flag */
int	slnum;			/* source line number counter */
char	symtab[STABSZ];		/* symbol table		*/
				/* struct sym_tab		*/
				/* {	char	size;		*/
				/*	char	chars[size];	*/
				/*	char	flag;		*/
				/*	int	value;		*/
				/*	int	next_pointer	*/
				/* }				*/
char	symbol[SBOLSZ];		/* temporary symbol storage	*/
int	udtype;			/* undefined symbol type	*/
int	undef;			/* undefined symbol in expression flg  */
int	value;			/* operand field value */
char	zpref;			/* zero page reference flag	*/
int	msb	= 0x80 ;		/* hibit for bytes */


#define A	0x20)+('A'&0x1f))
#define B	0x20)+('B'&0x1f))
#define C	0x20)+('C'&0x1f))
#define D	0x20)+('D'&0x1f))
#define E	0x20)+('E'&0x1f))
#define F	0x20)+('F'&0x1f))
#define G	0x20)+('G'&0x1f))
#define H	0x20)+('H'&0x1f))
#define I	0x20)+('I'&0x1f))
#define J	0x20)+('J'&0x1f))
#define K	0x20)+('K'&0x1f))
#define L	0x20)+('L'&0x1f))
#define M	0x20)+('M'&0x1f))
#define N	0x20)+('N'&0x1f))
#define O	0x20)+('O'&0x1f))
#define P	0x20)+('P'&0x1f))
#define Q	0x20)+('Q'&0x1f))
#define R	0x20)+('R'&0x1f))
#define S	0x20)+('S'&0x1f))
#define T	0x20)+('T'&0x1f))
#define U	0x20)+('U'&0x1f))
#define V	0x20)+('V'&0x1f))
#define W	0x20)+('W'&0x1f))
#define X	0x20)+('X'&0x1f))
#define Y	0x20)+('Y'&0x1f))
#define Z	0x20)+('Z'&0x1f))

#define OPSIZE	127

int	optab[]	=		/* nmemonic  operation code table	*/
{				/* '.' = 31, '*' = 30, '=' = 29		*/
	((0*0x20)+(29)),PSEUDO,1,
	((0*0x20)+(29)),PSEUDO,1,
	((((0*D*S,PSEUDO,7,
	((((0*D*S,PSEUDO,7,
	((((0*D*W,PSEUDO,2,
	((((0*D*W,PSEUDO,2,
	((((0*0x20)+(30))*0x20)+(29)),PSEUDO,3,
	((((0*0x20)+(30))*0x20)+(29)),PSEUDO,3,
	((((((0*A*D*C,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0x61,
	((((((0*A*D*C,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0x61,
	((((((0*A*N*D,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0x21,
	((((((0*A*N*D,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0x21,
	((((((0*A*S*C,PSEUDO,8,
	((((((0*A*S*C,PSEUDO,8,
	((((((0*A*S*L,ABS|ZER|ZERX|ABSX|ACC,0x02,
	((((((0*A*S*L,ABS|ZER|ZERX|ABSX|ACC,0x02,
	((((((0*B*C*C,CLASS2,0x90,
	((((((0*B*C*C,CLASS2,0x90,
	((((((0*B*C*S,CLASS2,0xb0,
	((((((0*B*C*S,CLASS2,0xb0,
	((((((0*B*E*Q,CLASS2,0xf0,
	((((((0*B*E*Q,CLASS2,0xf0,
	((((((0*B*I*T,ABS|ZER,0x20,
	((((((0*B*I*T,ABS|ZER,0x20,
	((((((0*B*M*I,CLASS2,0x30,
	((((((0*B*M*I,CLASS2,0x30,
	((((((0*B*N*E,CLASS2,0xd0,
	((((((0*B*N*E,CLASS2,0xd0,
	((((((0*B*P*L,CLASS2,0x10,
	((((((0*B*P*L,CLASS2,0x10,
	((((((0*B*R*K,CLASS1,0x00,
	((((((0*B*R*K,CLASS1,0x00,
	((((((0*B*V*C,CLASS2,0x50,
	((((((0*B*V*C,CLASS2,0x50,
	((((((0*B*V*S,CLASS2,0x70,
	((((((0*B*V*S,CLASS2,0x70,
	((((((0*C*L*C,CLASS1,0x18,
	((((((0*C*L*C,CLASS1,0x18,
	((((((0*C*L*D,CLASS1,0xd8,
	((((((0*C*L*D,CLASS1,0xd8,
	((((((0*C*L*I,CLASS1,0x58,
	((((((0*C*L*I,CLASS1,0x58,
	((((((0*C*L*V,CLASS1,0xb8,
	((((((0*C*L*V,CLASS1,0xb8,
	((((((0*C*M*P,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0xc1,
	((((((0*C*M*P,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0xc1,
	((((((0*C*P*X,IMM1|ABS|ZER,0xe0,
	((((((0*C*P*X,IMM1|ABS|ZER,0xe0,
	((((((0*C*P*Y,IMM1|ABS|ZER,0xc0,
	((((((0*C*P*Y,IMM1|ABS|ZER,0xc0,
	((((((0*D*E*C,ABS|ZER|ZERX|ABSX,0xc2,
	((((((0*D*E*C,ABS|ZER|ZERX|ABSX,0xc2,
	((((((0*D*E*X,CLASS1,0xca,
	((((((0*D*E*X,CLASS1,0xca,
	((((((0*D*E*Y,CLASS1,0x88,
	((((((0*D*E*Y,CLASS1,0x88,
	((((((0*D*F*B,PSEUDO,0,
	((((((0*D*F*B,PSEUDO,0,
	((((((0*E*O*R,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0x41,
	((((((0*E*O*R,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0x41,
	((((((0*E*Q*U,PSEUDO,1,
	((((((0*E*Q*U,PSEUDO,1,
	((((((0*I*N*C,ABS|ZER|ZERX|ABSX,0xe2,
	((((((0*I*N*X,CLASS1,0xe8,
	((((((0*I*N*X,CLASS1,0xe8,
	((((((0*I*N*Y,CLASS1,0xc8,
	((((((0*I*N*Y,CLASS1,0xc8,
	((((((0*J*M*P,ABS|IND,0x40,
	((((((0*J*M*P,ABS|IND,0x40,
	((((((0*J*S*R,ABS,0x14,
	((((((0*L*D*A,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0xa1,
	((((((0*L*D*A,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0xa1,
	((((((0*L*D*X,IMM1|ABS|ZER|ABSY2|ZERY,0xa2,
	((((((0*L*D*X,IMM1|ABS|ZER|ABSY2|ZERY,0xa2,
	((((((0*L*D*Y,IMM1|ABS|ZER|ABSX|ZERX,0xa0,
	((((((0*L*D*Y,IMM1|ABS|ZER|ABSX|ZERX,0xa0,
	((((((0*L*S*R,ABS|ZER|ZERX|ABSX|ACC,0x42,
	((((((0*M*S*B,PSEUDO,13,
	((((((0*N*O*P,CLASS1,0xea,
	((((((0*O*R*A,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0x01,
	((((((0*O*R*G,PSEUDO,3,
	((((((0*O*R*G,PSEUDO,3,
	((((((0*P*H*A,CLASS1,0x48,
	((((((0*P*H*A,CLASS1,0x48,
	((((((0*P*H*P,CLASS1,0x08,
	((((((0*P*L*A,CLASS1,0x68,
	((((((0*P*L*A,CLASS1,0x68,
	((((((0*P*L*P,CLASS1,0x28,
	((((((0*P*L*P,CLASS1,0x28,
	((((((0*R*O*L,ABS|ZER|ZERX|ABSX|ACC,0x22,
	((((((0*R*O*L,ABS|ZER|ZERX|ABSX|ACC,0x22,
	((((((0*R*O*R,ABS|ZER|ZERX|ABSX|ACC,0x62,
	((((((0*R*O*R,ABS|ZER|ZERX|ABSX|ACC,0x62,
	((((((0*R*T*I,CLASS1,0x40,
	((((((0*R*T*S,CLASS1,0x60,
	((((((0*R*T*S,CLASS1,0x60,
	((((((0*S*B*C,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0xe1,
	((((((0*S*B*C,IMM2|ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0xe1,
	((((((0*S*E*C,CLASS1,0x38,
	((((((0*S*E*D,CLASS1,0xf8,
	((((((0*S*E*D,CLASS1,0xf8,
	((((((0*S*E*I,CLASS1,0x78,
	((((((0*S*E*I,CLASS1,0x78,
	((((((0*S*T*A,ABS|ZER|INDX|INDY|ZERX|ABSX|ABSY,0x81,
	((((((0*S*T*X,ABS|ZER|ZERY,0x82,
	((((((0*S*T*X,ABS|ZER|ZERY,0x82,
	((((((0*S*T*Y,ABS|ZER|ZERX,0x80,
	((((((0*T*A*X,CLASS1,0xaa,
	((((((0*T*A*X,CLASS1,0xaa,
	((((((0*T*A*Y,CLASS1,0xa8,
	((((((0*T*S*X,CLASS1,0xba,
	((((((0*T*S*X,CLASS1,0xba,
	((((((0*T*X*A,CLASS1,0x8a,
	((((((0*T*X*A,CLASS1,0x8a,
	((((((0*T*X*S,CLASS1,0x9a,
	((((((0*T*X*S,CLASS1,0x9a,
	((((((0*T*Y*A,CLASS1,0x98,
	((((((0*T*Y*A,CLASS1,0x98,
	((((((0*0x20)+(31))*W*O^((((0*R*D,PSEUDO,2,	/* 0x7cab */
	((((((0*0x20)+(31))*W*O^((((0*R*D,PSEUDO,2,	/* 0x7cab */
	((((((0*0x20)+(31))*B*Y^((((0*T*E,PSEUDO,0,	/* 0x7edc */
	((((((0*0x20)+(31))*B*Y^((((0*T*E,PSEUDO,0,	/* 0x7edc */
	((((((0*0x20)+(31))*D*B^((((0*Y*T,PSEUDO,6,	/* 0x7fb6 */
	((((((0*0x20)+(31))*N*L^((((0*S*T,PSEUDO,5,	/* 0x7fb8 */
	((((((0*0x20)+(31))*L*I^((((0*S*T,PSEUDO,4,	/* 0x7ffd */
	0x7fff,0,0,
	0x7fff,0,0,
	0x7fff,0,0,
	0x7fff,0,0
};

int	step[] =
{
	3*((OPSIZE+1)/2),
	3*((((OPSIZE+1)/2)+1)/2),
	3*((((((OPSIZE+1)/2)+1)/2)+1)/2),
	3*((((((((OPSIZE+1)/2)+1)/2)+1)/2)+1)/2),
	3*(4),
	3*(3),
	3*(2),
	3*(1),
	0
};
SHAR_EOF
if test -f 'assm1.c'
then
	echo shar: over-writing existing file "'assm1.c'"
fi
cat << \SHAR_EOF > 'assm1.c'
#include "stdio.h"
#include "assm.d1"
#include "assm.d2"

#define CPMEOF EOF

/*
 *  Two changes to version 1.4 have been made to "port" as6502 to CP/M(tm).
 *  A "tolower()" function call was add to the command line processing
 *  code to (re)map the command line arguments to lower case (CP/M
 *  converts all command line arguments to upper case).  The readline()
 *  function has code added to "ignore" the '\r' character (CP/M includes
 *  the \r character along with \n).
 *
 *  Also, the ability to process multiple files on the command line has been
 *  added.  Now one can do, for example:
 *
 *	as6502 -nisvo header.file source.file data.file ...
 *
 *    George V. Wilder
 *	IX 1A-360 x1937
 *	ihuxp!gvw1
 */

main(argc, argv)
   int	argc;
   char *argv[];
{
	char	c;
	int	cnt;
	int	i;
	int	ac;
	char	**av;

	while (--argc > 0 && (*++argv)[0] == '-') {
		for (i = 1; (c =  ((*argv)[i])) != '\0'; i++) {
			c |= 0x20 ;  /* make it lower case - tm */
			if (c == 'd')		/* debug flag */
				dflag++;
			if (c == 'i')		/* ignore .nlst flag */
				iflag++;
			if (c == 'l')		/* disable listing flag */
				lflag--;
			if (c == 'n')		/* normal/split address mode */
				nflag++;
			if (c == 'o')		/* object output flag */
				oflag++;
			if (c == 's')		/* list symbol table flag */
				sflag++;
			if (c == 'v')		/* print assembler version */
				fprintf(stdout, "as6502 - version 4.1b - 11/22/84 - JHV [gvw]\n");
		}
	}
	ac = argc;
	av = argv;
	pass = FIRST_PASS;
	for (i = 0; i < 128; i++)
		hash_tbl[i] = -1;
	errcnt = loccnt = slnum = 0;
	while (pass != DONE) {
		initialize(ac, av, argc);
		if(pass == LAST_PASS && ac == argc)
			errcnt = loccnt = slnum = 0;
		while (readline() != -1)
			assemble();
		if (errcnt != 0) {
			pass = DONE;
			fprintf(stderr, "Terminated with error counter = %d\n", errcnt);
		}
		switch (pass) {
		case FIRST_PASS:
			--ac;
			++av;
			if(ac == 0) {
				pass = LAST_PASS;
				if (lflag == 0)
					lflag++;
				ac = argc;
				av = argv;
			}
			break;
		case LAST_PASS:
			--ac;
			++av;
			if(ac == 0) {
				pass = DONE;
				if (sflag != 0)
					stprnt();
			}
		}
		wrapup();
		if ((dflag != 0) && (pass == LAST_PASS)) {
			fprintf(stdout, "nxt_free = %d\n", nxt_free);
			cnt = 0;
			for (i = 0; i < 128; i++)
				if (hash_tbl[i] == -1)
					cnt++;
			fprintf(stdout, "%d unused hash table pointers out of 128\n", cnt);
		}
	}
	return(0);
}

/*****************************************************************************/

/* initialize opens files */

initialize(ac, av, argc)
   int	ac;
   char *av[];
   int  argc;
{

	if (ac == 0) {
		fprintf(stderr, "Invalid argument count (%d).\n", argc);
		exit(1);
	}
	if ((iptr = fopen(*av, "r")) == NULL) {
		fprintf(stderr, "Open error for file '%s'.\n", *av);
		exit(1);
	}
	if ((pass == LAST_PASS) && (oflag != 0) && ac == argc) {
		if ((optr = fopen("6502.out", "w")) == NULL) {
			fprintf(stderr, "Create error for object file 6502.out.\n");
			exit(1);
		}
		else fprintf(optr,"CALL -151"); /* let monitor do loading */
	}
}

/* readline reads and formats an input line	*/

int	field[] =
{
	SFIELD,
	SFIELD + 8,
	SFIELD + 14,
	SFIELD + 23,
	SFIELD + 43,
	SFIELD + 75
};

readline()
{
	int	i;		/* pointer into prlnbuf */
	int	j;		/* pointer to current field start	*/
	int	ch;		/* current character		*/
	int	cmnt;		/* comment line flag	*/
	int	spcnt;		/* consecutive space counter	*/
	int	string;		/* ASCII string flag	*/
	int	temp1;		/* temp used for line number conversion */

	temp1 = ++slnum;
	for (i = 0; i < LAST_CH_POS; i++)
		prlnbuf[i] = ' ';
	i = 3;
	while (temp1 != 0) {	/* put source line number into prlnbuf */
		prlnbuf[i--] = temp1 % 10 + '0';
		temp1 /= 10;
	}
	i = SFIELD;
	cmnt = spcnt = string = 0;
	j = 1;
	while ((ch = getc(iptr)) != '\n') {
		if(ch == '\r')
			continue;
		prlnbuf[i++] = ch;
		if ((ch == ' ') && (string == 0)) {
			if (spcnt != 0)
				--i;
			else if (cmnt == 0) {
				++spcnt;
				if (i < field[j])
					i = field[j];
				if (++j > 3) {
					spcnt = 0;
					++cmnt;
				}
			}
		}
		else if (ch == '\t') {
			prlnbuf[i - 1] = ' ';
			spcnt = 0;
			if (cmnt == 0) {
				if (i < field[j])
					i = field[j];
				if (++j > 3)
					++cmnt;
			}
			else i = (i + 8) & 0x78;
		}
		else if ((ch == ';') && (string == 0)) {
			spcnt = 0;
			if (i == SFIELD + 1)
				++cmnt;
			else if (prlnbuf[i - 2] != '\'') {
				++cmnt;
				prlnbuf[i-1] = ' ';
				if (i < field[3])
					i = field[3];
				prlnbuf[i++] = ';';
			}
		}
		else if (ch == EOF || ch == CPMEOF)
			return(-1);
		else {
			if ((ch == '"' || ch == '\'' ) && (cmnt == 0))
				string = string ^ 1;
			spcnt = 0;
			if (i >= LAST_CH_POS - 1)
				--i;
		}
	}
	prlnbuf[i] = 0;
	return(0);
}

/*
 * wrapup() closes the source file
 */

wrapup()
{

	fclose(iptr);
	if ((pass == DONE) && (oflag != 0)) {
		fputc('\n', optr);
		fclose(optr);
	}
	return;
}

/* symbol table print
 */

stprnt()
{
	int	i;
	int	j;
	int	k;

	fputc('\014', stdout);
	fputc('\n', stdout);
	i = 0;
	while	((j = symtab[i++]) != 0) {
		for (k = j; k > 0; k--)
			fputc(symtab[i++], stdout);
		for (k = 20 - j; k > 0; k--)
			fputc(' ', stdout);
		++i;
		j = (symtab[i++] & 0xff);
		j += (symtab[i++] << 8);
		hexcon(4, j);
		fprintf(stdout, "\t%c%c:%c%c\t%c%c%c%c\n",
			hex[3], hex[4], hex[1], hex[2],
			hex[1], hex[2], hex[3], hex[4]);
		i += 2;
	}
}
SHAR_EOF
#	End of shell archive
exit 0
