The same program can be used for DFA.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct state{
  char final;
  int value;
  struct transition *transList;
};

struct stateList{
  int value;
  struct state *statePtr;
  struct stateList *next;
};

struct transition{
  char symbol;
  struct state *statePtr;
  struct transition *next;
};

int dfa(char * input, struct state *s);
void freemem(struct stateList * sList);
int main(){
  struct stateList *sList = NULL, *sListPtr=NULL, *tmpListPtr = NULL;
  struct state *sPtr, *tmpStatePtr;
  struct transition *tPtr,*tmpTransPtr;
  int stateNo;
  char final='N';
  char symbol=' ';
  char input[80];
  do{
    printf("Enter State No (0 to Quit ): ");
    scanf("%d",&stateNo);
    getchar();
    if(stateNo != 0){
	printf("Final State ? (Y?N) ");
	scanf("%c",&final);
	if(sList == NULL){
	  sList = (struct stateList*) malloc(sizeof(struct stateList));
	  sList -> value = stateNo;
	  sList -> statePtr = (struct state *) malloc (sizeof(struct state));
	  sList -> statePtr -> value = stateNo;
	  sList -> statePtr -> final = final;
	  sList -> statePtr -> transList = NULL;
	  sList -> next= NULL;
	}else{
	  sListPtr = sList;
	  while(sListPtr -> next != NULL){
	    sListPtr = sListPtr->next;
	  }
	  sListPtr->next = (struct stateList*) malloc(sizeof(struct stateList));
	  sListPtr = sListPtr->next;
	  sListPtr -> value = stateNo;
	  sListPtr -> statePtr = (struct state *) malloc (sizeof(struct state));
	  sListPtr -> statePtr -> value = stateNo;
	  sListPtr -> statePtr -> final = final;
	  sListPtr -> statePtr -> transList = NULL;
	  sListPtr -> next= NULL;
	  }
	}
  }while(stateNo != 0);
  
  sListPtr = sList;
  while(sListPtr != NULL){
    printf("\n\nEnter Transitions from state %d \n",sListPtr->value);
    printf("To State (0 to Quit) : ");
    scanf("%d",&stateNo);
    while(stateNo != 0){
	tmpListPtr = sList;
	while(tmpListPtr != NULL){
	  if(tmpListPtr-> value == stateNo){
	    break;
	  }
	  tmpListPtr = tmpListPtr ->next;
	}


	if(tmpListPtr == NULL){
	  printf("Invalid State\n");
	}else{
	  getchar();
	  printf("Enter symbol : ");
	  scanf("%c",&symbol);
	  sPtr = sListPtr -> statePtr;
	 
	  if(sPtr->transList == NULL){
	    sPtr->transList = (struct transition *) malloc (sizeof (struct transition));
	    tPtr = sPtr->transList;
	  }else{
	    tPtr = sPtr->transList;
	    while(tPtr->next != NULL){
		tPtr = tPtr->next;
	    }
	    tPtr -> next = (struct transition *) malloc (sizeof (struct transition));
	    tPtr = tPtr ->next;  
	  }
	  tPtr -> symbol = symbol;
	  tPtr -> statePtr = tmpListPtr->statePtr;
	  tPtr -> next = NULL;
	  
	}
	printf("\nTo State (0 to Quit) : ");
	scanf("%d",&stateNo);
    }
    sListPtr = sListPtr -> next;
  }
  if(sList != NULL){
    printf("\nEnter String : ");
    scanf("%s",input);
    while(strcmp(input,"q") != 0){
	if( dfa(input,sList->statePtr )){
	  printf("String Accepted.");
	}
	else{
	  printf("String Not accepted!!! . ");
	}
	printf("\nEnter String (q to Quit): ");
	scanf("%s",input);
    }
  }  
  
  freemem(sList);
}

int dfa(char * input, struct state *s){
  struct transition * t;
  int accept =0;
  // printf("\nInput: %s\n",input);
  // printf("Value : %d\n",s->value);
  //printf("Final: %c\n",s->final);

  if(s == NULL){
    return 0;
  }else{
    t = s -> transList;
    if(input[0] == '\0' && s -> final == 'Y'){
	return 1;
    }
    
    while( t != NULL && accept ==0){
	//	printf("State Transition symbol : %c\n",t->symbol);
	if(t -> symbol == input[0]){
	  //printf("Transist to the state : %d\n",t->statePtr->value);
	  accept= dfa(input+1,t->statePtr); 
	  }
	t = t -> next;
    }
  }
  return accept;
} 

void freemem(struct stateList * sList){
  struct stateList *tsList;
  struct state * tstate;
  struct transition *trans, *trans2;
  while(sList != NULL){
    tsList = sList->next;
    
    tstate = sList -> statePtr;
    trans = tstate -> transList;
    while(trans != NULL){
	trans2 = trans->next;
	free(trans);
	trans = trans2;
    }
    free(tstate);
    free(sList);
    sList = tsList;
  }
}

Sample output for regExpression: (a|b)*abb

Enter State No (0 to Quit ): 1
Final State ? (Y?N) N
Enter State No (0 to Quit ): 2
Final State ? (Y?N) N
Enter State No (0 to Quit ): 3
Final State ? (Y?N) N
Enter State No (0 to Quit ): 4
Final State ? (Y?N) Y
Enter State No (0 to Quit ): 0


Enter Transitions from state 1 
To State (0 to Quit) : 1
Enter symbol : a

To State (0 to Quit) : 1
Enter symbol : b

To State (0 to Quit) : 2
Enter symbol : a

To State (0 to Quit) : 0


Enter Transitions from state 2 
To State (0 to Quit) : 3
Enter symbol : b

To State (0 to Quit) : 0


Enter Transitions from state 3 
To State (0 to Quit) : 4
Enter symbol : b

To State (0 to Quit) : 0


Enter Transitions from state 4 
To State (0 to Quit) : 0

Enter String : abb
String Accepted.
Enter String (q to Quit): aaaabb 
String Accepted.
Enter String (q to Quit): aaaabbbbbb
String Not accepted!!! . 
Enter String (q to Quit): quit
String Not accepted!!! . 
Enter String (q to Quit): q

This is simply the combination of 2-Pass assembler and a Macro Processor .

 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

#define TRUE 1
#define FALSE 0
#define lenOPTAB 7

struct{
    char opcode[32];
    char hexcode[3];
}OPTAB[]={
    {"ADD","08"},
    {"SUB","1C"},
    {"MUL","20"},
    {"DIV","24"},
    {"LDA","AC"},
    {"END","00"},
    {"MEND","FF"},

};

typedef struct deftab{
    char statement[80];
    struct deftab * next;
} DEFTAB;

typedef struct ntab{
    char name[80];
    DEFTAB * start;
    DEFTAB * end;
    struct ntab * next;
}NAMETAB;

NAMETAB *nameTab;

char expanding = FALSE;

struct{
    char label[32];
    int address;
}SYMTAB[100];


typedef struct{
    char label[32];
    char opcode[32];
    char operand[32];

}Token;

typedef struct{
    int address;
    Token src;
    char hexcode[30];
}asmlist;

int lenSRC = 0;
int lenSYMTAB = 0;
int startAddr =0;

void tokenize( char * line, Token *tok);
int  getline(FILE *fp,char * line);
char isOPCODE( char * str);

int pass1(FILE *srcfp, FILE *intfp);
void pass2(FILE *intrfp, FILE *lstfp, FILE *hexfp);

char searchSYMTAB( char * str);
void insertSYMTAB( char * label,int locCntr);
void tokenizeIntr( char * line, asmlist *list);
void initializeTextRec(char *textRec,asmlist list);
void writeObjTextRec(FILE *fp, char *str);

int  getAddress(char *symbol);
char * getHexOperand(char * str, char *hexOperand);
char * getOpcodeHex(char *op);
int operandLen(char *str);

void writeintrfile(asmlist list,FILE *fp);
void writelistfile(FILE *fp, asmlist list);
void writeobjheader(FILE *fp,asmlist list);
void writeEnd(FILE *fp);

void macroexpand(FILE *srcfp,FILE *outfp);
void processline(Token tok,FILE *srcfp,FILE *outfp);
NAMETAB * searchNAMETAB(char *str);
void define(Token tok,FILE *fp);
void expand(Token tok,FILE *srcfp, FILE *outfp);
void replaceARG(char *line,char ARGTAB[10][80]);
int readline(FILE *fp,char * line);
NAMETAB*  putInNAMETAB(Token tok);
void getDefLine (char *line, char ARGTAB[10][80], DEFTAB *def);
void putPrototypeInDEFTAB(Token tok,DEFTAB *def);
int getparameter(char str[80],char pList[10][80]);
void subParmeter(char *line,int pCount, char pList[10][80]);
void writeline(Token tok,FILE *fp);
void cleanMem();

int  main(int argc, char * argv[]){
    FILE *srcfp, *lstfp, *intrfp, *hexfp,*outfp;
    char lstfname[30], intrfname[30],hexfname[30];
    char outfilename[80];

    if (argc != 2){
	printf("Invalid usage !!!");
	return;
    }

    // generate filename for list,intermediate and hexfiles.
    if( strstr(argv[1],".") ){
	strcpy(lstfname,argv[1]);
	strcpy(strstr(lstfname,"."),".lst");
	strcpy(intrfname,argv[1]);
	strcpy(strstr(intrfname,"."),".int");
	strcpy(hexfname,argv[1]);
	strcpy(strstr(hexfname,"."),".hex");
	strcpy(outfilename,argv[1]);
	strcpy(strstr(outfilename,"."),"_expanded.asm");

    }else{
	strcpy(lstfname,argv[1]);
	strcat(lstfname,".lst");
	strcpy(intrfname,argv[1]);
	strcat(intrfname,".int");
	strcpy(hexfname,argv[1]);
	strcat(hexfname,".hex");
	strcpy(outfilename,argv[1]);
	strcat(outfilename,"_expanded.asm");

    }


    srcfp=fopen(argv[1],"r");
    if(srcfp == NULL){
	printf("!!! Error. Unable to open the src file. ");
	return;
    }

    outfp = fopen(outfilename,"w");
    if(outfp == NULL){
	printf("Unable to open outfile.\n");
	fclose(srcfp);
	return;
    }
    nameTab = NULL;
    macroexpand(srcfp,outfp);
    cleanMem();
    fclose(srcfp);
    fclose(outfp);

    srcfp=fopen(outfilename,"r");
    if(srcfp == NULL){
	printf("!!! Error. Unable to open the src file. ");
	return;
    }


    intrfp=fopen(intrfname,"w");
    if(intrfp == NULL){
	printf("!!! Error. Unable to open the intermediate file. ");
	fclose(srcfp);
	return;
    }

    lstfp=fopen(lstfname,"w");
    if(lstfp == NULL){
	printf("!!! Error. Unable to open the list file. ");
	fclose(srcfp);
	fclose(intrfp);
	return;
    }

    hexfp=fopen(hexfname,"w");
    if(hexfp == NULL){
	printf("!!! Error. Unable to open the hex file. ");
	fclose(srcfp);
	fclose(intrfp);
	fclose(lstfp);
	return;
    }

    // pass 1 generate intermediate file
    if(! pass1(srcfp,intrfp)){
	fclose(srcfp);
	fclose(intrfp);
	return;
    }

    fclose(srcfp);
    fclose(intrfp);

    intrfp=fopen(intrfname,"r");
    if(intrfp == NULL){
	printf("!!! Error. Unable to open the intermediate file. ");
	fclose(srcfp);
	return;
    }

    //generate list file and hexfile
    pass2(intrfp,lstfp,hexfp);

    fclose(lstfp);
    fclose(hexfp);
}

int pass1(FILE *srcfp, FILE *intrfp){
    char line[80];
    char *cptr;

    Token tok;
    int locCntr;
    asmlist list;
    if(! getline(srcfp,line)) return;  // read first line

    tokenize(line,&tok);  // tokenize the line

    if( strcasecmp(tok.opcode,"START") == 0){
	locCntr = strtoul(tok.operand,0,16);
	list.address = locCntr;
	list.src = tok;
	writeintrfile(list,intrfp);
	if(!getline(srcfp,line)) return;
	tokenize(line,&tok);

    }else{
	locCntr =0;
    }

    startAddr=locCntr;
    lenSRC = locCntr;

    while( strcasecmp(tok.opcode,"END") != 0){

	// check for comments. comments start with a '.'

	if( line[0] != '.'){

	    list.address = locCntr;
	    list.src = tok;
	    writeintrfile(list,intrfp); // writes intermediate file.

	    // check for label
	    if(strlen(tok.label) != 0){
		if(searchSYMTAB(tok.label)){
		    printf("Error : duplicate symbol @ %s",line);
		    return 0;
		}else{
		    //insert symboltable entry
		    insertSYMTAB(tok.label,locCntr);  
		}
	    }

	    //Finds instruction length
	    if( isOPCODE(tok.opcode)){
		locCntr = locCntr +3;
	    }
	    else if( strcasecmp(tok.opcode,"WORD") == 0){
		locCntr = locCntr +3;
	    }
	    else if( strcasecmp(tok.opcode,"RESW") == 0){
		// operand length is specified in the instruction itself
		if(tok.operand[0] == 'X'){
		    cptr=strtok(tok.operand," '");
		    if(cptr != NULL)
			locCntr = locCntr + 3* strtoul(cptr,0,16);
		}
		else{
		    locCntr = locCntr + 3* strtoul(tok.operand,0,10);
		}
	    }
	    else if( strcasecmp(tok.opcode,"RESB") == 0){
		// operand length is in instruction itself
		if(tok.operand[0] == 'X'){
		    cptr=strtok(tok.operand," '");
		    if(cptr != NULL)
			locCntr = locCntr + strtoul(cptr,0,16);
		}
		else{
		    locCntr = locCntr +  strtoul(tok.operand,0,10);
		}
	    }
	    else if( strcasecmp(tok.opcode,"BYTE") == 0){
		//length of the operand
		locCntr = locCntr + operandLen(tok.operand);
	    }
	    else{
		printf("Error Invalid operation code. @ %s ",line);
		return 0;
	    }
	}
	if(!getline(srcfp,line)) return 0;
	tokenize(line,&tok);
    }

    list.address = locCntr;
    list.src = tok;
    writeintrfile(list,intrfp);

    lenSRC = locCntr - lenSRC;

    return 1;
}

