6502/C02
1
0
Fork 0
mirror of https://github.com/RevCurtisP/C02.git synced 2024-11-25 06:31:25 +00:00
Code Issues Projects Releases Wiki Activity

Added struct declarations

Browse Source
This commit is contained in:
Curtis F Kaylor 2018-03-08 08:23:05 -05:00
parent df34d89252
commit fd6a96afb5
5 changed files with 139 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/common.h
View File

@ -4,9 +4,13 @@
#define FNAMLEN 255 //Maximum File Name Length
#define LINELEN 255 //Maximum Input/Output Line Length
#define CONLEN 6 //Maximum Definition Text Length
#define MAXCON 255 //Maximum Number of Definitions
#define VARLEN 6 //Maximum Variable Length
#define CONLEN 6 //Maximum Constant Name Length
#define MAXCON 255 //Maximum Number of Constants
#define STCLEN 6 //Maximum Struct Name Length
#define MAXSTC 32 //Maximum Number of Stuctures
#define STMLEN 6 //Maximum Struct Member Name Length
#define MAXSTM 255 //Maximum Number of Stucture Members
#define VARLEN 6 //Maximum Variable Name Length
#define MAXVAR 255 //Maximum Number of Variables
#define MAXFNS 16 //Maximum Functions in Stack
#define DATASPC 2048 //Space to Allocate for Variable Data

11
src/dclrtn.c
View File

