I would have looked at it with a debugger, but alas it
does not compile.
I was cutting it down and didn't test it.
My working copy is now included. I also included one of the
test inputs.
(a few more output spam debug statements,but it compiles.)
I'm trying to get gcc to compile with debugging symbols so I can
use gdb. Not having a whole lot of luck.
-Grant "needs a better newsreader" Austin
list.h
#ifndef _LIST_H
#define _LIST_H
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
/* list structures */
struct motNode {
struct motNode * next;
unsigned int opCode;
char type;
unsigned int numArgs;
char *opName;
};
typedef struct motNode motList;
struct lcNode{
struct lcNode *next;
unsigned int lc;
};
typedef struct lcNode lcList;
struct hashNode{
struct hashNode * next;
lcList * lc_head;
int defined; /*boolean flag non-zero is defined*/
unsigned int lc;
char *symbol;
};
typedef struct hashNode hashList;
/* end list structures */
/* hash function */
int hash(char * s, int T){
int
h = 0; /* holds number for bit-wise ops */
int
a = 127;
for (; *s != 0; s++)
h = (a * h + *s) % T;
return h;
}
/* end hash function */
int lcList_insert(lcList **lc_head, unsigned int lc){
lcList *lc_cur = malloc(sizeof *lc_cur);
if(lc_cur == NULL) return 0;
lc_cur->lc = lc;
lc_cur->next = *lc_head;
*lc_head = lc_cur;
return 1;
}
void lcList_free(lcList **lc_cur){
printf("lclist free\n");
lcList *tmp;
for( ; *lc_cur; *lc_cur = tmp){
tmp = (*lc_cur)->next;
free(*lc_cur);
}
return;
}
void lcList_dump(lcList * lc_cur){
while(lc_cur){
printf("lc dump :: %d\n",lc_cur->lc);
lc_cur = lc_cur->next;
}
}
hashList * hash_search(hashList *hash_cur, char * symbol){
printf("hashcur %u\n",hash_cur);
if(hash_cur == NULL) return hash_cur;
while(hash_cur){
if(strcmp(hash_cur->symbol,symbol) == 0){
printf("symbol %s found in %d\n",symbol,hash_cur);
return hash_cur;
}
else {
printf("1else %u %u\n",hash_cur,hash_cur->next);
hash_cur = hash_cur->next;
}
}
printf("end hash search for %s : hash_cur %d\n",symbol,hash_cur);
return hash_cur;
}
int hash_insert(hashList * hash_head[], int defined, unsigned int lc,
char * symbol){
/*
return 0 if unable to insert, return 1 if success, -1 for
other error
care must be taken so that a symbol is not set as defined
without the correct lc value.
*/
unsigned int hidx;
hashList * hash_cur = malloc(sizeof *hash_cur);
hashList * hash_test = NULL;
if(hash_cur == NULL) return 0;
hidx = hash(symbol,22);
printf("Symbol : %s\n",symbol);
printf("hidx : %d\n",hidx);
printf("lc : %d\n",lc);
if((hash_cur->symbol = malloc(strlen(symbol)+1)) == NULL){
free(hash_cur);
return -1;
}
strcpy(hash_cur->symbol,symbol);
hash_cur->defined = defined;
hash_cur->lc = lc;
hash_cur->lc_head = NULL;
hash_cur->next = hash_head[hidx];
hash_head[hidx] = hash_cur;
printf("inserted\n");
return 1;
}
unsigned int isDefined(hashList * hash_head[], char * symbol){
/* returns 1 if symbol is defined, 0 else */
unsigned int hidx;
printf("IsDEFINED FN\n");
hashList * hash_test = malloc(sizeof *hash_test);
hidx = hash(symbol,22);
printf("PRESEARCH\n");
if ((hash_test = hash_search(hash_head[hidx], symbol)) != NULL){
printf("POSTSEARCH\n");
return hash_test->defined;
}
printf("POST @\n");
return 0;
}
unsigned int symDefine(hashList * hash_head[], char * symbol,unsigned int lc){
unsigned int hidx;
hashList *hash_test = malloc(sizeof *hash_test);
hidx = hash(symbol,22);
if ((hash_test = hash_search(hash_head[hidx], symbol)) != NULL){
hash_test->defined = 1;
hash_test->lc = lc;
return 1;
}
return 0;
}
void hashList_free(hashList **hash_cur){
hashList *tmp;
for( ; *hash_cur; *hash_cur = tmp){
tmp = (*hash_cur)->next;
free((*hash_cur)->symbol);
free(*hash_cur);
}
return;
}
int mot_insert(motList **mot_head,unsigned int opCode, char type,
unsigned int numArgs,const char * opName){
motList *mot_cur = malloc(sizeof *mot_cur);
if(mot_cur == NULL) return 0;
if((mot_cur->opName = malloc(strlen(opName)+1)) == NULL)
{
free(mot_cur);
return 0;
}
mot_cur->opCode = opCode;
mot_cur->type = type;
mot_cur->numArgs= numArgs;
strcpy(mot_cur->opName, opName);
mot_cur->next = *mot_head;
*mot_head = mot_cur;
return 1;
}
motList * mot_search(motList *mot_cur,const char * opTrg){
while(mot_cur){
if(strcmp(mot_cur->opName,opTrg) == 0){
return mot_cur;
}
else {
mot_cur = mot_cur->next;
}
}
return mot_cur;
}
void mot_dump(motList *mot_cur){
while(mot_cur){
printf("%s\n",mot_cur->opName);
mot_cur = mot_cur->next;
}
return;
}
void generate_mot(motList **mot_cur){
mot_insert(mot_cur,0,'r',0,"hlt");
mot_insert(mot_cur,1,'r',3,"add");
mot_insert(mot_cur,2,'r',3,"sub");
mot_insert(mot_cur,3,'r',3,"mul");
mot_insert(mot_cur,4,'r',3,"div");
mot_insert(mot_cur,5,'r',3,"mod");
mot_insert(mot_cur,6,'r',2,"move");
mot_insert(mot_cur,7,'r',3,"and");
mot_insert(mot_cur,8,'r',3,"or");
mot_insert(mot_cur,9,'r',3,"xor");
mot_insert(mot_cur,10,'r',2,"com");
mot_insert(mot_cur,11,'r',3,"sll");
mot_insert(mot_cur,12,'r',3,"srl");
mot_insert(mot_cur,13,'r',3,"sra");
mot_insert(mot_cur,14,'r',3,"jr");
mot_insert(mot_cur,15,'r',1,"rdr");
mot_insert(mot_cur,16,'r',1,"prr");
mot_insert(mot_cur,17,'r',1,"prh");
/* I format */
mot_insert(mot_cur,18,'i',2,"li");
mot_insert(mot_cur,19,'i',3,"addi");
mot_insert(mot_cur,20,'i',3,"subi");
mot_insert(mot_cur,21,'i',3,"muli");
mot_insert(mot_cur,22,'i',3,"divi");
mot_insert(mot_cur,23,'i',3,"modi");
mot_insert(mot_cur,24,'i',3,"lwb");
mot_insert(mot_cur,25,'i',3,"swb");
/* J format */
mot_insert(mot_cur,26,'j',2,"lwa");
mot_insert(mot_cur,27,'i',2,"swa");
mot_insert(mot_cur,28,'i',1,"j");
mot_insert(mot_cur,29,'i',1,"jal");
mot_insert(mot_cur,30,'i',1,"jeq");
mot_insert(mot_cur,31,'i',1,"jne");
mot_insert(mot_cur,32,'i',1,"jlt");
mot_insert(mot_cur,33,'i',1,"jle");
mot_insert(mot_cur,34,'i',1,"jgt");
mot_insert(mot_cur,35,'i',1,"jge");
}
void mot_free(motList **mot_cur){
motList *tmp;
for( ; *mot_cur; *mot_cur = tmp){
tmp = (*mot_cur)->next;
free((*mot_cur)->opName);
free(*mot_cur);
}
return;
}
#endif
assem.h
#include <stdio.h>
#include <string.h>
#define MAX_INPUT 81
int process_token(char * token,motList * mot, hashList * hash_table[],
FILE * lst,FILE * err,int lc){
/*do work
free parts
*/
char * tok;
printf("token %s last char %c\n",token,token[strlen(token)-1]);
if( token[strlen(token)-1] == ':'){
/* symbol in label field */
printf("tok\n");
tok = malloc(strlen(token));
strncpy(tok,token,(strlen(token)-1));
strcat(tok,"\0");
printf("tok malloc and cpy\n");
/* if(isDefined(hash_table,tok) > 0){ */
/* printf("multiply defined\n"); */
/* }else{ */
hash_insert(hash_table,1,lc,tok);
/* } */
}
}
int parseln(char * line, FILE * lst,FILE * err,unsigned int lc,
motList * mot, hashList * hash_table[]){
char * tch;
tch = strtok(line, " \t");
while(tch != NULL){
process_token(tch,mot,hash_table,lst,err,lc);
tch = strtok(NULL," \t");
}
}
void assemble(const char * fnroot,motList * mot,
hashList * hash_table[], FILE * infle){
char inputStr[MAX_INPUT];
char errorStr[255];
char * filename;
char * err_filename;
FILE
* obj,
* lst,
* edt,
* erf;
FILE
* errfle;
unsigned int lc = 1;
filename = malloc(strlen(fnroot) + 4);
strcpy(filename,fnroot);
strcat(filename, ".lst");
if((lst = fopen(filename,"w+")) == NULL){
fprintf(stderr,"Error opening file: %s\n",filename);
}
free(filename);
err_filename = malloc(strlen(fnroot) + 4);
strcpy(err_filename,fnroot);
strcat(err_filename, ".err");
if((errfle = fopen(err_filename,"w+")) == NULL){
fprintf(stderr,"Error opening file: %s\n",err_filename);
}
while(feof(infle) == 0){
fgets(inputStr,81,infle);
if(strlen(inputStr) == 1){
fprintf(lst,"%d\n",lc);
lc++;
continue;
}
if(feof(infle) == 0 ){
if(inputStr[0] == '#'){
fprintf(lst,"%d\t%s",lc,inputStr);
lc++;
continue;
} else{
fprintf(lst,"%d\t%s",lc,inputStr);
parseln(inputStr,lst,errfle,lc,mot,hash_table);
lc++;
continue;
}
}
}
/* copy errors from temp error file to lst file then remove temp */
rewind(errfle);
while(feof(errfle) == 0){
fgets(errorStr,256,errfle);
if(feof(errfle) == 0){
fprintf(lst,"\n");
fprintf(lst,"%s",errorStr);
}
}
fclose(lst);
unlink(err_filename);
free(err_filename);
free(filename);
}
main.c
#include <stdio.h>
#include "list.h"
#include "assem.h"
int main(int argv, char * argc[]){
FILE * infle;
char * fnroot;
int fcount = 2;
char * eor;
char * inputStr;
char * ftest;
motList *mot_head = NULL;
hashList *hash_head[22];
hash_insert(hash_head,1,-1,"dUmMy_HSAH_00"); /* init hash table */
isDefined(hash_head,"dUmMy_HSAH_00");
hash_insert(hash_head,1,-1,"111111dUmMy_HSAH_00");
if(argv < 3){
fprintf(stderr,"Too few arguments\n");
fprintf(stderr,"\tusage:\tp2 <flag> <input files:minimum of one>\n");
exit(1);
}
do{
printf("top of do\n");
printf("infle :: %s\n",argc[fcount]);
if((infle = fopen(argc[fcount],"r")) == NULL){
fprintf(stderr,"Unable to open data file %s\n",argc[fcount]);
}
else{
eor = strrchr(argc[fcount],'.');
fnroot = malloc(eor-argc[fcount]+1);
strncpy(fnroot,argc[fcount],eor-argc[fcount]);
strcat(fnroot,"\0");
//do work
assemble(fnroot,mot_head,hash_head,infle);
free(fnroot);
fclose(infle);
}
fcount++;
} while(fcount < argv);
mot_free(&mot_head);
return 0;
}
test1.asm
#Test case 1 for assembler -- no .edef or .eref.
.text
test1: lwa $1,val1 #Puts -1 in $1.
prh $1
val12: lwa $2,val2
prh $2
sll $3,$2,16
prh $3
val123: srl $4,$1,16
prh $4
val1234: sra $5,$1,16
prh $5
#A label with 8 characters.
val12345: xor $6,$1,$2
prh $6
lwb $7,0($1)
prh $7
hlt
.data
val1: .word -1:4
val2: .word 65535:1
#No more lines.