void pass2(FILE *intrfp, FILE *lstfp, FILE *hexfp){
    char line[80];
    asmlist list;
    Token *tok;
    tok = &(list.src);

    char textRec[80];
    int operandAddr=0;
    char hexOperand[80];
    char hexObj[80],temp[80];
    int Index=9;

    if(!getline(intrfp,line)) return;
    tokenizeIntr(line,&list);//tokenize the intermediate code

    if (strcasecmp(tok->opcode,"START") == 0 ){
	writelistfile(lstfp,list);

	if(!getline(intrfp,line)) return;
	tokenizeIntr(line,&list);
    }
    writeobjheader(hexfp,list);  //H+Pgm_Name+Start_Addr+Length
    initializeTextRec(textRec,list); //  T+Starting address

    while(strcasecmp(tok->opcode,"END") != 0){
	// Valid Opcode  
	if(isOPCODE(tok->opcode)){

	    if(strlen(tok -> operand) != 0){
		if(searchSYMTAB(tok->operand)){
		    // get symbol address
		    operandAddr=getAddress(tok->operand);
		    //opcode+label address
		    sprintf(hexObj,"%s%04X",getOpcodeHex(tok -> opcode), operandAddr);
		}
		else{
		    if( getHexOperand(tok->operand,hexOperand) == NULL ){
			printf("Invalid operand @ %s",line);
		    }
		    //opcode+operand value
		    sprintf(hexObj,"%s%s",getOpcodeHex(tok -> opcode),hexOperand);
		}
	    }
	}

	else{
	    if(strcasecmp(tok -> opcode,"BYTE") == 0 ||	\
	       strcasecmp(tok -> opcode,"WORD") == 0){
		getHexOperand(tok->operand,hexOperand);
		//operand
		sprintf(hexObj,"%s",hexOperand);
	    }
	    else{
		getHexOperand(tok->operand,hexOperand);
		//operand
		sprintf(hexObj,"%s",hexOperand);

	    }
	}

	if((Index+strlen(hexObj)) > 69){
	    sprintf(textRec+7,"%02X%s",(strlen(textRec)-9)/2,textRec+9);//place length in lenField
	    writeObjTextRec(hexfp,textRec);
	    initializeTextRec(textRec,list);
	}

	strncpy(temp,textRec+1,6);
	Index = ((list.address - strtoul(temp,0,16))*2 )+9;

	sprintf(textRec+Index,"%s",hexObj);
	Index =Index + strlen(hexObj);
	strcpy(list.hexcode,hexObj);

	writelistfile(lstfp,list);

	if(!getline(intrfp,line)) return;
	tokenizeIntr(line,&list);

    }
    sprintf(textRec+7,"%02X%s",(strlen(textRec)-9)/2,textRec+9);
    writeObjTextRec(hexfp,textRec);
    writeEnd(hexfp);
} 


void insertSYMTAB( char * label,int locCntr){
    strcpy(SYMTAB[lenSYMTAB].label,label);
    SYMTAB[lenSYMTAB].address = locCntr;
    lenSYMTAB ++;
    return;
}

int getline(FILE *fp,char * line){
    char ch;
    int cnt=0;
    while ( (ch = fgetc(fp)) != EOF && ch != '\n' ){
	line[cnt++] = ch;
    }
    line[cnt] = '\0';

    if(line [0] == '\0')
	return 0;
    else
	return 1;
}