@ -92,6 +92,14 @@ void penum(int m) {
DEBUG("Enum Declaration Completed\n", 0)
}
/* Parse Enum Declaration*/
void pstrct(int m) {
DEBUG("Processing Struct Declarations\n", 0)
getwrd(); //Parse Structure Name
if (look('{')) defstc(); //Parse Struct Definition
else addstc(); //Parse and Compile Struct Declaration
SCMNT(""); //Clear Assembler Comment
}
/* Parse Variable/Function Declaration*/
void pdecl(int m, int t) {
@ -113,7 +121,8 @@ void pdecl(int m, int t) {
/* Check for and Parse Type Keyword */
int ptype(int m) {
int result = TRUE;
if (wordis("CONST")) pconst(m); //Parse 'const' declaration
if (wordis("STRUCT")) pstrct(m); //Parse 'const' declaration
else if (wordis("CONST")) pconst(m); //Parse 'const' declaration
else if (wordis("ENUM")) penum(m); //Parse 'enum' declaration
else if (wordis("CHAR")) pdecl(m, VTCHAR); //Parse 'char' declaration
else if (wordis("VOID")) pdecl(m, VTVOID); //Parse 'void' declaration

10
src/parse.h
View File

@ -4,7 +4,7 @@
#define TF(x) (x) ? TRUE : FALSE;
enum stypes {LITERAL, VARIABLE, REGISTER, ARRAY, FUNCTION}; //Symbol Types
enum stypes {LITERAL, VARIABLE, REGISTER, ARRAY, STRUCT, FUNCTION}; //Symbol Types
enum etypes {ETDEF, ETMAC}; //Definition Types
char nxtwrd[LINELEN]; //Next Word (from DEFINE lookup)
@ -14,10 +14,10 @@ int valtyp; //Value Type
char oper; //Arithmetic or Bitwise Operator
int litval; //Value of Parsed Literal
char connam[MAXCON+1][CONLEN+1]; //Definition Name Table
int conval[MAXCON+1]; //Definition Value Table
int concnt; //Number of Definitions Defined
int conidx; //Index into Definition Tables
char connam[MAXCON+1][CONLEN+1]; //Constant Name Table
int conval[MAXCON+1]; //Constant Value Table
int concnt; //Number of Constants Defined
int conidx; //Index into Constant Tables
int invasc; //Invert ASCII Flag
int mskasc; //Set High Bit Flag

90
src/vars.c
View File

@ -20,7 +20,7 @@
* varcnt if not found *
* Returns: TRUE if found, otherwise FALSE */
int fndvar(char *name) {
DEBUG("Looking up variable '%s'\n", word)
DEBUG("Looking up variable '%s'\n", name)
for (varidx=0; varidx<varcnt; varidx++)
if (strcmp(varnam[varidx], name) == 0) return TRUE;
return FALSE;
@ -120,14 +120,15 @@ void prsdat(void) {
}
/* Add Variable to Variable table *
* Uses: word - variable name *
* Uses: vrname - variable name *
* value - variable size */
void setvar(int m, int t) {
DEBUG("Added variable '%s' ", word);
DEBUG("Added variable '%s' ", vrname);
strncpy(varnam[varcnt], vrname, VARLEN);
varmod[varcnt] = m;
vartyp[varcnt] = t;
strncpy(varsiz[varcnt], value, 3);
varstc[varcnt] = (t == VTSTRUCT) ? stcidx : -1;
DETAIL("at index %d\n", varcnt);
}
@ -135,7 +136,7 @@ void setvar(int m, int t) {
* Uses: word - variable name */
void addvar(int m, int t) {
strcpy(vrname, word); //Save Variable Name
if (fndvar(vrname)) ERROR("Duplicate declaration of variable '%s\n", word,EXIT_FAILURE)
if (fndvar(vrname)) ERROR("Duplicate declaration of variable '%s\n", vrname, EXIT_FAILURE)
if (t == VTVOID) ERROR("Illegal Variable Type\n", 0, EXIT_FAILURE)
if (m == MTZP) {
setlbl(vrname);
@ -144,9 +145,10 @@ void addvar(int m, int t) {
strcpy(value, "*"); //Set Variable Type to Zero Page
}
else {
DEBUG("Checking for array definition\n", 0)
value[0] = 0;
if (match('[')) {
if (t == VTSTRUCT) {
DEBUG("Setting variable size to %d\n", stcsiz[stcidx])
sprintf(value, "%d", stcsiz[stcidx]);
} else if (match('[')) {
skpchr();
if (alcvar) {
DEBUG("Parsing array size\n", 0)
@ -154,10 +156,11 @@ void addvar(int m, int t) {
}
expect(']');
}
else value[0] = 0;
if (!alcvar) strcpy(value, "*");
setvar(m, t); //Add to Variable Table
}
if (m != MTZP) prsdat(); //Parse Variable Data
if (m != MTZP && t != VTSTRUCT ) prsdat(); //Parse Variable Data
varcnt++; //Increment Variable Counter
}
@ -199,3 +202,74 @@ void vartbl(void) {
}
vrwrtn = TRUE;
}
/* Lookup structure name in struct table *
* Sets: sctidx = index into sctnam array *
* sctcnt if not found *
* Returns: TRUE if found, otherwise FALSE */
int fndstc(char *name) {
DEBUG("Looking up struct '%s'\n", name)
for (stcidx=0; stcidx<stccnt; stcidx++)
if (strcmp(stcnam[stcidx], name) == 0) return TRUE;
return FALSE;
}
/* Lookup structure member name in table *
* Sets: stmidx = index into stmnam array *
* stmcnt if not found *
* Returns: TRUE if found, otherwise FALSE */
int fndstm(int stcidx, char *name) {
DEBUG("Looking up member '%s'\n", word)
for (stmidx=0; stmidx<stmcnt; stmidx++)
if (stmstc[stmidx] != stcidx) continue;
if (strcmp(stmnam[stmidx], name) == 0) return TRUE;
return FALSE;
}
/* Parse and Compile Struct Declaration */
void addstc(void) {
if (!fndstc(word)) ERROR("Undefined Struct '%s\n", word,EXIT_FAILURE)
getwrd(); //Get Variable Name
addvar(MTNONE, VTSTRUCT);
expect(';');
}
/* Parse Struct Definition *
* Uses: word - Struct Name */
void defstc(void) {
DEBUG("Parsing Struct Definition\n", 0)
if (fndstc(word)) ERROR("Duplicate Declaration of Struct '%s\n", word,EXIT_FAILURE)
strncpy(stcnam[stccnt], word, STCLEN);
DEBUG("Added struct '%s' ", word); DETAIL("at index %d\n", stccnt);
stclen = 0; //Initialize Struct Length
do {
getwrd(); //Get Member Name
if (wordis("CHAR")) getwrd(); //Skip Optional Type Declaration
if (fndstm(stccnt, word)) ERROR("Duplicate Declaration of Struct Member '%s\n", word,EXIT_FAILURE)
DEBUG("Adding member %s ", word) DETAIL("at index %d\n", stmcnt);
strncpy(stmnam[stmcnt], word, STMLEN);
DEBUG("Checking for array definition\n", 0)
if (match('[')) {
skpchr();
stmtyp[stmcnt] = ARRAY;
DEBUG("Parsing array size\n", 0)
stmsiz[stmcnt] = prsnum(0xFF) + 1;
expect(']');
}
else {
stmtyp[stmcnt] = VARIABLE;
stmsiz[stmcnt] = 1;
}
DEBUG("Set member type to %d", stmtyp[stmcnt]) DETAIL(" and size to %d\n", stmsiz[stmcnt]);
stclen += stmsiz[stmcnt];
expect(';');
stmcnt++;
} while (!look('}'));
expect(';');
//set stcsiz[
if (stclen > 256) ERROR("Structure Size %d Exceeds Limit of 256 bytes.\n", stclen, EXIT_FAILURE);
stcsiz[stccnt] = stclen;
DEBUG("Set struct size to %d\n", stclen);
stccnt++;
DEBUG("Struct Declaration Completed\n", 0)
}

58
src/vars.h
View File

@ -3,20 +3,30 @@
*************************************/
/* Variable Table */
char varnam[MAXVAR+1][VARLEN+1]; //Variable Name Table
char varmod[MAXVAR+1]; //Variable Modifier
char vartyp[MAXVAR+1]; //Variable Type
char varsiz[MAXVAR+1][4]; //Variable Array
int varcnt; //Number of Variables in Table
int varidx; //Index into Variable Tables
char vrname[MAXVAR+1]; //Variable Name
int vrwrtn; //Variables Written Flag
char varnam[MAXVAR+1][VARLEN+1]; //Variable Name Table
char varmod[MAXVAR+1]; //Variable Modifier
char vartyp[MAXVAR+1]; //Variable Type
char varsiz[MAXVAR+1][4]; //Variable Array Size
char varstc[MAXVAR+1]; //Variable Struct Type
int varcnt; //Number of Variables in Table
int varidx; //Index into Variable Tables
char vrname[MAXVAR+1]; //Variable Name
int vrwrtn; //Variables Written Flag
/*
int varidx; //Index into Variable Table
int vrtype; //Variable Type
*/
enum vtypes {VTVOID, VTCHAR}; //Variable Types
char stcnam[MAXSTC+1][STCLEN+1]; //Structure Name Table
int stcsiz[MAXSTC+1]; //Structure Size Table
int stccnt; //Number of Structs Defined
int stcidx; //Index into Struct Tables
int stclen; //Size of Current Struct
char stmnam[MAXSTM+1][STCLEN+1]; //Structure Member Name Table
int stmstc[MAXSTM+1]; //Structure Member Parent Struct
char stmtyp[MAXVAR+1]; //Structure Member Variable Type
int stmsiz[MAXVAR+1]; //Structure Member Array Size
int stmcnt; //Number of Struct Members Defined
int stmidx; //Index into Struct Member Tables
enum vtypes {VTVOID, VTCHAR, VTSTRUCT}; //Variable Types
char datvar[DATASPC+1]; //Variable Data Storage
char datlen[MAXVAR+1]; //Variable Data Length
@ -39,14 +49,16 @@ char prmtrx[VARLEN+1]; //Function Parameter X
char prmtry[VARLEN+1]; //Function Parameter Y
int prmcnt; //Number of Parameters
void addvar(int m, int t); //Parse and Compile Variable Declaration
void addvar(int m, int t); //Parse and Compile Variable Declaration
void addstc(); //Parse and Compile Structure Declaration
void defstc(); //Parse Structure Definition
void chksym(int alwreg, char *name); //Error if Variable not defined
void prsdts(); //Parse Data String
void setdat(); //Set Variable Data
void setvar(int m, int t); //Set Variable Name and Size
void prsdts(); //Parse Data String
void prsvar(int alwreg); //Parse Variable
void reqvar(int alwary); //Require and Parse Variable Name
void setdat(); //Store variable data
void setvar(int m, int t); //Add Variable to Variable table
void vartbl(); //Create Variable Table
void prsdts(); //Parse Data String
void setdat(); //Set Variable Data
void setvar(int m, int t); //Set Variable Name and Size
void prsdts(); //Parse Data String
void prsvar(int alwreg); //Parse Variable
void reqvar(int alwary); //Require and Parse Variable Name
void setdat(); //Store variable data
void setvar(int m, int t); //Add Variable to Variable table
void vartbl(); //Create Variable Table