mirror of
https://github.com/RevCurtisP/C02.git
synced 2024-11-21 10:32:08 +00:00
Added tests for parsing routines
This commit is contained in:
Curtis F Kaylor
parent
a220bd0592
commit
5748b176dc
831
apps/a02.c02
831
apps/a02.c02
@ -1,103 +1,738 @@
|
||||
/* C02 Assembler */
|
||||
/* Simple 6502 Assembler *
|
||||
* for C02 Compiler *
|
||||
* Uses DASM Syntax but *
|
||||
* supports 65C02 Op Codes */
|
||||
|
||||
/* Address Modes */
|
||||
enum {ABS, //Absolute
|
||||
ABX, //Absolute,X
|
||||
ABY, //Absolute,Y
|
||||
ACC, //Accumulator
|
||||
IDX, //(Indirect,X)
|
||||
IIY, //(Indirect),Y
|
||||
IMD, //Immediate
|
||||
IMP, //Implied
|
||||
IND, //Indirect
|
||||
REL, //Relative
|
||||
ZPG, //Zero Page
|
||||
ZPX, //Zero Page,X
|
||||
ZPY, //Zero Page,X
|
||||
#define DEBUG %00000100 //Print Debug Information
|
||||
|
||||
//#include "a02lib.h02" - This will replace all the defs below
|
||||
#include <stddef.h02>
|
||||
#include <stdlib.h02>
|
||||
#include <stdio.h02>
|
||||
#include <stdiox.h02>
|
||||
#include <ctype.h02>
|
||||
#include <intlib.h02>
|
||||
#include <memory.h02>
|
||||
#include <string.h02>
|
||||
|
||||
alias char lcltbl = $E000; //Local Symbol Table
|
||||
alias char symtbl = $E100; //Global Symbol Table
|
||||
|
||||
/* Address Mode Constants, Bit Masks, and Descriptions */
|
||||
enum {ACMLT, IMMDT, ZPAGE, ZPAGX, ABSLT, ABSLX, ABSLY, IMPLD, INDCT, INDCX, INDCY, RELTV};
|
||||
const char amodlo = {$01, $02, $04, $08, $20, $40, $80, $00, $00, $00, $00, $00};
|
||||
const char amodhi = {$00, $00, $00, $00, $00, $00, $00, $01, $02, $04, $08, $10};
|
||||
const char amdesc = {"Accumulator", "Immediate", "Zero Page", "Zero Page,X",
|
||||
"Absolute", "Absolute,X", "Absolute,Y", "Implied",
|
||||
"(Indirect)", "(Indirect,X)", "(Indirect),Y", "Relative", 0};
|
||||
|
||||
/* Pseudo-Op Lookup Table */
|
||||
struct pso {char token, name[5];};
|
||||
const char psolst = {'B', "BYTE", 'H', "HEX", 'W', "WORD", '=', "EQU", 'F', "FILL",
|
||||
'I', "INCL", 'S', "SUBR", 'B', "DC", 'F', "DS", 'A', "ALIG",
|
||||
'*', "ORG", 'P', "PROC", 'E', "END", $FF};
|
||||
|
||||
/* Op Code Lookup Table */
|
||||
struct opc {int amode; char token, name[5];};
|
||||
const char opcalo = {$00, $00, $FE, $7D, $04, $04, $24, $26, $A6, $6E, $6C, $20, $20, $6E, $2C};
|
||||
const char opcahi = {$01, $10, $0E, $00, $00, $10, $00, $00, $00, $00, $00, $06, $00, $00, $00};
|
||||
const char opclst = {
|
||||
$00, 0, "BRK", $EA, 0, "NOP", $DB, 0, "STP", $CB, 0, "WAI", $CA, 0, "DEX",
|
||||
$88, 0, "DEY", $E8, 0, "INX", $C8, 0, "INY", $48, 0, "PHA", $08, 0, "PHP",
|
||||
$DA, 0, "PHX", $5A, 0, "PHY", $68, 0, "PLA", $28, 0, "PLP", $FA, 0, "PLX",
|
||||
$7A, 0, "PLY", $18, 0, "CLC", $D8, 0, "CLD", $58, 0, "CLI", $B8, 0, "CLV",
|
||||
$38, 0, "SEC", $F8, 0, "SED", $78, 0, "SEI", $AA, 0, "TAX", $A8, 0, "TAY",
|
||||
$BA, 0, "TSX", $8A, 0, "TXA", $98, 0, "TYA", $9A, 0, "TXS", $40, 0, "RTI",
|
||||
$60, 0, "RTS", $B0, 1, "BCS", $F0, 1, "BEQ", $30, 1, "BMI", $70, 1, "BVS",
|
||||
$90, 1, "BCC", $D0, 1, "BNE", $10, 1, "BPL", $50, 1, "BVC", $80, 1, "BRA",
|
||||
$A1, 2, "LDA", $61, 2, "ADC", $21, 2, "AND", $C1, 2, "CMP", $81, 2, "STA",
|
||||
$E1, 2, "SBC", $01, 2, "ORA", $41, 2, "EOR", $02, 3, "ASL", $22, 3, "ROL",
|
||||
$E2, 3, "INC", $42, 3, "LSR", $62, 3, "ROR", $C2, 3, "DEC", $07, 4, "RMB",
|
||||
$87, 4, "SMB", $0F, 5, "BBR", $8F, 5, "BBS", $10, 6, "TRB", $00, 6, "TSB",
|
||||
$E0, 7, "CPX", $C0, 7, "CPY", $A2, 8, "LDX", $82, 8, "STX", $20, 9, "BIT",
|
||||
$60, 10,"STZ", $4C, 11,"JMP", $14, 12,"JSR", $A0, 13,"LDY", $80, 14,"STY",
|
||||
$FF
|
||||
};
|
||||
|
||||
/* Op-Code Fixup Table */
|
||||
struct opf {char token, opmod, opcode;};
|
||||
const char opfix = {
|
||||
$20, $08, $89, $E0, $08, $E0, $C0, $08, $C0, $A0, $08, $A0, $A2, $08, $A2,
|
||||
$C2, $08, $3A, $E2, $08, $1A, $60, $0C, $9C, $60, $1C, $9E, $A2, $18, $BE,
|
||||
$82, $18, $BC, $4C, $0C, $4C, $4C, $11, $6C, $4C, $00, $7C, 0
|
||||
};
|
||||
|
||||
/* Temporary and Index Variables */
|
||||
char b, c, f, i, j, m, n, o, t, u;
|
||||
int v, w;
|
||||
|
||||
/* Function Variables */
|
||||
char found, match, opcode, opdfnd; //lookup(), asmpso(), asmopc()
|
||||
int addr; //fndsym()
|
||||
int opdval; //evlopd() values
|
||||
char hilo, opdrqd, prns, reqbyt, result; //evlopd() flags
|
||||
int addend; //adrslt()
|
||||
char digit; //evlhex()
|
||||
int term; //evltrm()
|
||||
|
||||
/* Symbol Table Entries */
|
||||
struct sym {char name[8], bytes; int value;};
|
||||
struct sym symbol; //Current Symbol
|
||||
struct sym varble; //Symbol to Lookup
|
||||
char symcnt, lclcnt; //Number of Global, Local Symbols
|
||||
int symptr, lclptr; //Pointer to Next Table Entry
|
||||
char symflg, symlcl; //Valid Symbol Value, Local Symbol
|
||||
|
||||
/* Input Variables */
|
||||
char inplin[128]; //Input Buffer
|
||||
char inpidx; //Index into Input Buffer
|
||||
char eoinp; //End of Input
|
||||
int lineno; //Input File Line Number
|
||||
|
||||
|
||||
/* Assembly Variables */
|
||||
char label[8]; //Assembly Line Label
|
||||
char mcode[8]; //Generated Machine Code
|
||||
char mnmnc[12]; //Opcode Mnemonic
|
||||
char oprnd[128]; //Opcode Mnemonic
|
||||
char cmmnt[128]; //Assembly Line Comment
|
||||
char strng[128]; //Parsed String
|
||||
|
||||
char word[128]; //Parsed Word
|
||||
char wrdlen; //Length of Parsed Word
|
||||
|
||||
int mcdadr; //Machine Code Address
|
||||
char mcdidx; //Index into mcode[]
|
||||
char opridx; //Index into oprnd[]
|
||||
|
||||
char endasm; //End Assembly
|
||||
char local,dot; //Local Symbol, Dot Prefix Flags
|
||||
char colon; //Colon after Label
|
||||
char token, opmod; //OpCode Token, Modifier
|
||||
char amflg, amidx; //Flag and Index - amodlo[], amodhi[]
|
||||
char amdlo, amdhi; //Addressing Modes
|
||||
char opvlo, opvhi; //Operand Value
|
||||
char zpflg; //ZeroPage Flag
|
||||
|
||||
char hexadr[6]; //Current Address in Hexadecimal
|
||||
char bytstr[5]; //String Representation of Byte
|
||||
|
||||
char orgset; //Origin Address Set
|
||||
int orgadr; //Origin Address
|
||||
int curadr; //Current Address
|
||||
int lstadr; //List Address
|
||||
|
||||
/* Print Error Message and Exit *
|
||||
* Args: Y,X = Address of Eror Message */
|
||||
void error() {
|
||||
putstr(); putstr(" ERROR"); newlin();
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* Op Code Indexes */
|
||||
enum {ADC, AND, ASL, BCC, BCS, BEQ, BIT, BMI, BNE, BPL, BRK, BVC, BVS, CLC,
|
||||
CLD, CLI, CLV, CMP, CPX, CPY, DEC, DEX, DEY, EOR, INC, INX, INY, JMP,
|
||||
JSR, LDA, LDX, LDY, LSR, NOP, ORA, PHA, PHP, PLA, PLP, ROL, ROR, RTI,
|
||||
RTS, SBC, SEC, SED, SEI, STA, STX, STY, TAX, TAY, TSX, TXA, TXS, TYA};
|
||||
|
||||
/* Op Code Mnemonic Lists */
|
||||
const char mnelst = {"ADC AND ASL CMP CPX CPY DEC EOR INC JMP JSR LDA LDX LDY LSR ORA ROL ROR SBC STA STX STY "};
|
||||
|
||||
const char implst = {"BRK CLC CLD CLI CLV DEX DEYINX INY NOP PHA PHP PLA PLP RTI RTSSEC SED SEI TAX TAY TSX TXA TXS TYA "};
|
||||
|
||||
const char rellst = {"BCC BCS BEQ BMI BNE BPL BVC BVS "};
|
||||
|
||||
/* Op Code Lookup Tables */
|
||||
const char ocilst = {//x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
|
||||
#BRK, #ORA, 255, 255, 255, #ORA, #ASL, 255, #PHP, #ORA, #ASL, 255, 255, #ORA, #ASL, 255, //0x
|
||||
#BPL, #ORA, 255, 255, 255, #ORA, #ASL, 255, #CLC, #ORA, 255, 255, 255, #ORA, #ASL, 255, //1x
|
||||
#JSR, #AND, 255, 255, #BIT, #AND, #ROL, 255, #PLP, #AND, #ROL, 255, #BIT, #AND, #ROL, 255, //2x
|
||||
#BMI, #AND, 255, 255, 255, #AND, #ROL, 255, #SEC, #AND, 255, 255, 255, #AND, #ROL, 255, //3x
|
||||
#RTI, #EOR, 255, 255, 255, #EOR, #LSR, 255, #PHA, #EOR, #LSR, 255, #JMP, #EOR, #LSR, 255, //4x
|
||||
#BVC, #EOR, 255, 255, 255, #EOR, #LSR, 255, #CLI, #EOR, 255, 255, 255, #EOR, #LSR, 255, //5x
|
||||
#RTS, #ADC, 255, 255, 255, #ADC, #ROR, 255, #PLA, #ADC, #ROR, 255, #JMP, #ADC, #ROR, 255, //6x
|
||||
#BVS, #ADC, 255, 255, 255, #ADC, #ROR, 255, #SEI, #ADC, 255, 255, 255, #ADC, #ROR, 255, //7x
|
||||
255, #STA, 255, 255, #STY, #STA, #STX, 255, #DEY, 255, #TXA, 255, #STY, #STA, #STX, 255, //8x
|
||||
#BCC, #STA, 255, 255, #STY, #STA, #STX, 255, #TYA, #STA, #TXS, 255, 255, #STA, 255, 255, //9x
|
||||
#LDY, #LDA, #LDX, 255, #LDY, #LDA, #LDX, 255, #TAY, #LDA, #TAX, 255, #LDY, #LDA, #LDX, 255, //Ax
|
||||
#BCS, #LDA, 255, 255, #LDY, #LDA, #LDX, 255, #CLV, #LDA, #TSX, 255, #LDY, #LDA, #LDX, 255, //Bx
|
||||
#CPY, #CMP, 255, 255, #CPY, #CMP, #DEC, 255, #INY, #CMP, #DEX, 255, #CPY, #CMP, #DEC, 255, //Cx
|
||||
#BNE, #CMP, 255, 255, 255, #CMP, #DEC, 255, #CLD, #CMP, 255, 255, 255, #CMP, #DEC, 255, //Dx
|
||||
#CPX, #SBC, 255, 255, #CPX, #SBC, #INC, 255, #INX, #SBC, #NOP, 255, #CPX, #SBC, #INC, 255, //Ex
|
||||
#BEQ, #SBC, 255, 255, 255, #SBC, #INC, 255, #SED, #SBC, 255, 255, 255, #SBC, #INC, 255 //Fx
|
||||
}
|
||||
|
||||
const char admlst = {//x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
|
||||
#IMP, #IDX, 255, 255, 255, #ZPG, #ZPG, 255, #IMP, #IMD, #ACC, 255, 255, #ABS, #ABS, 255, //0x
|
||||
#IMP, #IIY, 255, 255, 255, #ZPX, #ZPX, 255, #IMP, #ABY, 255, 255, 255, #ABX, #ABX, 255, //1x
|
||||
#IMP, #IDX, 255, 255, #ZPG, #ZPG, #ZPG, 255, #IMP, #IMD, #ACC, 255, #ABS, #ABS, #ABS, 255, //2x
|
||||
#IMP, #IIY, 255, 255, 255, #ZPX, #ZPX, 255, #IMP, #ABY, 255, 255, 255, #ABX, #ABX, 255, //3x
|
||||
#IMP, #IDX, 255, 255, 255, #ZPG, #ZPG, 255, #IMP, #IMD, #ACC, 255, #ABS, #ABS, #ABS, 255, //4x
|
||||
#IMP, #IIY, 255, 255, 255, #ZPX, #ZPX, 255, #IMP, #ABY, 255, 255, 255, #ABX, #ABX, 255, //5x
|
||||
#IMP, #IDX, 255, 255, 255, #ZPG, #ZPG, 255, #IMP, #IMD, #ACC, 255, #IND, #ABS, #ABS, 255, //6x
|
||||
#IMP, #IIY, 255, 255, 255, #ZPX, #ZPX, 255, #IMP, #ABY, 255, 255, 255, #ABX, #ABX, 255, //7x
|
||||
255, #IDX, 255, 255, #ZPG, #ZPG, #ZPG, 255, #IMP, 255, #IMP, 255, #ABS, #ABS, #ABS, 255, //8x
|
||||
#IMP, #IIY, 255, 255, #ZPX, #ZPX, #ZPY, 255, #IMP, #ABY, #IMP, 255, 255, #ABX, 255, 255, //9x
|
||||
#IMD, #IDX, #IMD, 255, #ZPG, #ZPG, #ZPG, 255, #IMP, #IMD, #IMP, 255, #ABS, #ABS, #ABS, 255, //Ax
|
||||
#IMP, #IIY, 255, 255, #ZPX, #ZPX, #ZPY, 255, #IMP, #ABY, #IMP, 255, #ABX, #ABX, #ABY, 255, //Bx
|
||||
#IMD, #IDX, 255, 255, #ZPG, #ZPG, #ZPG, 255, #IMP, #IMD, #IMP, 255, #ABS, #ABS, #ABS, 255, //Cx
|
||||
#IMP, #IIY, 255, 255, 255, #ZPX, #ZPX, 255, #IMP, #ABY, 255, 255, 255, #ABX, #ABX, 255, //Dx
|
||||
#IMD, #IDX, 255, 255, #ZPG, #ZPG, #ZPG, 255, #IMP, #IMD, #IMP, 255, #ABS, #ABS, #ABS, 255, //Ex
|
||||
#IMP, #IIY, 255, 255, 255, #ZPX, #ZPX, 255, #IMP, #ABY, 255, 255, 255, #ABX, #ABX, 255 //Fx
|
||||
}
|
||||
|
||||
char aa,ii,xx,yy; //Function Variables
|
||||
char ss[4];
|
||||
int yx;
|
||||
|
||||
/* Lookup Op Code Index Mnemonic *
|
||||
* Args: int Address of String *
|
||||
* char Address Mode *
|
||||
* Rets: char Op Code Index *
|
||||
* $FF = Not Found */
|
||||
char lkupmi(yx) {
|
||||
aa = strlen(yx); //Get Length of Mnemonic
|
||||
if (ii <> 3) //If Not 3
|
||||
return $FF; // Return Not Found
|
||||
setdst(ss); //Copy Mnemonic
|
||||
strcpy(yx); //to SS
|
||||
strapd(' '); //and Append a Space
|
||||
setdst(mnelst); //Return Position of
|
||||
return strstr(ss); //ss[] in mnelst[]
|
||||
}
|
||||
|
||||
/* Lookup Op Code *
|
||||
* Args: char Opcode Index *
|
||||
* char Address Mode *
|
||||
* Rets: char Op Code *
|
||||
* $FF = Not Found */
|
||||
char lkupoc(aa, yx) {
|
||||
ii = 0;
|
||||
/* Read Line of Input from Console *
|
||||
* Populates: inplin[] - Line of Input *
|
||||
* Sets: inpidx - Length of Line *
|
||||
* Destroys: c - Input Character *
|
||||
* Returns: True if End of Input */
|
||||
char readln() {
|
||||
inpidx = 0;
|
||||
do {
|
||||
if (ocilst[ii] == aa and admlst[ii] == yy) return ii;
|
||||
ii++;
|
||||
} while (ii);
|
||||
return $FF; //Opcode Not Found
|
||||
c = getchr();
|
||||
select (c) {
|
||||
case #RTNKEY: c = 0;
|
||||
case #ESCKEY: if (inpidx) c = 0; else return #TRUE;
|
||||
default:
|
||||
}
|
||||
inplin[inpidx] = c;
|
||||
inpidx++;
|
||||
if (inpidx:-) error("!INPUT OVERFLOW");
|
||||
} while (c);
|
||||
return #FALSE;
|
||||
}
|
||||
|
||||
void prtchr(c) {if (c) putchr(c);} //Print Non-Null Character
|
||||
void prtlin() {putstr(); newlin();} //Print String plus New Lin
|
||||
void prtbyt() {prbyte(); putchr(' ');} //Print Hexadecimal Word
|
||||
void echoln() {putchr('<'); putwrd(lineno); prtlin(inplin);}
|
||||
|
||||
void init() {
|
||||
if (#DEBUG&2) prtlin("#STARTING ASSEMBLY");
|
||||
lineno = 1; //Initialize Input File Line Number
|
||||
orgset = #FALSE; //Origin Not Set
|
||||
endasm = #FALSE; //End Assembly Fl
|
||||
symptr = &symtbl;
|
||||
lclptr = &lcltbl;
|
||||
}
|
||||
|
||||
/* Parse Word from Input Line *
|
||||
* Populates: word[] *
|
||||
* Sets: wrdlen *
|
||||
* Updates: inpidx *
|
||||
* Returns: Word Found (TRUE/FALSE) */
|
||||
char pword() {
|
||||
wrdlen = 0;
|
||||
while () {
|
||||
if (#DEBUG:-) putchr(inplin[inpidx]);
|
||||
c = touppr(inplin[inpidx]);
|
||||
if (c < 'A' or c > 'Z' and c <> '_') break;
|
||||
word[wrdlen] = c; wrdlen++;
|
||||
inpidx++;
|
||||
}
|
||||
word[wrdlen] = 0; //Terminate String
|
||||
if (wrdlen) return #TRUE; else return #FALSE;
|
||||
}
|
||||
|
||||
/* Skip Character in Input Line *
|
||||
* Args: c - Character to Skip *
|
||||
* Updates: inpidx *
|
||||
* Returns: c if found, else #FALSE */
|
||||
int skpchr(c) {
|
||||
if (inplin[inpidx] == c) {inpidx++; return c;}
|
||||
else return #FALSE;
|
||||
}
|
||||
|
||||
/* Skip Spaces in Input Line *
|
||||
* Updates: inpidx */
|
||||
void skpspc() {
|
||||
i = 0;
|
||||
while (inplin[inpidx]) {
|
||||
if (A > ' ') break;
|
||||
inpidx++;
|
||||
}
|
||||
}
|
||||
|
||||
/* Copy Character from Input Line to Operand *
|
||||
* Args: c = character to copy (0 = any) *
|
||||
* Updates: inpidx *
|
||||
* Returns: character matched */
|
||||
char cpychr(c) {
|
||||
o = touppr(inplin[inpidx]);
|
||||
if (c and o <> c) return #FALSE;
|
||||
if (opridx:+) {oprnd[opridx] = o; opridx++; }
|
||||
inpidx++;
|
||||
return #TRUE;
|
||||
}
|
||||
|
||||
/* Check Origin Address */
|
||||
void chkorg() {
|
||||
if (!orgset) error("ORIGIN NOT SET");
|
||||
}
|
||||
|
||||
/* Write Line of Machine Language Bytes */
|
||||
void wrtmcd() {
|
||||
putwrd(mcdadr);
|
||||
for (i=0; i<mcdidx; i++) puthex(mcode[i]);
|
||||
mcdidx = 0;
|
||||
}
|
||||
|
||||
/* Output Machine Language Character */
|
||||
void outchr(b) {
|
||||
chkorg();
|
||||
if (mcdidx > 7) {wrtmcd(); newlin();}
|
||||
if (!mcdidx) mcdadr = curadr;
|
||||
if (#DEBUG&64) {putstr("#OUT "); putwrd(curadr); prtbyt(b); newlin();}
|
||||
mcode[mcdidx] = b;
|
||||
mcdidx++;
|
||||
curadr++;
|
||||
}
|
||||
|
||||
/* Output Machine Language Byte */
|
||||
void outbyt() {
|
||||
outchr(X);
|
||||
}
|
||||
|
||||
/* Write Word to Output File */
|
||||
void outwrd(w) {
|
||||
outbyt(w);
|
||||
c = >w; outchr(c);
|
||||
}
|
||||
|
||||
/* Print Symbol Table */
|
||||
void prtsym(n, dstptr) {
|
||||
prtlin("SYMBOLS");
|
||||
for (i=0; i<n; i++) {
|
||||
for (j=0; j<@varble; j++) {varble[j] = *dstptr; dstptr++;}
|
||||
putstr("|"); putwrd(varble.value); prtbyt(varble.bytes); prtlin(varble.name);
|
||||
}
|
||||
}
|
||||
|
||||
void prtlcl() {
|
||||
if (lclcnt) {
|
||||
putstr("LOCAL ");
|
||||
prtsym(lclcnt, &lcltbl);
|
||||
}
|
||||
}
|
||||
|
||||
/* Find Symbol in Table *
|
||||
* Args: n = Number of Symbols in Table *
|
||||
* s = Address of Table *
|
||||
* Uses: word = Symbol Name *
|
||||
* Sets: srcptr = Address of Entry *
|
||||
* varble = Contents of Entry *
|
||||
* Destroys: dstptr *
|
||||
* Returns: TRUE if Symbol was Found */
|
||||
char fndsym(n, addr) {
|
||||
if (#DEBUG&4) {putstr("#SYMBOL "); putstr(word);}
|
||||
setdst(word); setsrc(addr);
|
||||
for (i=0; i<n; i++) {
|
||||
if (strcms(word)) {addsra(@varble); continue;}
|
||||
setdst(varble); memcpy(@varble);
|
||||
if (#DEBUG&4) prtlin(" FOUND ");
|
||||
return #TRUE;
|
||||
}
|
||||
if (#DEBUG&4) prtlin(" NOT FOUND ");
|
||||
return #FALSE;
|
||||
}
|
||||
|
||||
/* Set Symbol Value and Size */
|
||||
void setsym(b, v) {
|
||||
symbol.value = v;
|
||||
if (!b) b = (>symbol.value) ? 2 : 1;
|
||||
symbol.bytes = b;
|
||||
}
|
||||
|
||||
/* Parse Label from Input Line
|
||||
* Sets: label[] = Label Name
|
||||
* local = '.' if Local else 0.
|
||||
^ symbol.name = Label Name
|
||||
* symbol.value = Current Address
|
||||
* symbol.bytes = Size of Symbol Value
|
||||
* Updates: c */
|
||||
void plabel() {
|
||||
local = (skpchr('.')) ? '.' : 0; //Check for Local Label
|
||||
if (pword()) {
|
||||
if (wrdlen>8) error("!SYMBOL TOO LONG");
|
||||
setdst(label); strcpy(word);
|
||||
if (#DEBUG&2) {putstr("#FOUND "); if (local) putstr("LOCAL "); putstr("LABEL "); prtlin(label);}
|
||||
setdst(symbol.name);strcpy(label);
|
||||
setsym(0, curadr); symflg = orgset;
|
||||
} else {
|
||||
label[0] = 0;
|
||||
if (#DEBUG&2) prtlin("#NO LABEL FOUND");
|
||||
}
|
||||
colon = skpchr(':'); //Optional Colon after Label
|
||||
}
|
||||
|
||||
/* Parse Mnemonic from Input Line *
|
||||
* Sets: mnmnc *
|
||||
* Updates: inpidx *
|
||||
* Returns: Opcode Found (TRUE/FALSE) */
|
||||
char pmnmnc() {
|
||||
skpspc(); //Skip Leading Spaces
|
||||
dot = skpchr('.'); //Optional Dot before Pseudo-Op
|
||||
if (pword()) {
|
||||
if (wrdlen>12) error("!MNEMONIC TOO LONG");
|
||||
for (i=0; i<=wrdlen; i++) mnmnc[i] = word[i];
|
||||
if (#DEBUG&2) {putstr("#FOUND MNEMONIC "); prtlin(mnmnc);}
|
||||
} else {
|
||||
mnmnc[0] = 0;
|
||||
if (#DEBUG&2) prtlin("#NO MNEMONIC FOUND");
|
||||
}
|
||||
}
|
||||
|
||||
/* Look Up List Entry *
|
||||
* Args: amflg = get address modes *
|
||||
* srcptr = address of list *
|
||||
* Uses: mnmnc = mnemonic *
|
||||
* Sets: token = op code token *
|
||||
* amidx = address mode index *
|
||||
* Destroys: match *
|
||||
* Returns: TRUE if found */
|
||||
char lookup(amflg, srcptr) {
|
||||
if (#DEBUG:-) printf(setdst(amflg,srcptr), "LOOKUP(%x,%w)");
|
||||
while () { //Search Pseudo-Op List
|
||||
if (#DEBUG:-) printf(setdst(srcptr)," SRCPTR=%w");
|
||||
token = *srcptr; srcptr++; if (#DEBUG:-) printf(token, ", TOKEN=%d");
|
||||
if (token == $FF) break;
|
||||
if (amflg) {amidx = *srcptr; srcptr++; if (#DEBUG:-) printf(amidx, ", AMDIDX=%d");}
|
||||
match = #TRUE; if (#DEBUG:-) newlin();
|
||||
i = 0; //Offset into mnmnc
|
||||
while (*srcptr) {
|
||||
if (#DEBUG:-) {
|
||||
printf(setdst(*srcptr,srcptr)," (%w)=%d ");
|
||||
printf(i,", MNMNC[%d]="); putchr(mnmnc[i]); newlin();
|
||||
}
|
||||
if (*srcptr <> mnmnc[i]) match = #FALSE;
|
||||
if (#DEBUG:-) prtbyt(match);
|
||||
i++; srcptr++;
|
||||
}
|
||||
if (match) return #TRUE;
|
||||
srcptr++;
|
||||
}
|
||||
return #FALSE;
|
||||
}
|
||||
|
||||
/* Evaluate Binary Number */
|
||||
void evlbin() {
|
||||
term = 0;
|
||||
cpychr('%');
|
||||
while (isbdgt(inplin[inpidx])) {
|
||||
term<<; if (inplin[inpidx] & 1) term++;
|
||||
cpychr(0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Evaluate Character Constant */
|
||||
void evlchr() {
|
||||
cpychr('\'');
|
||||
term = int(inplin[inpidx]);
|
||||
cpychr(0);
|
||||
cpychr('\'');
|
||||
}
|
||||
|
||||
/* Evaluate Decimal Number */
|
||||
int evldec() {
|
||||
term = 0;
|
||||
while (isdigt(inplin[inpidx])) {
|
||||
term = imultc(10, term);
|
||||
term = iaddc(inplin[inpidx] - '0', term);
|
||||
cpychr(0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Evaluate Hexadecimal Number */
|
||||
int evlhex() {
|
||||
term = 0;
|
||||
cpychr('$');
|
||||
while (ishdgt(inplin[inpidx])) {
|
||||
digit = inplin[inpidx] - '0';
|
||||
if (digit > 9) digit = digit - 7;
|
||||
term<<; term<<; term<<; term<<;
|
||||
term = iaddc(digit, term);
|
||||
cpychr(0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Evaluate Term in Operand *
|
||||
* Updates: inpidx
|
||||
* Sets: term
|
||||
* Returns: #TRUE if a term was found */
|
||||
char evltrm() {
|
||||
skpspc();
|
||||
if (isalph(inplin[inpidx]) or inplin[inpidx] == '.') {
|
||||
if (evlsym()) term = symbol.value; else term = &$0100;
|
||||
}
|
||||
else if (isdigt(inplin[inpidx]))
|
||||
evldec();
|
||||
else select(inplin[inpidx]) {
|
||||
case '$': evlhex(); break;
|
||||
case '%': evlbin(); break;
|
||||
case '\'': evlchr(); break;
|
||||
default: return #FALSE;
|
||||
}
|
||||
skpspc();
|
||||
if (#DEBUG&2) {putstr("#TERM=$"); putwrd(term); newlin();}
|
||||
return #TRUE;
|
||||
}
|
||||
|
||||
char evlsym() {
|
||||
symlcl = cpychr('.'); //Check for Local Symbol
|
||||
if (!pword()) {if (symlcl) error("INVALID SYMBOL"); else return;}
|
||||
for (i=0; i<wrdlen; i++) {
|
||||
if (opridx:+) {oprnd[opridx] = word[i]; opridx++;}
|
||||
}
|
||||
if (symlcl) found = fndsym(lclcnt, &lcltbl);
|
||||
else found = fndsym(symcnt, &symtbl);
|
||||
if (found) opdval = symbol.value;
|
||||
else error("UNDEFINED SYMBOL");
|
||||
}
|
||||
|
||||
/* Evaluate Operand *
|
||||
* Args: maxsiz = maximum size *
|
||||
* Returns: Operand Value */
|
||||
char evlopd(opdrqd, reqbyt) {
|
||||
hilo = 0; //Return LSB (1) or MSB ($FF)
|
||||
prns = 0; //Optional Parenthesis after Hi/Low Operator
|
||||
skpspc();
|
||||
if (cpychr('<')) hilo = 1; else if (cpychr('>')) hilo = $FF;
|
||||
if (hilo) prns = cpychr('(');
|
||||
result = evltrm();
|
||||
if (result) {
|
||||
opdval = term;
|
||||
while (cpychr('+')) {
|
||||
if (!evltrm()) break;
|
||||
opdval = iadd(setdst(opdval),term);
|
||||
}
|
||||
}
|
||||
if (hilo) {
|
||||
if (!result) error("!ILLEGAL OPERAND");
|
||||
if (prns) cpychr(')'); //Skip End Parenthesis
|
||||
if (hilo:-) opdval = int(>opdval); //Copy MSB to LSB
|
||||
opdval = int(<opdval); //Return LSB
|
||||
}
|
||||
if (result) {
|
||||
if (#DEBUG&2) printf(setdst(opdval), "#OPERAND VALUE=%i%n");
|
||||
if (reqbyt & >opdval) error("!VALUE TOO LARGE");
|
||||
} else {
|
||||
if (#DEBUG&2) putln("#NO OPERAND");
|
||||
if (opdrqd) error("!OPERAND REQUIRED");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Assemble EQU Pseudo-Op */
|
||||
void asmequ() {
|
||||
if (!label[0]) error("!LABEL REQUIRED");
|
||||
evlopd(#TRUE, #FALSE);
|
||||
setsym(0,opdval); symflg = #TRUE;
|
||||
}
|
||||
|
||||
/* Assemble ORG Pseudo-Op */
|
||||
void asmorg() {
|
||||
if (evlopd(#TRUE, #FALSE)) orgadr = opdval;
|
||||
if (symbol.name[0]) {
|
||||
symbol.value = orgadr;
|
||||
symbol.bytes = 2;
|
||||
}
|
||||
curadr = orgadr;
|
||||
lstadr = orgadr;
|
||||
orgset = #TRUE;
|
||||
symflg = #TRUE;
|
||||
}
|
||||
|
||||
/* Assemble BYTE Pseudo-Op */
|
||||
void asmbyt() {
|
||||
do {
|
||||
if (cpychr('"')) { //String Operand
|
||||
while (!cpychr('"')) {outchr(inplin[inpidx]); cpychr(0); }
|
||||
skpspc();
|
||||
} else {
|
||||
if (evlopd(#TRUE, #TRUE)) outbyt(opdval); //Evaluate Operand
|
||||
}
|
||||
} while (cpychr(','));
|
||||
}
|
||||
|
||||
/* Assemble HEX Pseudo-Op */
|
||||
void asmhex() {
|
||||
do {
|
||||
evlhex(); outbyt(term);
|
||||
} while (cpychr(','));
|
||||
}
|
||||
|
||||
/* Assemble SUBROUTINE Pseudo-Op */
|
||||
void asmsub() {
|
||||
prtlcl();
|
||||
lclptr = &lcltbl; lclcnt = 0;
|
||||
}
|
||||
|
||||
/* Assemble WORD Pseudo-Op */
|
||||
void asmwrd() {
|
||||
do {
|
||||
evlopd(#TRUE, #FALSE); outwrd(opdval);
|
||||
} while (cpychr(','));
|
||||
}
|
||||
|
||||
/* Assemble ALIGN Pseudo-Op */
|
||||
void asmaln() {
|
||||
w = evlopd(#TRUE, #FALSE);
|
||||
opdval = 0;
|
||||
while(icmp(iacc(opdval),curadr):+) opdval = iadd(setdst(opdval),w);
|
||||
}
|
||||
|
||||
|
||||
/* Assemble Pseudo-Op */
|
||||
char asmpso() {
|
||||
found = lookup(#FALSE, psolst); //Lookup Pseudo-Op
|
||||
if (!found) {if (dot) error("ILLEGAL PSEUDO-OP"); else return #FALSE;}
|
||||
if (#DEBUG&2) prtlin("ASSEMBLING PSEUDO-OP");
|
||||
skpspc();
|
||||
select (token) {
|
||||
case '=': asmequ(); break; //EQU
|
||||
case '*': asmorg(); //ORG
|
||||
case 'B': asmbyt(); //BYTE
|
||||
case 'H': asmhex(); //HEX
|
||||
case 'W': asmwrd(); //WORD
|
||||
//case 'F': asmfll(); //FILL
|
||||
case 'S': asmsub(); //SUBRoutine
|
||||
//case 'I': asminf(); //INCLude
|
||||
//case '*': asmorg(); //ORG
|
||||
//case 'P': asmprc(); //PROCessor
|
||||
case 'A': asmaln(); //ALIGn
|
||||
case 'E': endasm = #TRUE; //END
|
||||
default: error("!UNIMPLEMENTED");
|
||||
}
|
||||
return #TRUE;
|
||||
}
|
||||
|
||||
/* Check for Valid Addressing Mode */
|
||||
int chkmod(m, f) {
|
||||
if (amodlo[m] & amdlo and amodhi[m] & amdhi) return #TRUE;
|
||||
if (f) error("ILLEGAL ADDRESS MODE");
|
||||
return #FALSE;
|
||||
}
|
||||
|
||||
|
||||
/* Assemble Implied/Accumulator/Absolute/ZeroPage Mode Instruction */
|
||||
void asmiaz() {
|
||||
opdfnd = evlopd(#FALSE, #FALSE);
|
||||
if (!opdfnd) {
|
||||
if (amidx and chkmod(#ACMLT, #TRUE)) opmod = $08; //Accumulator
|
||||
return;
|
||||
}
|
||||
if (>opdval) zpflg = #FALSE; else zpflg = #TRUE;
|
||||
if (zpflg and chkmod(#ZPAGE, #FALSE)) opmod = $04; //ZeroPage
|
||||
else {if (chkmod(#ABSLT, #TRUE)) opmod = $0C;} //Absolute
|
||||
}
|
||||
|
||||
/* Fix Opcode (if needed) */
|
||||
char fixopc() {
|
||||
//for (int i=0; opfix[i].token; i++)
|
||||
// if (opfix[i].token == token && opfix[i].opmod == opmod)
|
||||
// return opfix[i].opcode;
|
||||
return token + opmod;
|
||||
}
|
||||
|
||||
|
||||
/* Assemble Opcode */
|
||||
void asmopc() {
|
||||
opmod = 0;
|
||||
found = lookup(#TRUE, opclst); //Lookup OpCode
|
||||
if (!found) error("!ILLEGAL MNEMONIC");
|
||||
if (#DEBUG&2) {putstr("OPCODE: "); prtbyt(token); prtbyt(amidx);}
|
||||
amdlo = opcalo[amidx]; amdhi = opcahi[amidx];
|
||||
if (#DEBUG&2) {prbyte(amdhi); prbyte(amdlo); newlin();}
|
||||
|
||||
asmiaz(); //Assemble Implied/Accumulator/Absolute/ZeroPage Instruction
|
||||
opcode = fixopc(); //Fixup Opcode
|
||||
outchr(opcode);
|
||||
if (opdfnd) {if (zpflg) outbyt(opdval); else outwrd(opdval);}
|
||||
}
|
||||
|
||||
/* Parse Comment from Input Line
|
||||
* Sets: cmmnt[]
|
||||
* Updates: inpidx */
|
||||
void pcmmnt() {
|
||||
skpspc();
|
||||
i = 0;
|
||||
while (inplin[inpidx] >= ' ') {
|
||||
cmmnt[i] = inplin[inpidx];
|
||||
i++; inpidx++;
|
||||
}
|
||||
cmmnt[i] = 0; //Terminate Comment
|
||||
if (#DEBUG&2) {if (i) {putstr("#COMMENT: "); prtlin(cmmnt);} else prtlin("No Comment Found");}
|
||||
}
|
||||
|
||||
/* Copy Symbol Struct to Destination */
|
||||
void cpysym() {
|
||||
for (i=0; i<@symbol; i++) {
|
||||
*dstptr = symbol[i];
|
||||
dstptr++;
|
||||
}
|
||||
}
|
||||
|
||||
/* Add Label to Symbol Table */
|
||||
void addlcl() {
|
||||
dstptr = lclptr; cpysym(); lclptr = dstptr;
|
||||
lclcnt++;
|
||||
}
|
||||
|
||||
/* Add Label to Symbol Table */
|
||||
void addsym() {
|
||||
dstptr = symptr; cpysym(); symptr = dstptr;
|
||||
symcnt++;
|
||||
}
|
||||
|
||||
/* Print Listing Line */
|
||||
void prlist() {
|
||||
prtchr('|');
|
||||
prtchr(local); putstr(label); prtchr(colon); putchr(' ');
|
||||
prtchr(dot); putstr(mnmnc); putchr(' ');
|
||||
if (opridx) putstr(oprnd);
|
||||
prtlin(cmmnt);
|
||||
}
|
||||
|
||||
void asmlin() {
|
||||
lstadr = curadr; //Set List Address
|
||||
opridx = 0; //Clear Operand String
|
||||
mcdidx = 0; //Clear Macbine Code
|
||||
inpidx = 0; //Initialize Line Buffer Index
|
||||
plabel(); //Parse Label
|
||||
pmnmnc(); //Parse Mnemonic
|
||||
if (mnmnc[0]) {
|
||||
if (!asmpso()) asmopc(); //Assemble Pseudo-Op or Op-Code
|
||||
oprnd[opridx] = 0; //Set oprnd to ""
|
||||
}
|
||||
pcmmnt(); //Parse Comment
|
||||
if (label[0]) {
|
||||
if (!symflg) error("INVALID ADDRESS");
|
||||
if (local) addlcl(); else addsym(); //Add Label to Table
|
||||
}
|
||||
if (mcdidx) wrtmcd(); //Write Machine Code
|
||||
prlist();
|
||||
}
|
||||
|
||||
|
||||
main:
|
||||
init(); //Initialize Assembly Variables
|
||||
goto tests;
|
||||
while (!readln()) {
|
||||
if (#DEBUG&1) echoln();
|
||||
asmlin(); if (endasm) break;
|
||||
lineno++;
|
||||
}
|
||||
prtlcl(); prtsym(symcnt, &symtbl);
|
||||
goto exit;
|
||||
|
||||
/*======================================================*/
|
||||
/* Everything below here is tests for various functions */
|
||||
|
||||
//Copy Arg String to inplin
|
||||
void setln(w) {
|
||||
inpidx = 0;
|
||||
setdst(inplin);
|
||||
strcpy(w);
|
||||
putln(inplin);
|
||||
}
|
||||
|
||||
//Test function plabel
|
||||
void tlabel() {
|
||||
setln();
|
||||
plabel();
|
||||
if (label[0]) {
|
||||
setdst(label); printf(local," LABEL=\"%s\", LOCAL=%d%n");
|
||||
setdst(symbol.name); printf(" SYMBOL.NAME=\"%s\", ");
|
||||
setdst(symbol.value); printf(symbol.bytes,"BYTES=%d, VALUE=%i%n");
|
||||
}
|
||||
else putln("NO LABEL FOUND");
|
||||
curadr++;
|
||||
}
|
||||
|
||||
//Test function evltrm
|
||||
void tevtrm() {
|
||||
setln();
|
||||
if (evltrm()) printf(setdst(term)," TERM=%i%n");
|
||||
else putln("NO TERM FOUND");
|
||||
}
|
||||
|
||||
void tmnmnc() {
|
||||
setln();
|
||||
pmnmnc();
|
||||
//print results
|
||||
}
|
||||
|
||||
tests:
|
||||
orgadr = &$0300; orgset = #TRUE;
|
||||
curadr = orgadr;
|
||||
tlabel("FEE "); tlabel(".FI "); tlabel("FOE: "); tlabel(".FUM: ");
|
||||
tevtrm(" 12345"); tevtrm("%10101"); tevtrm("$1001 ");
|
||||
goto exit;
|
||||
|
||||
void dolkup() {
|
||||
found = lookup(#FALSE, psolst); if (#DEBUG:-) {prtbyt(found); newlin();}
|
||||
if (!found) {
|
||||
found = lookup(#TRUE, opclst); if (#DEBUG:-) {prtbyt(found); newlin();}
|
||||
}
|
||||
if (found) {prtbyt(token); prtbyt(amidx);} else putstr("*NOF* ");
|
||||
prtlin(mnmnc);
|
||||
}
|
||||
|
||||
tstlkp:
|
||||
setdst(mnmnc); strcpy("BYTE"); dolkup();
|
||||
setdst(mnmnc); strcpy("ORG"); dolkup();
|
||||
setdst(mnmnc); strcpy("SUBROUTINE"); dolkup();
|
||||
setdst(mnmnc); strcpy("BRK"); dolkup();
|
||||
setdst(mnmnc); strcpy("BEQ"); dolkup();
|
||||
setdst(mnmnc); strcpy("STY"); dolkup();
|
||||
setdst(mnmnc); strcpy("XXX"); dolkup();
|
||||
setdst(mnmnc); strcpy("INVALID"); dolkup();
|
||||
goto exit;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user