void tokenizeIntr( char * line, asmlist *list){
    char *chr;
    Token *tok;
    tok = & (list -> src);
    list -> address = 0;
    strcpy(list->hexcode,"");
    strcpy(tok -> label, "\0");
    strcpy(tok -> opcode, "\0");
    strcpy(tok -> operand, "\0");

    chr =strtok(line, " \t");

    if( chr != NULL){
	list -> address = strtoul(chr,0,16);
	chr = strtok(NULL, " \t");

	if ( isOPCODE(chr)){
	    strcpy(tok -> opcode,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
	}else{
	    strcpy(tok->label,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> opcode,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
	}
    }
    //printf(" %s | %s | %s \n", tok-> label, tok-> opcode, tok -> operand);
    return;
}

char searchSYMTAB( char * str){
    int i;
    for (i=0; i < lenSYMTAB; i++){
	if( strcasecmp(SYMTAB[i].label,str) == 0)
	    return 1;
    }
    return 0;
}
void writeintrfile(asmlist list,FILE *fp){
    fprintf(fp,"%X\t%s\t%s\t%s\n",list.address,list.src.label,list.src.opcode,list.src.operand);
    return;
}
void writelistfile(FILE *fp, asmlist list){
    fprintf(fp,"%06X\t%s\t%s\t%s\t%s\n",list.address,list.src.label,list.src.opcode,list.src.operand,list.hexcode);
}

void writeobjheader(FILE *fp,asmlist list){
    char line[80];
    int i;

    line [0]='H';
    strncpy(line+1,list.src.label,6);
    sprintf(line+7,"%06X",list.address);
    sprintf(line+13,"%06X",lenSRC);
    line[19]='\0';

    for( i=0; i< 19; i++){
	if(line[i] =='\0')
	    line[i]=' ';
    }
    fprintf(fp,"%s\n",line);

}

void writeEnd(FILE *fp){

    fprintf(fp,"E%06X",startAddr);

}
void initializeTextRec( char *textRec,asmlist list){
    int i;
    for(i=0;i<80;i++){
	textRec[i]='0';
    }
    textRec[0]='T';
    sprintf(textRec+1,"%06X",list.address);
    sprintf(textRec+7,"%02X",00);
    return;
}

int getAddress(char *symbol){
    int i;
    for(i=0; i< lenSYMTAB; i++){
	if(strcasecmp(SYMTAB[i].label,symbol) == 0)
	    return SYMTAB[i].address;
    }
    return 0;
}
char * getOpcodeHex(char *op){
    int i;
    for(i=0; i< lenOPTAB; i++){
	if(strcasecmp(OPTAB[i].opcode,op) == 0)
	    return OPTAB[i].hexcode;
    }
    return "00";
}

int operandLen(char *str){
    char *cptr;
    //Hex Operand
    if(str[0] == 'X' || str[0]=='C'){
	cptr = strtok(str+1," '");
	if(cptr != NULL){
	    return strlen(cptr);
	}
	else{
	    return 0;
	}
    }
    return 0;
}

char * getHexOperand(char * strOperand, char *hexOperand){
    int i;
    char *cptr;
    char str[80];
    strcpy(str,strOperand);
    //Hex Operand
    if(str[0] == 'X'){
	cptr = strtok(str+1," '");
	if(cptr != NULL){
	    sprintf(hexOperand,"%04X",(unsigned int)strtoul(cptr,0,16));
	}
	else{
	    return NULL;
	}
    }
    //Charector operand
    else if(str[0] == 'C'){

	cptr = strtok(str+1," '");
	if(cptr != NULL){

	    for( i=0; cptr[i] != '\0'; i++){
		sprintf(hexOperand+(2*i),"%02X",cptr[i]);
	    }
	    hexOperand[2*i]='\0';

	}
	else{
	    return NULL;
	}
    }
    //absolute value.
    else if(str[0] == '#'){
	if( searchSYMTAB(str+1)){
	    sprintf(hexOperand,"%04X",getAddress(str+1));

	}else{
	    errno =0;
	    sprintf(hexOperand,"%04d",(int)strtoul(str,0,10));

	    if(errno == EINVAL){
		return NULL;
	    }
	}
    }
    else{

	sprintf(hexOperand,"%06X",(unsigned int)strtoul(str,0,16));

    }
    return hexOperand;

}

void writeObjTextRec(FILE *fp, char *str){
    fprintf(fp,"%s\n",str);
}


void macroexpand(FILE *srcfp,FILE *outfp){
    char line[80];
    Token tok;

    expanding = FALSE;
    readline(srcfp,line);
    tokenize(line,&tok);

    while( strcasecmp(tok.opcode,"END") != 0){
	processline(tok,srcfp,outfp);
	readline(srcfp,line);
	tokenize(line,&tok);
    }
    writeline(tok,outfp);
    return;
}

void processline(Token tok,FILE *srcfp,FILE *outfp){
    if(searchNAMETAB(tok.opcode)){
	expand(tok,srcfp,outfp);
    }else if (strcasecmp(tok.opcode,"MACRO") == 0){
	define(tok,srcfp);
    }
    else{
	writeline(tok,outfp);
    }
}

NAMETAB * searchNAMETAB(char *str){
    NAMETAB *nTab;
    nTab = nameTab;
    while(nTab != NULL){
	if(strcasecmp(nTab->name,str)== 0){
	    return nTab;
	}
	nTab = nTab->next;
    }
    return NULL;
}

void define(Token tok,FILE *fp){
    int level=1,pCount;
    int i;
    char line[80],line1[80];
    char pList[10][80]; //contain parameters
    NAMETAB *nTab;

    DEFTAB *def,*tmpdef,*start,*end;
    nTab = putInNAMETAB(tok);

    def =(DEFTAB*) malloc(sizeof(DEFTAB));
    def->next =NULL;
    start = def;

    putPrototypeInDEFTAB(tok,def);

    pCount = getparameter(tok.operand,pList);

    while(level > 0){
	readline(fp,line);
	strcpy(line1,line);
	tokenize(line1,&tok);

	if(line[0] != '.') {//not a comment line

	    subParmeter(line,pCount,pList);

	    //enter line to deftab;
	    tmpdef =(DEFTAB*) malloc(sizeof(DEFTAB));
	    strcpy(tmpdef->statement,line);      
	    tmpdef ->next = NULL;
	    def->next = tmpdef;
	    def = def->next;

	    if(strcasecmp(tok.opcode,"MACRO")==0){
		level = level+1;
	    }else if(strcasecmp(tok.opcode,"MEND")==0){
		level = level-1;
	    }
	}
    }

    nTab->start = start;
    nTab->end   = def;

}

void expand(Token tok,FILE *srcfp, FILE *outfp){
    char ARGTAB[10][80];
    int pCount;
    char line[80];

    NAMETAB *nTab;
    DEFTAB *def;

    expanding = TRUE;
    pCount = getparameter(tok.operand,ARGTAB);
    nTab = searchNAMETAB(tok.opcode);

    def = nTab->start;
    def = def -> next;
    getDefLine(line,ARGTAB,def);

    tokenize(line,&tok);
    def = def->next;  
    while(strcasecmp(tok.opcode,"MEND") != 0){
	processline(tok,srcfp,outfp);
	getDefLine(line,ARGTAB,def);
	tokenize(line,&tok);
	def = def->next;
    }

    expanding = FALSE;

}

void getDefLine (char *line, char ARGTAB[10][80], DEFTAB *def){
    char str[80];
    Token tok;

    strcpy(str,def->statement);
    tokenize(str,&tok);
    replaceARG(tok.operand,ARGTAB);
    sprintf(line,"%s %s %s",tok.label, tok.opcode, tok.operand);
    return;
}

void replaceARG(char *line,char ARGTAB[10][80]){
    char *str, tail[80];
    int count;
    str = strstr(line,"?");
    while( str ){
	strcpy(tail,str+2);
	count = (*(str+1) - 0x30);
	strcpy(str,ARGTAB[count]);
	strcat(str,tail); 
	str = strstr(line,"?");   

    }
    return;
}

int readline(FILE *fp,char * line){
    char ch;
    int cnt=0;
    while ( (ch = fgetc(fp)) != EOF && ch != '\n' ){
	line[cnt++] = ch;
    }
    line[cnt] = '\0';

    if(line [0] == '\0')
	return 0;
    else
	return 1;
}

NAMETAB*  putInNAMETAB(Token tok){
    NAMETAB *ptrNameTab=NULL;
    if(nameTab == NULL){
	ptrNameTab = (NAMETAB*) malloc(sizeof(NAMETAB));

	ptrNameTab -> start = NULL;
	ptrNameTab -> end   = NULL;
	ptrNameTab -> next  = NULL;
	nameTab = ptrNameTab;
    }else{
	ptrNameTab = nameTab;
	while(ptrNameTab ->next == NULL){
	    ptrNameTab = ptrNameTab -> next;
	}
	ptrNameTab -> next = (NAMETAB*) malloc(sizeof(NAMETAB));
	ptrNameTab = ptrNameTab-> next;
	ptrNameTab -> start = NULL;
	ptrNameTab -> end   = NULL;
	ptrNameTab ->next = NULL;

    }

    strcpy(ptrNameTab->name,tok.label);
    return ptrNameTab;

}
void putPrototypeInDEFTAB(Token tok,DEFTAB *def){
    sprintf(def->statement,"%s %s %s",tok.label,tok.opcode,tok.operand);
}

int getparameter(char str[80],char pList[10][80]){
    char *chr;
    int cnt=0;
    chr = strtok(str,".?, \n\t");

    while(chr != NULL){
	strcpy(pList[cnt],chr);
	cnt++;
	chr= strtok(NULL,".?, \n\t");
    }
    return cnt;
}

void subParmeter(char *line,int pCount, char pList[10][80]){
    int i;
    char *str;
    char *tail;
    for(i=0; i<pCount; i++){
	str = strstr(line,pList[i]);
	if(str != NULL){
	    tail = str+strlen(pList[i]);
	    sprintf(str,"?%d",i);
	    strcat(str,tail);
	}
    }
}

void writeline(Token tok,FILE *fp){
    fprintf(fp,"%s %s %s\n",tok.label,tok.opcode,tok.operand);
    return;
}
void tokenize( char * line, Token *tok){
    char *chr;
    strcpy(tok -> label, "\0");
    strcpy(tok -> opcode, "\0");
    strcpy(tok -> operand, "\0");

    chr =strtok(line, " \t");

    if( chr != NULL){
	//check for opcode
	if ( isOPCODE(chr) || searchNAMETAB(chr) ){
	    strcpy(tok -> opcode,chr); // instruction opcode+operand
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
	}else{  // instruction label+opcode+operand
	    strcpy(tok->label,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> opcode,chr);
	    chr = strtok(NULL, "\n\t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
	}
    }
    //  printf(" %s | %s | %s \n", tok-> label, tok-> opcode, tok -> operand);
    return;
}

char isOPCODE( char * str){
    int i;
    for (i=0; i < lenOPTAB; i++){
	if( strcasecmp(OPTAB[i].opcode,str) == 0)
	    return 1;
    }
    return 0;
}

void cleanMem(){
    NAMETAB *nTab,*tmp;
    DEFTAB *def,*tmpDef;
    nTab = nameTab;
    while(nTab != NULL){
	def = nTab->start;
	while(def != NULL){
	    tmpDef = def;
	    def = def-> next;
	    free(tmpDef);
	}
	tmp = nTab;
	nTab = nTab->next;
	free(tmp);
    }
}  

Sample Output;
test.asm    <-- Input
COPY  START 0000
TEST  MACRO &ONE, &&TWO
	LDA &ONE
	ADD THREE<
MEND
FIRST	SUB   THREE
	TEST  LENGTH,RETADR
EOF   BYTE  C'eof'
THREE WORD  3
ZERO 	WORD 	0
RETADR	RESW	1
LENGTH	RESW	1
MESS1   BYTE  C'HELLO_WORLD'
	  END
test.lst
000000	COPY	START	0000
000000	FIRST	SUB	THREE	1C0009
000003		LDA	LENGTH	AC0012
000006		ADD	THREE	080009
000009	EOF	BYTE	C'eof'	656F66
000009	THREE	WORD	3	000003
00000C	ZERO	WORD	0	000000
00000F	RETADR	RESW	1	000001
000012	LENGTH	RESW	1	000001
000015	MESS1	BYTE	C'HELLO_WORLD'	48454C4C4F5F574F524C44
test.hex
HFIRST 000000000015
T000000151C0009AC0012080009000003000000000001000001
T0000150B48454C4C4F5F574F524C44
E000000

SIC Macro Processor. Output is included.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0

#define lenOPTAB 7

struct{
    char opcode[32];
    char hexcode[3];
}OPTAB[]={
    {"ADD","08"},
    {"SUB","1C"},
    {"MUL","20"},
    {"DIV","24"},
    {"LDA","AC"},
    {"END","00"},
    {"MEND","FF"},

};

typedef struct deftab{
    char statement[80];
    struct deftab * next;
} DEFTAB;

typedef struct ntab{
    char name[80];
    DEFTAB * start;
    DEFTAB * end;
    struct ntab * next;
}NAMETAB;

NAMETAB *nameTab;

char expanding = FALSE;

typedef struct{
    char label[32];
    char opcode[32];
    char operand[32];
}Token;

void macroexpand(FILE *srcfp,FILE *outfp);
void processline(Token tok,FILE *srcfp,FILE *outfp);
NAMETAB * searchNAMETAB(char *str);
void define(Token tok,FILE *fp);
void expand(Token tok,FILE *srcfp, FILE *outfp);
void replaceARG(char *line,char ARGTAB[10][80]);
int readline(FILE *fp,char * line);
NAMETAB*  putInNAMETAB(Token tok);
void getline (char *line, char ARGTAB[10][80], DEFTAB *def);
void putPrototypeInDEFTAB(Token tok,DEFTAB *def);
int getparameter(char str[80],char pList[10][80]);
void subParmeter(char *line,int pCount, char pList[10][80]);
void writeline(Token tok,FILE *fp);
void tokenize( char * line, Token *tok);
char isOPCODE( char * str);
void cleanMem();
int main(int argc, char *argv[]){
    FILE *srcfp, *outfp;
    char outfilename[80];
    if(argc != 2){
	  printf("Invalid Usage !!!\n");
	  return;
    }
    // generate filename expanded file.
    if( strstr(argv[1],".") ){
	  strcpy(outfilename,argv[1]);
	  strcpy(strstr(outfilename,"."),"_expanded.asm");
    }else{
	  strcpy(outfilename,argv[1]);
	  strcat(outfilename,"_expanded.asm");
    }

    srcfp = fopen(argv[1],"r");
    if(srcfp == NULL){
	  printf("Unable to read the source file.\n");
	  return;
    }
    outfp = fopen(outfilename,"w");
    if(outfp == NULL){
	  printf("Unable to open outfile.\n");
	  fclose(srcfp);
	  return;
    }
    nameTab = NULL;
    macroexpand(srcfp,outfp);
    cleanMem();
    fclose(srcfp);
    fclose(outfp);
}

void macroexpand(FILE *srcfp,FILE *outfp){
    char line[80];
    Token tok;

    expanding = FALSE;
    readline(srcfp,line);
    tokenize(line,&tok);

    while( strcasecmp(tok.opcode,"END") != 0){
	  processline(tok,srcfp,outfp);
	  readline(srcfp,line);
	  tokenize(line,&tok);
    }
    writeline(tok,outfp);
    return;
}

void processline(Token tok,FILE *srcfp,FILE *outfp){
    if(searchNAMETAB(tok.opcode)){
	  expand(tok,srcfp,outfp);
    }else if (strcasecmp(tok.opcode,"MACRO") == 0){
	  define(tok,srcfp);
    }
    else{
	  writeline(tok,outfp);
    }
}

NAMETAB * searchNAMETAB(char *str){
    NAMETAB *nTab;
    nTab = nameTab;
    while(nTab != NULL){
	  if(strcasecmp(nTab->name,str)== 0){
		return nTab;
	  }
	  nTab = nTab->next;
    }
    return NULL;
}

void define(Token tok,FILE *fp){
    int level=1,pCount;
    int i;
    char line[80],line1[80];
    char pList[10][80]; //contain parameters
    NAMETAB *nTab;

    DEFTAB *def,*tmpdef,*start,*end;
    nTab = putInNAMETAB(tok);

    def =(DEFTAB*) malloc(sizeof(DEFTAB));
    def->next =NULL;
    start = def;

    putPrototypeInDEFTAB(tok,def);

    pCount = getparameter(tok.operand,pList);

    while(level > 0){
	  readline(fp,line);
	  strcpy(line1,line);
	  tokenize(line1,&tok);

	  if(line[0] != '.') {//not a comment line

		subParmeter(line,pCount,pList);

		//enter line to deftab;
		tmpdef =(DEFTAB*) malloc(sizeof(DEFTAB));
		strcpy(tmpdef->statement,line);
		tmpdef ->next = NULL;
		def->next = tmpdef;
		def = def->next;

		if(strcasecmp(tok.opcode,"MACRO")==0){
		    level = level+1;
		}else if(strcasecmp(tok.opcode,"MEND")==0){
		    level = level-1;
		}
	  }
    }

    nTab->start = start;
    nTab->end   = def;

}

void expand(Token tok,FILE *srcfp, FILE *outfp){
    char ARGTAB[10][80];
    int pCount;
    char line[80];

    NAMETAB *nTab;
    DEFTAB *def;

    expanding = TRUE;
    pCount = getparameter(tok.operand,ARGTAB);
    nTab = searchNAMETAB(tok.opcode);

    def = nTab->start;
    def = def -> next;
    getline(line,ARGTAB,def);

    tokenize(line,&tok);
    def = def->next;
    while(strcasecmp(tok.opcode,"MEND") != 0){
	  processline(tok,srcfp,outfp);
	  getline(line,ARGTAB,def);
	  tokenize(line,&tok);
	  def = def->next;
    }

    expanding = FALSE;

}

void getline (char *line, char ARGTAB[10][80], DEFTAB *def){
    char str[80];
    Token tok;

    strcpy(str,def->statement);
    tokenize(str,&tok);
    replaceARG(tok.operand,ARGTAB);
    sprintf(line,"%s %s %s",tok.label, tok.opcode, tok.operand);
    return;
}

void replaceARG(char *line,char ARGTAB[10][80]){
    char *str, tail[80];
    int count;
    str = strstr(line,"?");
    while( str ){
	  strcpy(tail,str+2);
	  count = (*(str+1) - 0x30);
	  strcpy(str,ARGTAB[count]);
	  strcat(str,tail);
	  str = strstr(line,"?");

    }
    return;
}

int readline(FILE *fp,char * line){
    char ch;
    int cnt=0;
    while ( (ch = fgetc(fp)) != EOF && ch != '\n' ){
        line[cnt++] = ch;
    }
    line[cnt] = '\0';

    if(line [0] == '\0')
        return 0;
    else
        return 1;
}

NAMETAB*  putInNAMETAB(Token tok){
    NAMETAB *ptrNameTab=NULL;
    if(nameTab == NULL){
	  ptrNameTab = (NAMETAB*) malloc(sizeof(NAMETAB));

	  ptrNameTab -> start = NULL;
	  ptrNameTab -> end   = NULL;
	  ptrNameTab -> next  = NULL;
	  nameTab = ptrNameTab;
    }else{
	  ptrNameTab = nameTab;
	  while(ptrNameTab ->next == NULL){
		ptrNameTab = ptrNameTab -> next;
	  }
	  ptrNameTab -> next = (NAMETAB*) malloc(sizeof(NAMETAB));
	  ptrNameTab = ptrNameTab-> next;
	  ptrNameTab -> start = NULL;
	  ptrNameTab -> end   = NULL;
	  ptrNameTab ->next = NULL;

    }

    strcpy(ptrNameTab->name,tok.label);
    return ptrNameTab;

}
void putPrototypeInDEFTAB(Token tok,DEFTAB *def){
    sprintf(def->statement,"%s %s %s",tok.label,tok.opcode,tok.operand);
}

int getparameter(char str[80],char pList[10][80]){
    char *chr;
    int cnt=0;
    chr = strtok(str,".?, \n\t");

    while(chr != NULL){
	  strcpy(pList[cnt],chr);
	  cnt++;
	  chr= strtok(NULL,".?, \n\t");
    }
    return cnt;
}

void subParmeter(char *line,int pCount, char pList[10][80]){
    int i;
    char *str;
    char *tail;
    for(i=0; i<pCount; i++){
	  str = strstr(line,pList[i]);
	  if(str != NULL){
		tail = str+strlen(pList[i]);
		sprintf(str,"?%d",i);
		strcat(str,tail);
	  }
    }
}

void writeline(Token tok,FILE *fp){
    fprintf(fp,"%s %s %s\n",tok.label,tok.opcode,tok.operand);
    return;
}
void tokenize( char * line, Token *tok){
    char *chr;
    strcpy(tok -> label, "\0");
    strcpy(tok -> opcode, "\0");
    strcpy(tok -> operand, "\0");

    chr =strtok(line, " \t");

    if( chr != NULL){
        //check for opcode
	  if ( isOPCODE(chr) || searchNAMETAB(chr) ){
		strcpy(tok -> opcode,chr); // instruction opcode+operand
		chr = strtok(NULL, " \t");
		if( chr != NULL )
		    strcpy(tok -> operand, chr);
        }else{  // instruction label+opcode+operand
		strcpy(tok->label,chr);
		chr = strtok(NULL, " \t");
		if( chr != NULL )
		    strcpy(tok -> opcode,chr);
		chr = strtok(NULL, "\n\t");
		if( chr != NULL )
		    strcpy(tok -> operand, chr);
        }
    }
    //  printf(" %s | %s | %s \n", tok-> label, tok-> opcode, tok -> operand);
    return;
}

char isOPCODE( char * str){
    int i;
    for (i=0; i < lenOPTAB; i++){
        if( strcasecmp(OPTAB[i].opcode,str) == 0)
		return 1;
    }
    return 0;
}

void cleanMem(){
    NAMETAB *nTab,*tmp;
    DEFTAB *def,*tmpDef;
    nTab = nameTab;
    while(nTab != NULL){
	  def = nTab->start;
	  while(def != NULL){
		tmpDef = def;
		def = def-> next;
		free(tmpDef);
	  }
	  tmp = nTab;
	  nTab = nTab->next;
	  free(tmp);
    }
}

Sample Output;
test.asm    <-- Input

COPY  START 0000
TEST  MACRO &ONE, &TWO
	LDA &ONE
	ADD THREE
MEND
FIRST	SUB   THREE
	TEST  LENGTH,RETADR
EOF   BYTE  C'eof'
THREE WORD  3
ZERO 	WORD 	0
RETADR	RESW	1
LENGTH	RESW	1
MESS1   BYTE  C'HELLO_WORLD'
	  END

test_expanded.asm

COPY START 0000
FIRST SUB   THREE
 LDA LENGTH
 ADD THREE
EOF BYTE  C'eof'
THREE WORD  3
ZERO WORD 0
RETADR RESW 1
LENGTH RESW 1
MESS1 BYTE  C'HELLO_WORLD'
 END

Free memory list is hard coded & first fit free block is selected

#include <stdio.h>
#include <string.h>
#define MEMSIZE  8192 // 8K

struct record{
    char type;
    int start;
    int length;
    char content[80];
};

unsigned char memory[MEMSIZE];

struct freeMemoryList{
    int startAddr;
    int length;
} freeMemList[] = { {0x500,5},{0x1000,512}};
int lenfreeMemList = 2;

int getline(FILE *fp,char * line);
void header(char *line,char *name, int * start, int *length);
void getRecord(char *line,struct record *rec);
int findFreeMem(int length);
int load(FILE * hexfp);
void writeToMemFile(FILE *memfp);

int main(int argc, char * argv[]){
    FILE *hexfp, *memfp;
    char memfname[30];

    if (argc != 2){
	  printf("Invalid usage !!!");
	  return;
    }

    if( strstr(argv[1],".") ){
	  strcpy(memfname,argv[1]);
	  strcpy(strstr(memfname,"."),".mem");

    }else{
	  strcpy(memfname,argv[1]);
	  strcat(memfname,".mem");

    }

    memfp = fopen(memfname,"w");
    hexfp = fopen(argv[1],"r");

    if(load(hexfp))
	  writeToMemFile(memfp);
    fclose(memfp);
    fclose(hexfp);
}

int load(FILE * hexfp){
    char line[80],name[10],strByte[3];
    int start, length;
    int baseAddr;
    int i,t;
    struct record rec;

    getline(hexfp,line);
    header(line,name,&start,&length);

    baseAddr=findFreeMem(length);

    if(baseAddr == -1){
	  printf("No free memory available.\n");
	  return 0;
    }

    getline(hexfp,line);
    getRecord(line,&rec);
    do{
	  if(rec.type=='T'){
		for(i=0;i<rec.length;i++){
		    strncpy(strByte,rec.content+(2*i),2);
		    strByte[2]='\0';
		    //address start with logical 0
		    memory[rec.start+i+baseAddr - start] = strtol(strByte,0,16);
		}
	  }else if(rec.type=='M'){
		int k, addr;

		//align to four bytes

		for( k=0;k< rec.length / 4;k++){
		    addr= rec.start+baseAddr+ (2*k);

		    memory[addr] = memory[addr]+ (baseAddr/0x100);

		    memory[addr + 1] = memory[addr + 1]+ (baseAddr%0x100);
		}

	  }
	  getline(hexfp,line);
	  getRecord(line,&rec);
    }while(rec.type != 'E');
    return 1;
}

//find first fit memory block.
int findFreeMem(int length){
    int i;
    for(i=0;i<lenfreeMemList;i++){
	  if(freeMemList[i].length >= length)
		return freeMemList[i].startAddr;
    }
    return -1;

}
void writeToMemFile(FILE *memfp){
    int i;
    fprintf(memfp,"Address \t Contents\n");
    for(i=0; i<MEMSIZE;i++){
	  if(i%16 == 0){
		fprintf(memfp,"\n%06X\t",i);
	  }
	  if(i%4 == 0){
		fprintf(memfp," ");
	  }
	  fprintf(memfp,"%02X",memory[i]);

    }
    return;
}

void getRecord(char *line,struct record *rec){

    char temp[80];
    rec->type = line[0];
    if(line[0] == 'T'){
	  strncpy(temp,line+1,6);
	  temp[6]='\0';
	  rec->start = strtoul(temp,0,16);
	  strncpy(temp,line+7,2);
	  temp[2]='\0';
	  rec->length = strtoul(temp,0,16);
	  strncpy(rec->content,line+9, rec->length*2);
    }else if(line[0] == 'M'){
	  strncpy(temp,line+1,6);
	  temp[6]='\0';
	  rec->start = strtoul(temp,0,16);
	  strncpy(temp,line+7,2);
	  temp[2]='\0';
	  rec->length = strtoul(temp,0,16);
    }
    return ;
}

void header(char *line,char *name, int * start, int *length){
    char temp[10];
    if(line[0] == 'H'){
	  strncpy(name,line+1,6);
	  strncpy(temp,line+7,6);
	  *start = strtoul(temp,0,16);
	  strncpy(temp,line+13,6);
	  *length = strtoul(temp,0,16);
    }else{
	  start =0;
	  length =0;
    }
}
int getline(FILE *fp,char * line){
    char ch;
    int cnt=0;
    while ( (ch = fgetc(fp)) != EOF && ch != '\n' ){
	  line[cnt++] = ch;
    }
    line[cnt] = '\0';

    if(line [0] == '\0')
	  return 0;
    else
	  return 1;
}

Sample Output:
test.hex <--- Input

HFIRST 000000000037
T00000018AC0009AC0012656F66000003000000000001000001000004
T0000211648454C4C4F5F574F524C4468656C6C6F5F776F726C64
M00000104
M00000404
E000000

test.mem

Address          Contents

000000   00000000 00000000 00000000 00000000
000010   00000000 00000000 00000000 00000000
-----------------------------------------------------------------
-----------------------------------------------------------------
000FF0   00000000 00000000 00000000 00000000
001000   AC1009AC 1012656F 66000003 00000000
001010   00010000 01000004 00000000 00000000
001020   0048454C 4C4F5F57 4F524C44 68656C6C
001030   6F5F776F 726C6400 00000000 00000000
-----------------------------------------------------------------
-----------------------------------------------------------------

Two operand instruction are not considered. Sample output is included in the program.

#include <stdio.h>
#include <string.h>
#include <errno.h>

#define lenOPTAB 6

struct{
    char opcode[32];
    char hexcode[3];
}OPTAB[]={
    {"ADD","08"},
    {"SUB","1C"},
    {"MUL","20"},
    {"DIV","24"},
    {"MOV","AC"},
    {"END","00"}
};

struct{
    char label[32];
    int address;
}SYMTAB[100];

struct{
    int address;
    int length;
} modifyRec[100];
int lenmodifyRec=0;
typedef struct{
    char label[32];
    char opcode[32];
    char operand[32];

}Token;

typedef struct{
    int address;
    Token src;
    char hexcode[30];
}asmlist;

int lenSRC = 0;
int lenSYMTAB = 0;
int startAddr =0;
int opAddr=0;

void tokenize( char * line, Token *tok);
int  getline(FILE *fp,char * line);
char isOPCODE( char * str);

int pass1(FILE *srcfp, FILE *intfp);
void pass2(FILE *intrfp, FILE *lstfp, FILE *hexfp);

char searchSYMTAB( char * str);
void insertSYMTAB( char * label,int locCntr);
void tokenizeIntr( char * line, asmlist *list);
void initializeTextRec(char *textRec,asmlist list);

int  getAddress(char *symbol);
char * getHexOperand(char * str, char *hexOperand);
char * getOpcodeHex(char *op);
int operandLen(char *str);

void writeintrfile(asmlist list,FILE *fp);
void writelistfile(FILE *fp, asmlist list);
void writeobjheader(FILE *fp,asmlist list);
void writeObjTextRec(FILE *fp, char *str);
void writeModifyRec(FILE *fp);
void writeEnd(FILE *fp);

int  main(int argc, char * argv[]){
    FILE *srcfp, *lstfp, *intrfp, *hexfp;
    char lstfname[30], intrfname[30],hexfname[30];
    if (argc != 2){
        printf("Invalid usage !!!");
        return;
    }

    // generate filename for list,intermediate and hexfiles.
    if( strstr(argv[1],".") ){
        strcpy(lstfname,argv[1]);
        strcpy(strstr(lstfname,"."),".lst");
        strcpy(intrfname,argv[1]);
        strcpy(strstr(intrfname,"."),".int");
        strcpy(hexfname,argv[1]);
        strcpy(strstr(hexfname,"."),".hex");
    }else{
        strcpy(lstfname,argv[1]);
        strcat(lstfname,".lst");
        strcpy(intrfname,argv[1]);
        strcat(intrfname,".int");
        strcpy(hexfname,argv[1]);
        strcat(hexfname,".hex");
    }

    srcfp=fopen(argv[1],"r");
    if(srcfp == NULL){
        printf("!!! Error. Unable to open the src file. ");
        return;
    }

    intrfp=fopen(intrfname,"w");
    if(intrfp == NULL){
        printf("!!! Error. Unable to open the intermediate file. ");
        fclose(srcfp);
        return;
    }

    lstfp=fopen(lstfname,"w");
    if(lstfp == NULL){
        printf("!!! Error. Unable to open the list file. ");
        fclose(srcfp);
        fclose(intrfp);
        return;
    }

    hexfp=fopen(hexfname,"w");
    if(hexfp == NULL){
        printf("!!! Error. Unable to open the hex file. ");
        fclose(srcfp);
        fclose(intrfp);
        fclose(lstfp);
        return;
    }

    // pass 1 generate intermediate file
    if(! pass1(srcfp,intrfp)){
        fclose(srcfp);
        fclose(intrfp);
        return;
    }

    fclose(srcfp);
    fclose(intrfp);

    intrfp=fopen(intrfname,"r");
    if(intrfp == NULL){
        printf("!!! Error. Unable to open the intermediate file. ");
        fclose(srcfp);
        return;
    }

    //generate list file and hexfile
    pass2(intrfp,lstfp,hexfp);

    fclose(lstfp);
    fclose(hexfp);
}

int pass1(FILE *srcfp, FILE *intrfp){
    char line[80];
    char *cptr;

    Token tok;
    int locCntr;
    asmlist list;
    if(! getline(srcfp,line)) return;  // read first line

    tokenize(line,&tok);  // tokenize the line

    if( strcasecmp(tok.opcode,"START") == 0){
        locCntr = strtoul(tok.operand,0,16);
        list.address = locCntr;
        list.src = tok;
        writeintrfile(list,intrfp);
        if(!getline(srcfp,line)) return;
        tokenize(line,&tok);

    }else{
        locCntr =0;
    }

    startAddr=locCntr;
    lenSRC = locCntr;

    while( strcasecmp(tok.opcode,"END") != 0){

        // check for comments. comments start with a '.'

        if( line[0] != '.'){

		list.address = locCntr;
		list.src = tok;
		writeintrfile(list,intrfp); // writes intermediate file.

		// check for label
		if(strlen(tok.label) != 0){
		    if(searchSYMTAB(tok.label)){
			  printf("Error : duplicate symbol @ %s",line);
			  return 0;
		    }else{
			  //insert symboltable entry
			  insertSYMTAB(tok.label,locCntr);
		    }
		}

		//Finds instruction length
		if( isOPCODE(tok.opcode)){
		    locCntr = locCntr +3;
		}
		else if( strcasecmp(tok.opcode,"WORD") == 0){
		    locCntr = locCntr +3;
		}
		else if( strcasecmp(tok.opcode,"RESW") == 0){
		    // operand length is specified in the instruction itself
		    if(tok.operand[0] == 'X'){
			  cptr=strtok(tok.operand," '");
			  if(cptr != NULL)
				locCntr = locCntr + 3* strtoul(cptr,0,16);
		    }
		    else{
			  locCntr = locCntr + 3* strtoul(tok.operand,0,10);
		    }
		}
		else if( strcasecmp(tok.opcode,"RESB") == 0){
		    // operand length is in instruction itself
		    if(tok.operand[0] == 'X'){
			  cptr=strtok(tok.operand," '");
			  if(cptr != NULL)
				locCntr = locCntr + strtoul(cptr,0,16);
		    }
		    else{
			  locCntr = locCntr +  strtoul(tok.operand,0,10);
		    }
		}
		else if( strcasecmp(tok.opcode,"BYTE") == 0){
		    //length of the operand
		    locCntr = locCntr + operandLen(tok.operand);
		}
		else{
		    printf("Error Invalid operation code. @ %s ",line);
		    return 0;
		}
        }
        if(!getline(srcfp,line)) return 0;
        tokenize(line,&tok);
    }

    list.address = locCntr;
    list.src = tok;
    writeintrfile(list,intrfp);

    lenSRC = locCntr - lenSRC;

    return 1;
}

void pass2(FILE *intrfp, FILE *lstfp, FILE *hexfp){
    char line[80];
    asmlist list;
    Token *tok;
    tok = &(list.src);

    char textRec[80];
    int operandAddr=0;
    char hexOperand[80];
    char hexObj[80],temp[80];
    int Index=9;

    if(!getline(intrfp,line)) return;
    tokenizeIntr(line,&list);//tokenize the intermediate code

    if (strcasecmp(tok->opcode,"START") == 0 ){
        writelistfile(lstfp,list);

        if(!getline(intrfp,line)) return;
        tokenizeIntr(line,&list);
    }
    writeobjheader(hexfp,list);  //H+Pgm_Name+Start_Addr+Length
    initializeTextRec(textRec,list); //  T+Starting address

    while(strcasecmp(tok->opcode,"END") != 0){

	  // Valid Opcode
        if(isOPCODE(tok->opcode)){

		if(strlen(tok -> operand) != 0){
		    if(searchSYMTAB(tok->operand)){
			  modifyRec[lenmodifyRec].address=list.address+1;
			  modifyRec[lenmodifyRec].length=4;
			  lenmodifyRec++;

			  // get symbol address
			  operandAddr=getAddress(tok->operand);
			  //opcode+label address
			  sprintf(hexObj,"%s%04X",getOpcodeHex(tok -> opcode), operandAddr);
		    }
		    else{
			  opAddr=list.address+1;
			  if( getHexOperand(tok->operand,hexOperand) == NULL ){
				printf("Invalid operand @ %s",line);
			  }
			  //opcode+operand value
			  sprintf(hexObj,"%s%s",getOpcodeHex(tok -> opcode),hexOperand);
		    }
		}
        }
	  else{
		opAddr=list.address;
		if(strcasecmp(tok -> opcode,"BYTE") == 0 ||	\
		   strcasecmp(tok -> opcode,"WORD") == 0){

		    getHexOperand(tok->operand,hexOperand);
		    //operand
		    sprintf(hexObj,"%s",hexOperand);
		}
		else{
		    getHexOperand(tok->operand,hexOperand);
		    //operand
		    sprintf(hexObj,"%s",hexOperand);

		}
        }

        if((Index+strlen(hexObj)) > 69){
		sprintf(textRec+7,"%02X%s",(strlen(textRec)-9)/2,textRec+9);//place length in lenField
		writeObjTextRec(hexfp,textRec);
		initializeTextRec(textRec,list);
        }

        strncpy(temp,textRec+1,6);
        Index = ((list.address - strtoul(temp,0,16))*2 )+9;

        sprintf(textRec+Index,"%s",hexObj);
        Index =Index + strlen(hexObj);
        strcpy(list.hexcode,hexObj);

        writelistfile(lstfp,list);

        if(!getline(intrfp,line)) return;
        tokenizeIntr(line,&list);

    }
    sprintf(textRec+7,"%02X%s",(strlen(textRec)-9)/2,textRec+9);
    writeObjTextRec(hexfp,textRec);
    writeModifyRec(hexfp);
    writeEnd(hexfp);
}

void insertSYMTAB( char * label,int locCntr){
    strcpy(SYMTAB[lenSYMTAB].label,label);
    SYMTAB[lenSYMTAB].address = locCntr;
    lenSYMTAB ++;
    return;
}

int getline(FILE *fp,char * line){
    char ch;
    int cnt=0;
    while ( (ch = fgetc(fp)) != EOF && ch != '\n' ){
        line[cnt++] = ch;
    }
    line[cnt] = '\0';

    if(line [0] == '\0')
        return 0;
    else
        return 1;
}

void tokenize( char * line, Token *tok){
    char *chr;
    strcpy(tok -> label, "\0");
    strcpy(tok -> opcode, "\0");
    strcpy(tok -> operand, "\0");

    chr =strtok(line, " \t");

    if( chr != NULL){
        //check for opcode
        if ( isOPCODE(chr)){
		strcpy(tok -> opcode,chr); // instruction opcode+operand
		chr = strtok(NULL, " \t");
		if( chr != NULL )
		    strcpy(tok -> operand, chr);
        }else{  // instruction label+opcode+operand
		strcpy(tok->label,chr);
		chr = strtok(NULL, " \t");
		if( chr != NULL )
		    strcpy(tok -> opcode,chr);
		chr = strtok(NULL, " \t");
		if( chr != NULL )
		    strcpy(tok -> operand, chr);
        }
    }
    //printf(" %s | %s | %s \n", tok-> label, tok-> opcode, tok -> operand);
    return;
}

void tokenizeIntr( char * line, asmlist *list){
    char *chr;
    Token *tok;
    tok = & (list -> src);
    list -> address = 0;
    strcpy(list->hexcode,"");
    strcpy(tok -> label, "\0");
    strcpy(tok -> opcode, "\0");
    strcpy(tok -> operand, "\0");

    chr =strtok(line, " \t");

    if( chr != NULL){
        list -> address = strtoul(chr,0,16);
        chr = strtok(NULL, " \t");

        if ( isOPCODE(chr)){
		strcpy(tok -> opcode,chr);
		chr = strtok(NULL, " \t");
		if( chr != NULL )
		    strcpy(tok -> operand, chr);
        }else{
		strcpy(tok->label,chr);
		chr = strtok(NULL, " \t");
		if( chr != NULL )
		    strcpy(tok -> opcode,chr);
		chr = strtok(NULL, " \t");
		if( chr != NULL )
		    strcpy(tok -> operand, chr);
        }
    }
    //printf(" %s | %s | %s \n", tok-> label, tok-> opcode, tok -> operand);
    return;
}

char isOPCODE( char * str){
    int i;
    for (i=0; i < lenOPTAB; i++){
        if( strcasecmp(OPTAB[i].opcode,str) == 0)
		return 1;
    }
    return 0;
}

char searchSYMTAB( char * str){
    int i;
    for (i=0; i < lenSYMTAB; i++){
        if( strcasecmp(SYMTAB[i].label,str) == 0)
		return 1;
    }
    return 0;
}
void writeintrfile(asmlist list,FILE *fp){
    fprintf(fp,"%X\t%s\t%s\t%s\n",list.address,list.src.label,list.src.opcode,list.src.operand);
    return;
}
void writelistfile(FILE *fp, asmlist list){
    fprintf(fp,"%06X\t%s\t%s\t%s\t%s\n",list.address,list.src.label,list.src.opcode,list.src.operand,list.hexcode);
}

void writeobjheader(FILE *fp,asmlist list){
    char line[80];
    int i;

    line [0]='H';
    strncpy(line+1,list.src.label,6);
    sprintf(line+7,"%06X",list.address);
    sprintf(line+13,"%06X",lenSRC);
    line[19]='\0';

    for( i=0; i< 19; i++){
        if(line[i] =='\0')
		line[i]=' ';
    }
    fprintf(fp,"%s\n",line);

}

void writeEnd(FILE *fp){

    fprintf(fp,"E%06X",startAddr);

}
void initializeTextRec( char *textRec,asmlist list){
    int i;
    for(i=0;i<80;i++){
        textRec[i]='0';
    }
    textRec[0]='T';
    sprintf(textRec+1,"%06X",list.address);
    sprintf(textRec+7,"%02X",00);
    return;
}

int getAddress(char *symbol){
    int i;
    for(i=0; i< lenSYMTAB; i++){
        if(strcasecmp(SYMTAB[i].label,symbol) == 0)
		return SYMTAB[i].address;
    }
    return 0;
}
char * getOpcodeHex(char *op){
    int i;
    for(i=0; i< lenOPTAB; i++){
        if(strcasecmp(OPTAB[i].opcode,op) == 0)
		return OPTAB[i].hexcode;
    }
    return "00";
}

int operandLen(char *str){
    char *cptr;
    //Hex Operand
    if(str[0] == 'X' || str[0]=='C'){
        cptr = strtok(str+1," '");
        if(cptr != NULL){
		return strlen(cptr);
        }
        else{
		return 0;
        }
    }
    return 0;
}

char * getHexOperand(char * strOperand, char *hexOperand){
    int i;
    char *cptr;
    char str[80];
    strcpy(str,strOperand);
    //Hex Operand
    if(str[0] == 'X'){
        cptr = strtok(str+1," '");
        if(cptr != NULL){
		sprintf(hexOperand,"%04X",strtoul(cptr,0,16));
        }
        else{
		return NULL;
        }
    }
    //Charector operand
    else if(str[0] == 'C'){

        cptr = strtok(str+1," '");
        if(cptr != NULL){

		for( i=0; cptr[i] != '\0'; i++){
		    sprintf(hexOperand+(2*i),"%02X",cptr[i]);
		}
		hexOperand[2*i]='\0';

        }
        else{
		return NULL;
        }
    }
    //absolute value.
    else if(str[0] == '#'){
	  if( searchSYMTAB(str+1)){
		sprintf(hexOperand,"%04X",getAddress(str+1));
		modifyRec[lenmodifyRec].address=opAddr;
		modifyRec[lenmodifyRec].length=04;
		lenmodifyRec++;
        }else{
		errno =0;
		sprintf(hexOperand,"%04d",strtoul(str,0,10));

		if(errno == EINVAL){
		    return NULL;
		}
        }
    }
    else{

        sprintf(hexOperand,"%06X",strtoul(str,0,16));

    }
    return hexOperand;

}

void writeObjTextRec(FILE *fp, char *str){
    fprintf(fp,"%s\n",str);
}

void writeModifyRec(FILE *fp){
    int i;

    for (i=0; i< lenmodifyRec; i++){
	  fprintf(fp,"M%06X%02X\n",modifyRec[i].address,modifyRec[i].length);
    }
}
Sample Output:
test.asm   <--- Input

COPY    START 0000
FIRST    MOV   THREE
MOV #LENGTH
EOF       BYTE  C'eof'
THREE   WORD  3
ZERO 	WORD 	0
RETADR	RESW	1
LENGTH	RESW	1
BUFFER	RESW	4
MESS1      BYTE  C'HELLO_WORLD'
MESS2      BYTE  C'hello_world'
END

test.lst
000000	COPY	START	0000
000000	FIRST	MOV	THREE	AC0009
000003		MOV	#LENGTH	AC0012
000006	EOF	BYTE	C'eof'	656F66
000009	THREE	WORD	3	000003
00000C	ZERO	WORD	0	000000
00000F	RETADR	RESW	1	000001
000012	LENGTH	RESW	1	000001
000015	BUFFER	RESW	4	000004
000021	MESS1	BYTE	C'HELLO_WORLD'	48454C4C4F5F574F524C44
00002C	MESS2	BYTE	C'hello_world'	68656C6C6F5F776F726C64

test.hex
HFIRST 000000000037
T00000018AC0009AC0012656F66000003000000000001000001000004
T0000211648454C4C4F5F574F524C4468656C6C6F5F776F726C64
M00000104
M00000404
E000000

Sample output is included in the program. Program name and size validation are not done.

#include <stdio.h>
#include <string.h>
#define MEMSIZE  8192 // 8K
struct record{
    char type;
    int start;
    int length;
    char content[80];
};

unsigned char memory[MEMSIZE];

int getline(FILE *fp,char * line);
void header(char *line,char *name, int * start, int *length);
void getRecord(char *line,struct record *rec);
void writeToMemFile(FILE *memfp);
int load(FILE * hexfp);

int main(int argc, char * argv[]){
    FILE *hexfp, *memfp;
    char memfname[30];

    if (argc != 2){
	printf("Invalid usage !!!");
	return;
    }

    if( strstr(argv[1],".") ){
	strcpy(memfname,argv[1]);
	strcpy(strstr(memfname,"."),".mem");

    }else{
	strcpy(memfname,argv[1]);
	strcat(memfname,".mem");

    }

    memfp = fopen(memfname,"w");
    hexfp = fopen(argv[1],"r");
    if(load(hexfp))
	writeToMemFile(memfp);
    fclose(memfp);
    fclose(hexfp);
}

int load(FILE * hexfp){
    char line[80],name[10],strByte[3];
    int start, length;
    int i,t;
    struct record rec;

    getline(hexfp,line);
    header(line,name,&start,&length);

    getline(hexfp,line);
    getRecord(line,&rec);
    do{
	for(i=0;i<rec.length;i++){
	    strncpy(strByte,rec.content+(2*i),2);
	    strByte[2]='\0';
	    memory[rec.start+i] = strtol(strByte,0,16);
	}

	getline(hexfp,line);
	getRecord(line,&rec);
    }while(rec.type != 'E');
    return 1;
}

void writeToMemFile(FILE *memfp){
    int i;
    fprintf(memfp,"Address \t Contents\n");
    for(i=0; i<MEMSIZE;i++){
	if(i%16 == 0){
	    fprintf(memfp,"\n%06X\t",i);
	}
	if(i%4 == 0){
	    fprintf(memfp," ");
	}
	fprintf(memfp,"%02X",memory[i]);

    }
    return;
}

void getRecord(char *line,struct record *rec){

    char temp[80];
    rec->type = line[0];
    if(line[0] == 'T'){
	strncpy(temp,line+1,6);
	temp[6]='\0';
	rec->start = strtoul(temp,0,16);
	strncpy(temp,line+7,2);
	temp[2]='\0';
	rec->length = strtoul(temp,0,16);
	strncpy(rec->content,line+9, rec->length*2);
    }
    return ;
}

void header(char *line,char *name, int * start, int *length){
    char temp[10];
    if(line[0] == 'H'){
	strncpy(name,line+1,6);
	strncpy(temp,line+7,6);
	*start = strtoul(temp,0,16);
	strncpy(temp,line+13,6);
	*length = strtoul(temp,0,16);
    }else{
	start =0;
	length =0;
    }
}
int getline(FILE *fp,char * line){
    char ch;
    int cnt=0;
    while ( (ch = fgetc(fp)) != EOF && ch != '\n' ){
	line[cnt++] = ch;
    }
    line[cnt] = '\0';

    if(line [0] == '\0')
	return 0;
    else
	return 1;
}

Sample Output:

test.hex  <-- Input
HFIRST 000000000037
T00000018AC0009AC0012656F66000003000000000001000001000004
T0000211648454C4C4F5F574F524C4468656C6C6F5F776F726C64
E000000

test.mem

Address 	 Contents

000000	 AC0009AC 0012656F 66000003 00000000
000010	 00010000 01000004 00000000 00000000
000020	 0048454C 4C4F5F57 4F524C44 68656C6C
000030	 6F5F776F 726C6400 00000000 00000000
000040	 00000000 00000000 00000000 00000000
000050	 00000000 00000000 00000000 00000000
000060	 00000000 00000000 00000000 00000000
000070	 00000000 00000000 00000000 00000000

Two operand instruction are not considered. Sample output is included in the program.

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>

#define lenOPTAB 6

struct{
    char opcode[32];
    char hexcode[3];
}OPTAB[]={
    {"ADD","08"},
    {"SUB","1C"},
    {"MUL","20"},
    {"DIV","24"},
    {"MOV","AC"},
    {"END","00"}
};

struct{
    char label[32];
    int address;
    struct addrList * list;
}SYMTAB[100];

struct addrList{
    int address;
    struct addrList * next;
};

typedef struct{
    char label[32];
    char opcode[32];
    char operand[32];

}Token;

typedef struct{
    int address;
    Token src;
    char hexcode[30];
}asmlist;

int lenSRC = 0;
int lenSYMTAB = 0;
int startAddr =0;
int locCntr=0;
void tokenize( char * line, Token *tok);
int  getline(FILE *fp,char * line);
char isOPCODE( char * str);

int assembly(FILE *srcfp, FILE *lstfp,FILE *hexfp);

char searchSYMTAB( char * str);
void insertSYMTAB( char * label,int locCntr);
void initializeTextRec(char *textRec,asmlist list);
void insertSYMTABList(char *operand, int locCntr);
void insertSYMTABaddr(char *label, int address);

int  getAddress(char *symbol);
char * getHexOperand(char * str, char *hexOperand);
char * getOpcodeHex(char *op);
int operandLen(char *str);

void writeintrfile(asmlist list,FILE *fp);
void writelistfile(FILE *fp, asmlist list);
void writeobjheader(FILE *fp,asmlist list);
void writeObjTextRec(FILE *fp, char *str);
void writeUndefinedSym(FILE *hexfp);
void writeEnd(FILE *fp);

int  main(int argc, char * argv[]){
    FILE *srcfp, *lstfp, *intrfp, *hexfp;
    char lstfname[30], intrfname[30],hexfname[30];
    if (argc != 2){
	printf("Invalid usage !!!");
	return;
    }

    // generate filename for list,intermediate and hexfiles.
    if( strstr(argv[1],".") ){
	strcpy(lstfname,argv[1]);
	strcpy(strstr(lstfname,"."),".lst");
	strcpy(hexfname,argv[1]);
	strcpy(strstr(hexfname,"."),".hex");
    }else{
	strcpy(lstfname,argv[1]);
	strcat(lstfname,".lst");
	strcpy(hexfname,argv[1]);
	strcat(hexfname,".hex");
    }

    srcfp=fopen(argv[1],"r");
    if(srcfp == NULL){
	printf("!!! Error. Unable to open the src file. ");
	return;
    }

    lstfp=fopen(lstfname,"w");
    if(lstfp == NULL){
	printf("!!! Error. Unable to open the list file. ");
	fclose(srcfp);
	return;
    }

    hexfp=fopen(hexfname,"w");
    if(hexfp == NULL){
	printf("!!! Error. Unable to open the hex file. ");
	fclose(srcfp);
	fclose(lstfp);
	return;
    }

    assembly(srcfp,lstfp,hexfp);

    fclose(srcfp);
    fclose(lstfp);
    fclose(hexfp);
}

int assembly(FILE *srcfp, FILE *lstfp, FILE *hexfp){
    char line[80];
    char *cptr;

    Token tok;

    asmlist list;
    char value;
    int operandAddr=0;

    char textRec[80],hexObj[80],temp[80],hexOperand[80];
    int Index=9;

    if(! getline(srcfp,line)) return;  // read first line

    tokenize(line,&tok);  // tokenize the line

    if( strcasecmp(tok.opcode,"START") == 0){
	locCntr = strtoul(tok.operand,0,16);
	list.address = locCntr;
	list.src = tok;
	list.hexcode[0]='\0';
	writelistfile(lstfp,list);
	if(!getline(srcfp,line)) return;
	tokenize(line,&tok);

    }else{
	locCntr =0;
    }

    startAddr=locCntr;
    lenSRC = locCntr;

    list.address = locCntr;
    writeobjheader(hexfp,list);  //H+Pgm_Name+Start_Addr+Length
    initializeTextRec(textRec,list); //  T+Starting address

    while( strcasecmp(tok.opcode,"END") != 0){
	// check for comments. comments start with a '.'
	if( line[0] != '.'){
	    list.address = locCntr;
	    list.src = tok;

	    // check for label
	    if(strlen(tok.label) != 0){
		if(value = searchSYMTAB(tok.label)){
		    if(value == 2){
			insertSYMTABaddr(tok.label,locCntr);
		    }else{
			printf("Error : duplicate symbol @ %s",line);
			return 0;
		    }
		}else{
		    //insert symboltable entry
		    insertSYMTAB(tok.label,locCntr);
		}
	    }

	    if( isOPCODE(tok.opcode)){
		if(strlen(tok.operand) != 0){
		    if(searchSYMTAB(tok.operand) == 1){
			// get symbol address
			operandAddr=getAddress(tok.operand);
			//opcode+label address
			sprintf(hexObj,"%s%04X",getOpcodeHex(tok.opcode), operandAddr);
		    }
		    else{
			if( tok.operand[0]!='C'&&tok.operand[0] != 'X'&&tok.operand[0] != '#'&& \
			    ( tok.operand[0] <='0' || tok.operand[0] >= '9') ){
			    insertSYMTABList(tok.operand,locCntr+1);
			    sprintf(hexObj,"%s%04X",getOpcodeHex(tok.opcode), 0);
			}else{
			    getHexOperand(tok.operand,hexOperand) ;
			    //opcode+operand value
			    sprintf(hexObj,"%s%s",getOpcodeHex(tok.opcode),hexOperand);
			}
		    }
		}
		locCntr = locCntr +3;
	    }
	    else if( strcasecmp(tok.opcode,"WORD") == 0){
		getHexOperand(tok.operand,hexOperand);
		sprintf(hexObj,"%s",hexOperand);
		locCntr = locCntr +3;
	    }
	    else if( strcasecmp(tok.opcode,"RESW") == 0){
		getHexOperand(tok.operand,hexOperand);
		sprintf(hexObj,"%s",hexOperand);

		// operand length is specified in the instruction itself
		if(tok.operand[0] == 'X'){
		    cptr=strtok(tok.operand," '");
		    if(cptr != NULL)
			locCntr = locCntr + 3* strtoul(cptr,0,16);
		}
		else{
		    locCntr = locCntr + 3* strtoul(tok.operand,0,10);
		}
	    }
	    else if( strcasecmp(tok.opcode,"RESB") == 0){
		hexObj[0]='\0';
		// operand length is in instruction itself
		if(tok.operand[0] == 'X'){
		    cptr=strtok(tok.operand," '");
		    if(cptr != NULL)
			locCntr = locCntr + strtoul(cptr,0,16);
		}
		else{
		    locCntr = locCntr +  strtoul(tok.operand,0,10);
		}
	    }
	    else if( strcasecmp(tok.opcode,"BYTE") == 0){
		//length of the operand
		getHexOperand(tok.operand,hexOperand);
		sprintf(hexObj,"%s",hexOperand);
		locCntr = locCntr + operandLen(tok.operand);
	    }
	    else{
		printf("Error Invalid operation code. @ %s ",line);
		return 0;
	    }

	}

	if((Index+strlen(hexObj)) > 69){
	    sprintf(textRec+7,"%02X%s",(strlen(textRec)-9)/2,textRec+9);//place length in lenField
	    writeObjTextRec(hexfp,textRec);
	    initializeTextRec(textRec,list);
	}

	strncpy(temp,textRec+1,6);
	Index = ((list.address - strtoul(temp,0,16))*2 )+9;

	sprintf(textRec+Index,"%s",hexObj);
	Index =Index + strlen(hexObj);
	strcpy(list.hexcode,hexObj);
	writelistfile(lstfp,list);
	if(!getline(srcfp,line)) return 0;
	tokenize(line,&tok);
    }

    sprintf(textRec+7,"%02X%s",(strlen(textRec)-9)/2,textRec+9);
    writeObjTextRec(hexfp,textRec);
    writeUndefinedSym(hexfp);
    writeEnd(hexfp);
    return 1;
}

void writeUndefinedSym(FILE *hexfp){
    int i;
    asmlist list;
    char textRec[80];
    struct addrList *alist, *nextList;

    for (i=0; i < lenSYMTAB; i++){
	//printf("%d\n",SYMTAB[i].list);
	if(SYMTAB[i].list != NULL){
	    alist = SYMTAB[i].list;
	    do{
		list.address = alist->address;
		initializeTextRec(textRec,list);
		sprintf(textRec+7,"02%04X",SYMTAB[i].address);
		writeObjTextRec(hexfp,textRec);
		alist = alist->next;
	    }while(alist != NULL);

	}

    }
}
void insertSYMTABList(char *operand, int locCntr){
    int i;
    struct addrList *list, *nextList;
    list = (struct addrList *) malloc(sizeof(struct addrList));
    list->next = NULL;
    list->address =locCntr;

    for (i=0;i<lenSYMTAB;i++){
	if(strcasecmp(SYMTAB[i].label,operand) == 0){
	    if(SYMTAB[i].list == NULL){
		SYMTAB[i].list = list;
	    }else{
		nextList = SYMTAB[i].list;
		while( nextList ->next !=NULL){
		    nextList = nextList->next;
		}
		nextList->next =list;
	    }
	    break;
	}
    }
    if( i == lenSYMTAB){
	strcpy(SYMTAB[lenSYMTAB].label,operand);
	SYMTAB[lenSYMTAB].address = 0;
	SYMTAB[lenSYMTAB].list = list;
	lenSYMTAB ++;

    }
}
void insertSYMTABaddr(char *label, int address){
    int i;
    for (i=0; i < lenSYMTAB; i++){
	if( strcasecmp(SYMTAB[i].label,label) == 0)
	    SYMTAB[i].address = address;
    }
    return ;
}

void insertSYMTAB( char * label,int locCntr){
    strcpy(SYMTAB[lenSYMTAB].label,label);
    SYMTAB[lenSYMTAB].address = locCntr;
    SYMTAB[lenSYMTAB].list = NULL;
    lenSYMTAB ++;
    return;
}

int getline(FILE *fp,char * line){
    char ch;
    int cnt=0;
    while ( (ch = fgetc(fp)) != EOF && ch != '\n' ){
	line[cnt++] = ch;
    }
    line[cnt] = '\0';

    if(line [0] == '\0')
	return 0;
    else
	return 1;
}

void tokenize( char * line, Token *tok){
    char *chr;
    strcpy(tok -> label, "\0");
    strcpy(tok -> opcode, "\0");
    strcpy(tok -> operand, "\0");

    chr =strtok(line, " \t");

    if( chr != NULL){
	//check for opcode
	if ( isOPCODE(chr)){
	    strcpy(tok -> opcode,chr); // instruction opcode+operand
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
	}else{  // instruction label+opcode+operand
	    strcpy(tok->label,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> opcode,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
	}
    }
    //printf(" %s | %s | %s \n", tok-> label, tok-> opcode, tok -> operand);
    return;
}

char isOPCODE( char * str){
    int i;
    for (i=0; i < lenOPTAB; i++){
	if( strcasecmp(OPTAB[i].opcode,str) == 0)
	    return 1;
    }
    return 0;
}

char searchSYMTAB( char * str){
    int i;
    for (i=0; i < lenSYMTAB; i++){
	if( strcasecmp(SYMTAB[i].label,str) == 0){
	    if(SYMTAB[i].address == 0)
		return 2;
	    else
		return 1;
	}

    }
    return 0;
}

void writeintrfile(asmlist list,FILE *fp){
    fprintf(fp,"%X\t%s\t%s\t%s\n",list.address,list.src.label,list.src.opcode,list.src.operand);
    return;
}

void writelistfile(FILE *fp, asmlist list){
    fprintf(fp,"%06X\t%s\t%s\t%s\t%s\n",list.address,list.src.label,list.src.opcode,list.src.operand,list.hexcode);
}

void writeobjheader(FILE *fp,asmlist list){
    char line[80];
    int i;

    line [0]='H';
    strncpy(line+1,list.src.label,6);
    sprintf(line+7,"%06X",list.address);
    sprintf(line+13,"%06X",lenSRC);
    line[19]='\0';

    for( i=0; i< 19; i++){
	if(line[i] =='\0')
	    line[i]=' ';
    }
    fprintf(fp,"%s\n",line);

}

void writeEnd(FILE *fp){
    fprintf(fp,"E%06X",startAddr);
}

void initializeTextRec( char *textRec,asmlist list){
    int i;
    for(i=0;i<80;i++){
	textRec[i]='0';
    }
    textRec[0]='T';
    sprintf(textRec+1,"%06X",list.address);
    sprintf(textRec+7,"%02X",00);
    return;
}

int getAddress(char *symbol){
    int i;
    for(i=0; i< lenSYMTAB; i++){
	if(strcasecmp(SYMTAB[i].label,symbol) == 0)
	    return SYMTAB[i].address;
    }
    return 0;
}
char * getOpcodeHex(char *op){
    int i;
    for(i=0; i< lenOPTAB; i++){
	if(strcasecmp(OPTAB[i].opcode,op) == 0)
	    return OPTAB[i].hexcode;
    }
    return "00";
}

int operandLen(char *str){
    char *cptr;
    //Hex Operand
    if(str[0] == 'X' || str[0]=='C'){
	cptr = strtok(str+1," '");
	if(cptr != NULL){
	    return strlen(cptr);
	}
	else{
	    return 0;
	}
    }
    return 0;
}

char * getHexOperand(char * strOperand, char *hexOperand){
    int i;
    char *cptr;
    char str[80];
    strcpy(str,strOperand);
    //Hex Operand
    if(str[0] == 'X'){
	cptr = strtok(str+1," '");
	if(cptr != NULL){
	    sprintf(hexOperand,"%04X",strtoul(cptr,0,16));
	}
	else{
	    return NULL;
	}
    }
    //Charector operand
    else if(str[0] == 'C'){

	cptr = strtok(str+1," '");
	if(cptr != NULL){

	    for( i=0; cptr[i] != '\0'; i++){
		sprintf(hexOperand+(2*i),"%02X",cptr[i]);
	    }
	    hexOperand[2*i]='\0';

	}
	else{
	    return NULL;
	}
    }
    //absolute value.
    else if(str[0] == '#'){

	if( searchSYMTAB(str+1) ==1){

	    sprintf(hexOperand,"%04X",getAddress(str+1));

	}else if( searchSYMTAB(str+1) ==0 && (str[1] <='0' || str[1] >= '9')){

	    insertSYMTABList(str+1,locCntr+1);
	    sprintf(hexOperand,"%04X",0);

	}else{

	    errno =0;
	    sprintf(hexOperand,"%04d",strtoul(str,0,10));

	    if(errno == EINVAL){
		return NULL;
	    }
	}
    }
    else{

	sprintf(hexOperand,"%06X",strtoul(str,0,16));

    }
    return hexOperand;

}

void writeObjTextRec(FILE *fp, char *str){
    fprintf(fp,"%s\n",str);
}

Sample Output:
test.asm   <--- Input

COPY    START 0000
FIRST    MOV   THREE
MOV #LENGTH
EOF       BYTE  C'eof'
THREE   WORD  3
ZERO 	WORD 	0
RETADR	RESW	1
LENGTH	RESW	1
BUFFER	RESW	4
MESS1      BYTE  C'HELLO_WORLD'
MESS2      BYTE  C'hello_world'
END

test.lst

000000	COPY	START	0000
000000	FIRST	MOV	THREE	AC0000
000003		MOV	#LENGTH	AC0000
000006	EOF	BYTE	C'eof'	656F66
000009	THREE	WORD	3	000003
00000C	ZERO	WORD	0	000000
00000F	RETADR	RESW	1	000001
000012	LENGTH	RESW	1	000001
000015	BUFFER	RESW	4	000004
000021	MESS1	BYTE	C'HELLO_WORLD'	48454C4C4F5F574F524C44
00002C	MESS2	BYTE	C'hello_world'	68656C6C6F5F776F726C64

test.hex
T00000018AC0000AC0000656F66000003000000000001000001000004
T0000211648454C4C4F5F574F524C4468656C6C6F5F776F726C64
T000001020009
T000004020012
E000000

Two operand instruction are not considered. Sample output is included in the program.

#include <stdio.h>
#include <string.h>
#include <errno.h>

#define lenOPTAB 6

struct{
    char opcode[32];
    char hexcode[3];
}OPTAB[]={
    {"ADD","08"},
    {"SUB","1C"},
    {"MUL","20"},
    {"DIV","24"},
    {"MOV","AC"},
    {"END","00"}
};

struct{
    char label[32];
    int address;
}SYMTAB[100];

typedef struct{
    char label[32];
    char opcode[32];
    char operand[32];

}Token;

typedef struct{
    int address;
    Token src;
    char hexcode[30];
}asmlist;

int lenSRC = 0;
int lenSYMTAB = 0;
int startAddr =0;

void tokenize( char * line, Token *tok);
int  getline(FILE *fp,char * line);
char isOPCODE( char * str);

int pass1(FILE *srcfp, FILE *intfp);
void pass2(FILE *intrfp, FILE *lstfp, FILE *hexfp);

char searchSYMTAB( char * str);
void insertSYMTAB( char * label,int locCntr);
void tokenizeIntr( char * line, asmlist *list);
void initializeTextRec(char *textRec,asmlist list);
void writeObjTextRec(FILE *fp, char *str);

int  getAddress(char *symbol);
char * getHexOperand(char * str, char *hexOperand);
char * getOpcodeHex(char *op);
int operandLen(char *str);

void writeintrfile(asmlist list,FILE *fp);
void writelistfile(FILE *fp, asmlist list);
void writeobjheader(FILE *fp,asmlist list);
void writeEnd(FILE *fp);

int  main(int argc, char * argv[]){
    FILE *srcfp, *lstfp, *intrfp, *hexfp;
    char lstfname[30], intrfname[30],hexfname[30];
    if (argc != 2){
        printf("Invalid usage !!!");
        return;
    }

    // generate filename for list,intermediate and hexfiles.
    if( strstr(argv[1],".") ){
        strcpy(lstfname,argv[1]);
        strcpy(strstr(lstfname,"."),".lst");
        strcpy(intrfname,argv[1]);
        strcpy(strstr(intrfname,"."),".int");
        strcpy(hexfname,argv[1]);
        strcpy(strstr(hexfname,"."),".hex");
    }else{
        strcpy(lstfname,argv[1]);
        strcat(lstfname,".lst");
        strcpy(intrfname,argv[1]);
        strcat(intrfname,".int");
        strcpy(hexfname,argv[1]);
        strcat(hexfname,".hex");
    }

    srcfp=fopen(argv[1],"r");
    if(srcfp == NULL){
        printf("!!! Error. Unable to open the src file. ");
        return;
    }

    intrfp=fopen(intrfname,"w");
    if(intrfp == NULL){
        printf("!!! Error. Unable to open the intermediate file. ");
        fclose(srcfp);
        return;
    }

    lstfp=fopen(lstfname,"w");
    if(lstfp == NULL){
        printf("!!! Error. Unable to open the list file. ");
        fclose(srcfp);
        fclose(intrfp);
        return;
    }

    hexfp=fopen(hexfname,"w");
    if(hexfp == NULL){
        printf("!!! Error. Unable to open the hex file. ");
        fclose(srcfp);
        fclose(intrfp);
        fclose(lstfp);
        return;
    }

    // pass 1 generate intermediate file
    if(! pass1(srcfp,intrfp)){
        fclose(srcfp);
        fclose(intrfp);
        return;
    }

    fclose(srcfp);
    fclose(intrfp);

    intrfp=fopen(intrfname,"r");
    if(intrfp == NULL){
        printf("!!! Error. Unable to open the intermediate file. ");
        fclose(srcfp);
        return;
    }

    //generate list file and hexfile
    pass2(intrfp,lstfp,hexfp);

    fclose(lstfp);
    fclose(hexfp);
}

int pass1(FILE *srcfp, FILE *intrfp){
    char line[80];
    char *cptr;

    Token tok;
    int locCntr;
    asmlist list;
    if(! getline(srcfp,line)) return;  // read first line

    tokenize(line,&tok);  // tokenize the line

    if( strcasecmp(tok.opcode,"START") == 0){
        locCntr = strtoul(tok.operand,0,16);
        list.address = locCntr;
        list.src = tok;
        writeintrfile(list,intrfp);
        if(!getline(srcfp,line)) return;
        tokenize(line,&tok);

    }else{
        locCntr =0;
    }

    startAddr=locCntr;
    lenSRC = locCntr;

    while( strcasecmp(tok.opcode,"END") != 0){

        // check for comments. comments start with a '.'

        if( line[0] != '.'){

	    list.address = locCntr;
	    list.src = tok;
	    writeintrfile(list,intrfp); // writes intermediate file.

	    // check for label
	    if(strlen(tok.label) != 0){
		if(searchSYMTAB(tok.label)){
		    printf("Error : duplicate symbol @ %s",line);
		    return 0;
		}else{
		    //insert symboltable entry
		    insertSYMTAB(tok.label,locCntr);
		}
	    }

	    //Finds instruction length
	    if( isOPCODE(tok.opcode)){
		locCntr = locCntr +3;
	    }
	    else if( strcasecmp(tok.opcode,"WORD") == 0){
		locCntr = locCntr +3;
	    }
	    else if( strcasecmp(tok.opcode,"RESW") == 0){
		// operand length is specified in the instruction itself
		if(tok.operand[0] == 'X'){
		    cptr=strtok(tok.operand," '");
		    if(cptr != NULL)
			locCntr = locCntr + 3* strtoul(cptr,0,16);
		}
		else{
		    locCntr = locCntr + 3* strtoul(tok.operand,0,10);
		}
	    }
	    else if( strcasecmp(tok.opcode,"RESB") == 0){
		// operand length is in instruction itself
		if(tok.operand[0] == 'X'){
		    cptr=strtok(tok.operand," '");
		    if(cptr != NULL)
			locCntr = locCntr + strtoul(cptr,0,16);
		}
		else{
		    locCntr = locCntr +  strtoul(tok.operand,0,10);
		}
	    }
	    else if( strcasecmp(tok.opcode,"BYTE") == 0){
		//length of the operand
		locCntr = locCntr + operandLen(tok.operand);
	    }
	    else{
		printf("Error Invalid operation code. @ %s ",line);
		return 0;
	    }
        }
        if(!getline(srcfp,line)) return 0;
        tokenize(line,&tok);
    }

    list.address = locCntr;
    list.src = tok;
    writeintrfile(list,intrfp);

    lenSRC = locCntr - lenSRC;

    return 1;
}

void pass2(FILE *intrfp, FILE *lstfp, FILE *hexfp){
    char line[80];
    asmlist list;
    Token *tok;
    tok = &(list.src);

    char textRec[80];
    int operandAddr=0;
    char hexOperand[80];
    char hexObj[80],temp[80];
    int Index=9;

    if(!getline(intrfp,line)) return;
    tokenizeIntr(line,&list);//tokenize the intermediate code

    if (strcasecmp(tok->opcode,"START") == 0 ){
        writelistfile(lstfp,list);

        if(!getline(intrfp,line)) return;
        tokenizeIntr(line,&list);
    }
    writeobjheader(hexfp,list);  //H+Pgm_Name+Start_Addr+Length
    initializeTextRec(textRec,list); //  T+Starting address

    while(strcasecmp(tok->opcode,"END") != 0){
        // Valid Opcode
        if(isOPCODE(tok->opcode)){

	    if(strlen(tok -> operand) != 0){
		if(searchSYMTAB(tok->operand)){
		    // get symbol address
		    operandAddr=getAddress(tok->operand);
		    //opcode+label address
		    sprintf(hexObj,"%s%04X",getOpcodeHex(tok -> opcode), operandAddr);
		}
		else{
		    if( getHexOperand(tok->operand,hexOperand) == NULL ){
			printf("Invalid operand @ %s",line);
		    }
		    //opcode+operand value
		    sprintf(hexObj,"%s%s",getOpcodeHex(tok -> opcode),hexOperand);
		}
	    }
        }

        else{
	    if(strcasecmp(tok -> opcode,"BYTE") == 0 ||	\
	       strcasecmp(tok -> opcode,"WORD") == 0){
		getHexOperand(tok->operand,hexOperand);
		//operand
		sprintf(hexObj,"%s",hexOperand);
	    }
	    else{
		getHexOperand(tok->operand,hexOperand);
		//operand
		sprintf(hexObj,"%s",hexOperand);

	    }
        }

        if((Index+strlen(hexObj)) > 69){
	    sprintf(textRec+7,"%02X%s",(strlen(textRec)-9)/2,textRec+9);//place length in lenField
	    writeObjTextRec(hexfp,textRec);
	    initializeTextRec(textRec,list);
        }

        strncpy(temp,textRec+1,6);
        Index = ((list.address - strtoul(temp,0,16))*2 )+9;

        sprintf(textRec+Index,"%s",hexObj);
        Index =Index + strlen(hexObj);
        strcpy(list.hexcode,hexObj);

        writelistfile(lstfp,list);

        if(!getline(intrfp,line)) return;
        tokenizeIntr(line,&list);

    }
    sprintf(textRec+7,"%02X%s",(strlen(textRec)-9)/2,textRec+9);
    writeObjTextRec(hexfp,textRec);
    writeEnd(hexfp);
} 

void insertSYMTAB( char * label,int locCntr){
    strcpy(SYMTAB[lenSYMTAB].label,label);
    SYMTAB[lenSYMTAB].address = locCntr;
    lenSYMTAB ++;
    return;
}

int getline(FILE *fp,char * line){
    char ch;
    int cnt=0;
    while ( (ch = fgetc(fp)) != EOF && ch != '\n' ){
        line[cnt++] = ch;
    }
    line[cnt] = '\0';

    if(line [0] == '\0')
        return 0;
    else
        return 1;
}

void tokenize( char * line, Token *tok){
    char *chr;
    strcpy(tok -> label, "\0");
    strcpy(tok -> opcode, "\0");
    strcpy(tok -> operand, "\0");

    chr =strtok(line, " \t");

    if( chr != NULL){
        //check for opcode
        if ( isOPCODE(chr)){
	    strcpy(tok -> opcode,chr); // instruction opcode+operand
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
        }else{  // instruction label+opcode+operand
	    strcpy(tok->label,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> opcode,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
        }
    }
    //printf(" %s | %s | %s \n", tok-> label, tok-> opcode, tok -> operand);
    return;
}

void tokenizeIntr( char * line, asmlist *list){
    char *chr;
    Token *tok;
    tok = & (list -> src);
    list -> address = 0;
    strcpy(list->hexcode,"");
    strcpy(tok -> label, "\0");
    strcpy(tok -> opcode, "\0");
    strcpy(tok -> operand, "\0");

    chr =strtok(line, " \t");

    if( chr != NULL){
        list -> address = strtoul(chr,0,16);
        chr = strtok(NULL, " \t");

        if ( isOPCODE(chr)){
	    strcpy(tok -> opcode,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
        }else{
	    strcpy(tok->label,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> opcode,chr);
	    chr = strtok(NULL, " \t");
	    if( chr != NULL )
		strcpy(tok -> operand, chr);
        }
    }
    //printf(" %s | %s | %s \n", tok-> label, tok-> opcode, tok -> operand);
    return;
}

char isOPCODE( char * str){
    int i;
    for (i=0; i < lenOPTAB; i++){
        if( strcasecmp(OPTAB[i].opcode,str) == 0)
	    return 1;
    }
    return 0;
}

char searchSYMTAB( char * str){
    int i;
    for (i=0; i < lenSYMTAB; i++){
        if( strcasecmp(SYMTAB[i].label,str) == 0)
	    return 1;
    }
    return 0;
}
void writeintrfile(asmlist list,FILE *fp){
    fprintf(fp,"%X\t%s\t%s\t%s\n",list.address,list.src.label,list.src.opcode,list.src.operand);
    return;
}
void writelistfile(FILE *fp, asmlist list){
    fprintf(fp,"%06X\t%s\t%s\t%s\t%s\n",list.address,list.src.label,list.src.opcode,list.src.operand,list.hexcode);
}

void writeobjheader(FILE *fp,asmlist list){
    char line[80];
    int i;

    line [0]='H';
    strncpy(line+1,list.src.label,6);
    sprintf(line+7,"%06X",list.address);
    sprintf(line+13,"%06X",lenSRC);
    line[19]='\0';

    for( i=0; i< 19; i++){
        if(line[i] =='\0')
	    line[i]=' ';
    }
    fprintf(fp,"%s\n",line);

}

void writeEnd(FILE *fp){

    fprintf(fp,"E%06X",startAddr);

}
void initializeTextRec( char *textRec,asmlist list){
    int i;
    for(i=0;i<80;i++){
        textRec[i]='0';
    }
    textRec[0]='T';
    sprintf(textRec+1,"%06X",list.address);
    sprintf(textRec+7,"%02X",00);
    return;
}

int getAddress(char *symbol){
    int i;
    for(i=0; i< lenSYMTAB; i++){
        if(strcasecmp(SYMTAB[i].label,symbol) == 0)
	    return SYMTAB[i].address;
    }
    return 0;
}
char * getOpcodeHex(char *op){
    int i;
    for(i=0; i< lenOPTAB; i++){
        if(strcasecmp(OPTAB[i].opcode,op) == 0)
	    return OPTAB[i].hexcode;
    }
    return "00";
}

int operandLen(char *str){
    char *cptr;
    //Hex Operand
    if(str[0] == 'X' || str[0]=='C'){
        cptr = strtok(str+1," '");
        if(cptr != NULL){
	    return strlen(cptr);
        }
        else{
	    return 0;
        }
    }
    return 0;
}

char * getHexOperand(char * strOperand, char *hexOperand){
    int i;
    char *cptr;
    char str[80];
    strcpy(str,strOperand);
    //Hex Operand
    if(str[0] == 'X'){
        cptr = strtok(str+1," '");
        if(cptr != NULL){
	    sprintf(hexOperand,"%04X",strtoul(cptr,0,16));
        }
        else{
	    return NULL;
        }
    }
    //Charector operand
    else if(str[0] == 'C'){

        cptr = strtok(str+1," '");
        if(cptr != NULL){

	    for( i=0; cptr[i] != '\0'; i++){
		sprintf(hexOperand+(2*i),"%02X",cptr[i]);
	    }
	    hexOperand[2*i]='\0';

        }
        else{
	    return NULL;
        }
    }
    //absolute value.
    else if(str[0] == '#'){
        if( searchSYMTAB(str+1)){
	    sprintf(hexOperand,"%04X",getAddress(str+1));

        }else{
	    errno =0;
	    sprintf(hexOperand,"%04d",strtoul(str,0,10));

	    if(errno == EINVAL){
		return NULL;
	    }
        }
    }
    else{

        sprintf(hexOperand,"%06X",strtoul(str,0,16));

    }
    return hexOperand;

}

void writeObjTextRec(FILE *fp, char *str){
    fprintf(fp,"%s\n",str);
}

Sample Output:
test.asm

COPY    START 0000
FIRST    MOV   THREE
MOV #LENGTH
EOF       BYTE  C'eof'
THREE   WORD  3
ZERO 	WORD 	0
RETADR	RESW	1
LENGTH	RESW	1
BUFFER	RESW	4
MESS1      BYTE  C'HELLO_WORLD'
MESS2      BYTE  C'hello_world'
END

test.lst

000000	COPY	START	0000
000000	FIRST	MOV	THREE	AC0009
000003		MOV	#LENGTH	AC0012
000006	EOF	BYTE	C'eof'	656F66
000009	THREE	WORD	3	000003
00000C	ZERO	WORD	0	000000
00000F	RETADR	RESW	1	000001
000012	LENGTH	RESW	1	000001
000015	BUFFER	RESW	4	000004
000021	MESS1	BYTE	C'HELLO_WORLD'	48454C4C4F5F574F524C44
00002C	MESS2	BYTE	C'hello_world'	68656C6C6F5F776F726C64

test.hex

HFIRST 000000000037
T00000018AC0009AC0012656F66000003000000000001000001000004
T0000211648454C4C4F5F574F524C4468656C6C6F5F776F726C64
E000000

The solution consists of the following,
An API for performing basic creates, read, update and delete operations of persistent classes
A language for specifying queries (object oriented expression language) that refers to classes and properties of the classes.
A facility for specifying mapping metadata

Development Platform:
Operating system : Linux
Compilers : gcc-compatible C++
Database : MySQL

#include <stdio.h>
#include <stdlib.h>

#define Q_SIZE      100
#define S_SIZE      100

#define VISITED        1       //MOD 01
#define NOTVISITED 0       //MOD 01

struct vertex_node {
    int data,status;
    struct vertex_node *next;
    struct adj_link *adj;
};

struct adj_link {
    struct vertex_node *next;
    struct adj_link *adj;
};

typedef struct vertex_node v_node;
typedef struct adj_link a_link;

v_node * create   ();
void     bfs      ( v_node * );
void     dfs      ( v_node * );
char     getchoice();
void     free_node( v_node * );
void     free_link( a_link * );
 
int main(){
    char choice;
    v_node *head=NULL;
    printf("Creating the Graph in Adjacency List Representation \n");
    head = create();
    do{
	  choice = getchoice();

	  switch (choice){
	  case '1':
		bfs(head);
		break;
	  case '2':
		dfs(head);
		break;
	  case '3':
		free_node(head);
		break;
	  default:
		printf("Invalid Choice !!! \n");
	  }
    }while(choice != '3');
    return;
}
/******************************************************************
This funciton will display the menu and get user's choice.
******************************************************************/
char getchoice(){
    char temp[80];
    printf ("\n");
    printf ("1: Breadth First Search\n");
    printf ("2: Depth First Search\n");
    printf (" 3: Exit \n\n");
    printf ("Choice ? ");
    scanf("%s",temp);
  
    return temp[0];
}

/******************************************************************
This funciton create a graph using adjacentcylist.
******************************************************************/
v_node * create(){
    int tmp_data;
    v_node * head, *node, *adj_node;
    a_link * link, *p_link;
    head = NULL;

    //Read the vertex list.
    printf("Node in the Graph (Type Ctrl-D to END): \n");

    while( ( scanf ( "%d",&tmp_data )) != EOF){

	  node = ( v_node* ) malloc ( sizeof(v_node) );

	  node -> data = tmp_data;
	  node -> status = NOTVISITED;
	  node -> next = NULL;
	  node -> adj = NULL;

	  if ( head == NULL ){
		head     = node;
		adj_node = node;
	  }
	  else{
		adj_node -> next = node;
		adj_node = node;
	  }
    }

    //Read the edge list.
    node = head;

    while( node != NULL ){
	  p_link = NULL;
	  printf ("Links from %d node (Type Ctrl-D to END \n",node -> data);   //MOD 01
	  while ( ( scanf("%d",&tmp_data)) != EOF){
		link = (a_link *) malloc (sizeof(a_link));
		link -> adj = NULL;
		if ( p_link == NULL){
		    node -> adj = link;
		    p_link = link;
		}
		else{
		    p_link -> adj = link;
		    p_link = link;
		}

		// give a cross link to corresponding vertex
		adj_node = head;
		while ( adj_node != NULL){
		    if ( adj_node -> data == tmp_data){
			  link -> next = adj_node;
		    }
		    adj_node = adj_node -> next;
		}
	  }
	  node = node -> next;
    }
    return head;
}


void bfs ( v_node * head){
    int queue[Q_SIZE], q_front=-1, q_rear=-1;
    v_node * node, *adj_node;
    a_link * link;
    node = head;

    while ( node != NULL){
	  node -> status = NOTVISITED;
	  node = node -> next;
    
    }

    node = head;

    q_rear++;
    queue[q_rear] = node-> data;
    q_front++;
    node -> status = VISITED;

    while ( q_front <= q_rear ) {
	  node = head;

	  while ( node != NULL){
		if ( node -> data == queue[q_front]){
		    break;
		}
		node = node -> next;
	  }

	  link = node -> adj;

	  while ( link != NULL ){
		adj_node = link -> next;
		if( adj_node -> status == NOTVISITED ){
		    q_rear ++;
		    queue[q_rear] = adj_node -> data;

		    adj_node -> status = VISITED;
		}
		link = link -> adj;
	  }
	  q_front++;
    }
    q_front =0;

    printf ("Breadth First Search Path: \n");

    while ( q_front <= q_rear){
	  printf ( "%d ",queue[q_front] );
	  q_front++;
    }

    printf("\n");
    return;
}

void dfs ( v_node * head){
    v_node *node, *adj_node;
    a_link *link;
    int stack[S_SIZE],top=0;

    node = head;
    while ( node != NULL ){
	  node -> status = NOTVISITED;
	  node = node -> next;
    }

    node = head;
    stack[top] = node -> data;
    node -> status = VISITED;

    printf("Depth First Search Path: \n");
    while ( top >= 0){
	  node = head;
	  while ( node != NULL){
		if ( node -> data == stack[top]){
		    break;
		}
		node = node -> next;
	  }

	  printf("%d ",stack[top]);
	  top--;
	  link = node -> adj;
	  while ( link != NULL){
		adj_node= link -> next;
		if( adj_node -> status == NOTVISITED){
		    top++;
		    stack[top] = adj_node -> data;
		    adj_node -> status = VISITED;
		}
		link = link->adj;
	  }
    }
    printf("\n");
    return;
}

void free_node (v_node *node){
    if (node -> next != NULL){
	  free_node (node -> next);
    }
    if(node -> adj != NULL){
    	free_link(node->adj);
    }    
    free(node);
  
    return;
}

void free_link (a_link *link){
    if(link -> adj != NULL){             //MOD 01
	  free_link(link -> adj);
    }
    free(link);
    return;
}
 


         ]]>
			http://quoans.wordpress.com/2009/05/15/graph-seaching-bfs-and-dfs/feed/
		0
	
		
			Renjith S