Subversion Repositories ncore

//STEFAN, Istvan

//Little endian???

//published under GPL

//Mukodik:

//      utasitasok, regiszterek, direktivak felismerese

//      kovetkezo direktivaknal szam felismerese:

//              .byte,.word,.dword,.qword,.ascii,.asciiz

//              nincs szohatarhoz igazitva az adatsor vege sem eleje

//      nincs kezelve, szukseges?:

//              .nibble,.bool,.space!!!Ez kellene

//              .stack:verem meretenek beallitasa

//      todo:

//              stack meretenek olvasasa

//              hexa szamok felismerese (boolean, octa?)

//              szohatarhoz igazitas

//              kimeneti fajlformatum:

//                      szekciok meretenek kiirasa

//                      !!eddig nem tud futni a sim

//              a sorszamok helyes szamolasa

#include 

#include //strcmp(),strcpy()

#include //atoll()

//Line number

int line=0;

//Version of the core

int version=1;;

//Instruction's names

#define MAXCMD 16

char *cmds[MAXCMD+1]={"coA","coB","add","sub","mvA","mvB","shl","shr"

                ,"and","orr","xor","jmp","Fmv","mvD","Dmv","mvP",""};

char *cmds2[MAXCMD+1]={"mvA","coA","mvB","coB","csB","shl","shr","and"

                ,"orr","xor","add","sub","cal","ret","Imv","jmp",""};

char *cmds3[MAXCMD+1]={"mvA","coA","mvB","coB","csB","shl","shr","and"

                ,"orr","xor","add","sub","int","ire","Imv","jmp",""};

//Register's names

#define MAXREG 16

char *regs[MAXREG+1]={"reg0","reg1","reg2","reg3","reg4","reg5","reg6","reg7"

                ,"reg8","reg9","reg10","reg11","reg12","reg13","reg14","reg15",""};

char *regs_d[MAXREG+1]={"$0","$1","$2","$3","$4","$5","$6","$7"

                ,"$8","$9","$10","$11","$12","$13","$14","$15",""};

char *regs_r[MAXREG+1]={"r0","r1","r2","r3","r4","r5","r6","r7"

                ,"r8","r9","r10","r11","r12","r13","r14","r15",""};

char *regs_n[MAXREG+1]={"","","","","","","",""

                ,"","","","ireA","FLAG","mem","DP","IP",""};//???

//Directive's names

#define MAXDIR 12

char *dire[MAXDIR+1]={".data",".stack",".text",".core3",".byte",".word",".dword",

                ".qword",".ascii",".asciiz",".space",".core2",""};

int dorg=0,torg=0;//Global vars, place actual in the section .data/.text

int stackl=0;

char datab=0,stackb=0,textb=0;//These directives can be declared only one time

    //0:not yet defined,1:defined,2:actual section

struct labstruct{

    char name[15];

    unsigned int address;

    unsigned char label_type;//0:address not defined,1:data label,2:text label

};

//Storing the labels

struct labstruct lab[100];

int maxlab=0;//Current number of labels

//Structure of the binary file:

//      address of main function (unsigned int)

//      length of stack section (unsigned int)

//              ???length of the next section (unsigned int)

//      .data section

//              //0x0000:the adress of the stack at runtime->deleted

//              label's pointers

//              initialised datas

//              ???length of the next section (unsigned int)

//      .text section

//              ???length of the next section (unsigned int){0}

//      ???chksum???

//Structure on execution:

//      .text segment

//      .data segment:

//              address of stack?->deleted

//      .stack

//Structure of the data section at the runtime

//      0x0 address of the stack

//      0x1 addresses of the labels (functions, variables, etc)

int wordsize=32;//This is the width of the registers and granulity of the .data

int htu(char *c){

    printf("Asm compiler for the nCore project at opencores.org\n");

    printf("Published under the GPL.\n");

    printf("\tUse:\n");

    printf("\t%s infile.asm [outfile]\n",c);

    return(0);

}

char fgetc_line(FILE *f){

    char c=fgetc(f);

    if(c=='\n')

        line++;//We count the line-number

    return c;

}

int whitespace(char c){

return ((c==' ')|(c=='\t')|(c=='\n')|(c=='\r')|(c==';')

        |(c==':'));//For labels

}

#undef debug

//#define debug

char readchar(FILE * f){

    char c;

#ifdef debug

    printf("\treadchar");

    c=fputc(fgetc_line(f),stdout);

#else

    c=fgetc_line(f);

#endif

    if(feof(f))return(-10);

    while(whitespace(c)){

        if(c==';'){

#ifdef debug

            while(fputc(fgetc_line(f),stdout)!='\n')

#else

            while(fgetc_line(f)!='\n')

#endif

                    if(feof(f))return(-10);

                    //line++;

                    }

#ifdef debug

        c=fputc(fgetc_line(f),stdout);

#else

        c=fgetc_line(f);

#endif

        if(feof(f))return(-10);

        }

#ifdef debug

    fputc('\n',stdout);

#endif

//    if(c=='\n')

        //line++;

    return(c);

}

int newlabel(char * s){//Add the label name s to the list of labels(w/o address)

    int i=0;

    while(((i

        i++;

    if(i

        return(-1);//The label already exist, we can't overwrite it

    strcpy(lab[maxlab].name,s);

    lab[maxlab].address=0;

    lab[maxlab].label_type=0;//'Not yet used' label

    maxlab++;

    return(i);//i=maxlab-1

}

int findlabel(char * s){//Search the label s in the label's list

    int i=0;

    while(((i

        i++;

    if(i==maxlab)

        return(-1);//The label not exist

    return(i);

}

//#define debug

int addlabel(char * s){//Add the address to the existing label s

    int i=0;

    while(((i

        i++;

    if(datab==2){

        lab[i].address=dorg;

        lab[i].label_type=1;//Label under use, pointing to data

        return(i);

        }

    else if(textb==2){

        lab[i].address=torg;

        lab[i].label_type=2;//Label under use, pointing to function

#ifdef debug

        printf("Marked label at %d:%d\n",torg,lab[i].address);

#endif

        return(i);

        }

    else return(-2);//We can't define a label out of the .data/.text sections

}

#undef debug

//#define debug

int readreg(FILE * f){//visszateres: 0< regiszter, <0 cimke, 

    char cmd[31];

    int i=0;

    if(feof(f))return(-10);

    cmd[0]=readchar(f);

    while(!whitespace(cmd[i])){

        i++;

        cmd[i]=fgetc_line(f);

    if(feof(f))return(-10);

    }

    cmd[i]=0;

#ifdef debug

    printf("\treg:%s\n",cmd);

#endif

    i=0;

    while((strcmp(cmd,regs[i])!=0)&(i

#ifdef debug

        printf("%s:%s\n",cmd,regs[i]);

#endif

        i++;}

    if(i

#ifdef debug

        printf("%s\n",regs[i]);

#endif

        return(i);

    }

//Not in the regs set

    i=0;

    while((strcmp(cmd,regs_d[i])!=0)&(i

        i++;}

    if(i

#ifdef debug

        printf("%s\n",regs_d[i]);

#endif

        return(i);

    }

//Not in the regs_d set

    i=0;

    while((strcmp(cmd,regs_r[i])!=0)&(i

        i++;}

    if(i

#ifdef debug

        printf("%s\n",regs_r[i]);

#endif

        return(i);

    }

//Not in the regs_r set

    i=0;

    while((strcmp(cmd,regs_n[i])!=0)&(i

        i++;}

    if(i

#ifdef debug

        printf("%s\n",regs_n[i]);

#endif

        return(i);

    }

if(version>1){//We can use a label as param only after version 2 of the core

#ifdef debug

        printf("Unknown register:%s, searching in labels...",cmd);

#endif

    i=findlabel(cmd);

    if(i==-1){

        i=newlabel(cmd);

#ifdef debug

        printf("created.\n");

#endif

        }

#ifdef debug

    else

        printf("found.\n");

#endif

    return (-i-1);

}

        printf("Unknown register:%s, at line %d\n",cmd,line);

        return(-maxlab-10);//Unknown register/label

}

#undef debug

int direrr(char * dire){

    printf("%s was declared more than once.\nLine:%d",dire,line);

    return(-1);

}

#undef debug

//#define debug

int getvalue(FILE *f,FILE * d,int w){//Recognizing dec,hex,oct,bin numbers!!!,

                        //and writing to .data

    char s[15];//TODO!!!!

    int i=0;//No of readed numbers

    long long j=0;

    int l;//writed bytes

    int ch;

    char c;//the next character in f

    int k;//altalanos ciklusvaltozo

    c=fgetc_line(f);

#ifdef debug

    printf("Readed0:%c",c);

#endif

    if(feof(f))

        return(-1);//Early file-end

    while(!feof(f)){

        while(((c==' ')|(c=='\t'))&(!feof(f))){

            c=fgetc_line(f);

#ifdef debug

            printf("Readed1:%c",c);

#endif

            }

#ifdef debug

        printf("\t First readed char:'%c',%d\n",c,c);

#endif

        if(feof(f))

            return(-1);//Early file-end

        if(((c>'9')|(c<'0'))&((c!='\'')&(c!='\"')&(c!=',')&(c!=' ')&(c!='\t'))){

            printf("Need number after this directive\nLine:%d",line);

            return(-1);//Early end-of-line or not well-formatted

            }

        switch(c){

            case '\''://This will be a character

                c=fgetc_line(f);

#ifdef debug

                printf("Readed2:%c",c);

#endif

                if(feof(f))

                    return(-1);//Early file-end

                if((ch=fgetc_line(f))!='\'')//Not well-coded

                    return(-1);

#ifdef debug

                printf("readed3:%c",ch);

#endif

                fputc(c,d);//Writing out the data

#ifdef debug

                printf("writed:'%c'",c);

#endif

                i++;//We have one more data

                c=fgetc_line(f);

                break;

            case '\"'://This will be a string

                c=fgetc_line(f);

#ifdef debug

                printf("readed4:%c",c);

#endif

                if(feof(f))

                    return(-1);//Early file-end

                while((c!='\"')&(c!='\n')&(c!='\r')&(!feof(f))){//Until the end

                    if((c=='\n')|(c=='\r'))

                        return(-1);//Not well-coded

                    if((c!='\"')){

                        fputc(c,d);

#ifdef debug

                        printf("writed:'%c'",c);

#endif

                        i++;

                        c=fgetc_line(f);

#ifdef debug

                        printf("readed5:%c",c);

#endif

                        if(feof(f))

                            return(-1);//Early file-end

                        }

                    }

                c=fgetc_line(f);

                break;

            case ';'://This is a comment? Not well-coded?

            case '\n'://This is the end of the line

            case '\r'://This is the end of the line

                goto end_of_function;//:-S

//              return(i);

                break;

            default://This is possibly a number

                j=0;

                s[0]=c;

                while(((!whitespace(c))&(c!=','))&(!feof(f))){

                    j++;

                    c=fgetc_line(f);

                    s[j]=c;

#ifdef debug

                    printf("readed6:'%c'",c);

#endif

                    }

                if(feof(f))

                    return(-1);//Early end of file

                s[j]='\0';

                j=atoll(s);

#ifdef debug

                    printf("\nreaded6 number:\"%lld\",'%s', till now:%d\n",j,s,i);

#endif

                do{//little endian

                    ch=j%256;

                    fputc(ch,d);

#ifdef debug

                    printf("writed:'%d',bytes:%d",ch,i);

#endif

                    i++;

                    j=j/256;

                }while(j!=0);

        }

        while((whitespace(c))&((c!='\n')&(c!='\r'))&(!feof(f)))

            c=fgetc_line(f);

#ifdef debug

            printf("Readed7:'%c'",c);

#endif

        switch(c){

            case ';'://This is comment? Not well-coded?

            case '\n':

            case '\r'://End of line..

//              line++;

                goto end_of_function;//:-S

//              return(i);

                break;

            case ' '://Next item

            case '\t'://Next item

            case ','://Next item

                c=fgetc_line(f);

#ifdef debug

                printf("%c",c);

#endif

                break;

            default:

                return(-1);//Something not well...

        }

    }

    return(-1);

    end_of_function:

//    while(i%(wordsize/8)!=0){

//    while(i%w!=0){

    while(i%4!=0){

        fputc(0,d);

        i++;

        }

    return i;

}

#undef debug

//#define debug

long readconst(FILE * f){//Recognizing dec,hex,oct,bin numbers!!!,

                        //and writing to .data

    int i;//Var for reading the string

    long j=-1;//The readed consant

    char s[15];//TODO!!!!

    int ch;

    char c;//the next character in f

    int k;//altalanos ciklusvaltozo

    c=fgetc_line(f);

#ifdef debug

    printf("Readed0:%c",c);

#endif

    if(feof(f))

        return(-1);//Early file-end

//    while(!feof(f)){

        while(((c==' ')|(c=='\t'))&(!feof(f))){

            c=fgetc_line(f);

#ifdef debug

            printf("Readed1:%c",c);

#endif

            }

#ifdef debug

        printf("\t First readed char:'%c',%d\n",c,c);

#endif

        if(feof(f))

            return(-1);//Early file-end

        if(((c>'9')|(c<'0'))&((c!='\'')&(c!='\"')&(c!=','))){

            printf("Need number after this directive\nLine:%d",line);

            return(-1);//Early end-of-line or not well-formatted

            }

        switch(c){

            case ';'://This is a comment? Not well-coded?

            case '\n'://This is the end of the line

            case '\r'://This is the end of the line

                goto end_of_function;//:-S

//              return(i);

                break;

            default://This is possibly a number

                i=0;

                s[0]=c;

                while(((!whitespace(c))&(c!=','))&(!feof(f))){

                    i++;

                    c=fgetc_line(f);

                    s[i]=c;

#ifdef debug

                    printf("readed6:'%c'",c);

#endif

                    }

                if(feof(f))

                    return(-1);//Early end of file

                s[i]='\0';

                j=atoll(s);

#ifdef debug

                    printf("\nreaded6 number:\"%ld\",'%s'\n",j,s);

#endif

        }

//    }

    end_of_function:

    return j;

}

#undef debug

//#define debug

int directive(char * s,FILE * f,FILE * d){

    int i=0,j=0,k,l;

    while((strcmp(s,dire[i])!=0)&(i

#ifdef debug

//      printf("%s:%s\n",s,dire[i]);

#endif

        i++;}

    if(i==MAXDIR){

        printf("Unknown directive:%s\nLine:%d",s,line);

        return(-5);//Unknown instruction

        }

#ifdef debug

    printf("Directive recognized:\n\t%s,%d\nLine:%d",dire[i],i,line);

#endif

    switch(i){

        case 0://.data

                if(stackb==2)

                    stackb=1;

                if(textb==2)

                    textb=1;

                datab=2;

            break;

        case 1://.stack

            if(stackb){

                return(direrr(s));

            }

            else{

                if(datab==2)

                    datab=1;

                if(textb==2)

                    textb=1;

                stackb=2;

                if(!(stackl=readconst(f))){

                    printf("Not found size after directive .stack\n");

                    return(-1);

                    }

            }

            break;

        case 2://.text

                if(stackb==2)

                    stackb=1;

                if(datab==2)

                    datab=1;

                textb=2;

            break;

        case 3://.core3 we are working with the 3d version

            version=3;

            break;

        case 4://.byte

            if(datab==2){

                j=getvalue(f,d,1);

                dorg+=j*8/(wordsize);

//              dorg+=(j*8)/wordsize;

//              if((j*8)%wordsize!=0)

//                  dorg++;

                }

            else j=-5;

            break;

        case 5://.word

            if(datab==2){

                j=getvalue(f,d,2);

                dorg+=j*16/(wordsize);

//              dorg+=(j*16)/wordsize;

//              if((j*16)%wordsize!=0)

//                  dorg++;

                }

            else j=-5;

            break;

        case 6://.dword

            if(datab==2){

                j=getvalue(f,d,4);

printf("\t%d\n",j);

                dorg+=j*32/(wordsize);

//              dorg+=(j*32)/wordsize;

//              if((j*32)%wordsize!=0)

//                  dorg++;

                }

            else j=-5;

            break;

        case 7://.qword

            if(datab==2){

                j=getvalue(f,d,8);

printf("\t%d\n",j);

                dorg+=j*64/(wordsize);

//              dorg+=(j*64)/wordsize;

                }

            else j=-5;

            break;

        case 8://.ascii we will using one character per word

            if(datab==2){

                dorg+=getvalue(f,d,1)*8/(wordsize);

                }

            else j=-5;

            break;

        case 9://.asciiz we will using one character per word

            if(datab==2){//!!bug, end of the string&dorg

                dorg+=(getvalue(f,d,1)+1)*8/(wordsize);

                for(k=0;k<(wordsize/8.0);k++)

                    fputc('0',d);

                //dorg++;

                }

            else j=-5;

            break;

        case 10://.space in byte

            if(datab==2){

                j=readconst(f);

                for(k=0;k

                    fputc('0',d);

                dorg+=(j*8)/wordsize;

                if((j*8)%wordsize!=0)

                    dorg++;

                while((j*8)%wordsize!=0){

                    fputc(0,d);

                    j++;

                    }

                }

            else j=-5;//Not in the data section

            break;

        case 11://.core2 we are working with the 2nd version

            version=2;

            break;

        default:

            return(-5);//Something error

    }

    if(j<0){

#ifdef debug

        printf("Wrong place of data.\nLine:%d",line);

#endif

        return(j);

    }

    return(i);

}

#undef debug

//#define debug

int readcmd(FILE *f,FILE *d,FILE *t){

    char cmd[31];//TODO!!

    int j;//The register part

    int i=0;//The instruction part

#ifdef debugg

printf("\t\ttorg:%d,dorg:%d\n",torg,dorg);

#endif

    if(feof(f))return(-10);

    cmd[0]=readchar(f);

    while(!whitespace(cmd[i])){

        i++;

        cmd[i]=fgetc_line(f);

    if(feof(f))return(-10);

    }

    if(cmd[i]!=':')

        cmd[i]='\0';

    else

        cmd[i+1]='\0';

    if(cmd[0]=='.'){//This is compiler-directive

        if(directive(cmd,f,d)<0){

#ifdef debug

            printf("Directive:'%s'\n",cmd);

#endif

            return(-2);

            }

        return(-1);

        }

    if(cmd[i]==':'){

    cmd[i]=0;

#ifdef debug

    printf("Label:'%s',at %d\n",cmd,torg);

#endif

        //Searching for a pre-defined label

        i=findlabel(cmd);

        if(i<0)

            newlabel(cmd);

        addlabel(cmd);//Setting the address of the label

        return(-3);}//This is label

#ifdef debug

    printf("\tcmd:'%s'\n",cmd);

#endif

    i=0;

switch(version){

case 1:{//version==1

    while((strcmp(cmd,cmds[i])!=0)&(i

#ifdef debug

    printf("%s:%s\n",cmd,cmds[i]);

#endif

        i++;}

    }

case 2:{//version==2

    while((strcmp(cmd,cmds2[i])!=0)&(i

#ifdef debug

    printf("%s:%s\n",cmd,cmds2[i]);

#endif

        i++;}

    }

case 3:{//version==3

    while((strcmp(cmd,cmds3[i])!=0)&(i

#ifdef debug

    printf("%s:%s\n",cmd,cmds3[i]);

#endif

        i++;}

    }

}

    if(i==MAXCMD){

        printf("Unknown instruction:%s\nLine:%d\n",cmd,line);

        return(-5);//Unknown instruction

        }

#ifdef debug

    printf("Instruction recognized:\n\t%s ",cmds[i]);

#endif

    if(textb!=2){

//Only for ver1!!!

#ifdef debug

        printf("Found instruction not in the text section:%s!\nLine:%d\n",cmds[i],line);

#endif

        return(-5);

    }

//      instruction in 'i', register or label in 'j'

    //If the instruction is cxx, we need to read the constant

if(((version==1)&((i==0) | (i==1)))|((version>2)&((i==1) | (i==3) | (i==4)))){

    torg++;

    j=readconst(f);

    fprintf(t,"%c",(i<<4)+j);

#ifdef debug

    printf("Writed instruction:%s\n",cmd);

#endif

    }

else {

j=readreg(f);;

if (j==-1)return -5;//There was an error evaluating the parameter

if(version>2){

    if(j<0){

//#ifdef debug

    printf("Found label as parameter at line %d: turning the instruction to macro\n",line);

//#endif

    }

    torg++;

//Writing the coded instruction to the .text section

    if(j>=0){

        fprintf(t,"%c",(i<<4)+j);

#ifdef debug

    printf("Writed instruction:%s\n",cmd);

#endif

        }

    else{

        fprintf(t,"%c",i<<4);//TODO!!! The macros

#ifdef debug

    printf("Writed instruction:%s\n",cmd);

#endif

        }

}

else{

    if(j<0)

        return(-5);

    else

        fprintf(t,"%c",(i<<4)+j);

}

}

#ifdef debug

    printf("torg:%d,dorg:%d\n",torg,dorg);

#endif

    return(i);

};

//Egyszeres forditas:

//      a cimkek tablazatat a .data elejere kiirjuk, igy nem valtozik

//      a kod a cimkektol fuggoen

//      cimkere valo hivatkozaskor nem a cimke cimet olvassuk be, hanem

//      a .data elejenek cimehez adjuk hozza a cimke sorszamat, onnan

//      olvassuk be a cimke cimet->athelyezhetoek akar futas kozben is!!!

//      (feltetel: minden olvasas es iras elott be kell olvasni a cimet,

//      valamint/illetve csak kooperativ taszk eseten, mert preemptiv

//      eseten a betoltes utan is athelyezodhet a kod-vagy csak bizonyos

//      rendszerhivas eseten helyezodjon at)

//      ha nem athelyezheto, gyorsabb, mert kevesebb a konstans

//Jo lenne az elf formatum:

//      kovetelmeny a 32 bit

#undef debug

#define debug

int main(int arg,char **argv){

    FILE * f;

    FILE * d;//Data section,temporary

    FILE * t;//Text section,temporary

    FILE * o;//Output file

    int cer;

    int i;

    int m=0;//Is the __main defined?

    char chartmp;

    if(arg==1){

        htu(argv[0]);

        return(0);

    }

    if(arg>=2){//There's an input file

        if(!(f=fopen(argv[1],"ro"))){

            printf("Error opening the input file\n");

            return(-1);

        }

    }

    if(arg==3){//There's an output file

        if(!(o=fopen(argv[2],"w+"))){

            printf("Error opening the output file '%s\n'\n",argv[2]);

            return(-1);

        }

    }else

        if(!(o=fopen("out","w+"))){

            printf("Error opening the output file 'out'\n");

            return(-1);

        }

    d=tmpfile();//Temp file to store the informations about the .data section

    t=tmpfile();//Temp file to store the informations about the .text section

//Init de SP->do at init of the task

//newlabel("SP");

//datab=2;

//addlabel("SP");

    while(!feof(f)){

#ifdef debug

//      printf("readcmd\n");

#endif

        cer=readcmd(f,d,t);

        if(cer==-5){

            printf("Unknown instruction or register at line %d\n",line);

            fclose(d);

            fclose(t);

            fclose(f);

            fclose(o);

            return(-1);

        }

        if(cer==-2){

            printf("Wrong utilisation of directive at line %d\n",line);

            fclose(t);

            fclose(f);

            fclose(o);

            return(-1);

        }

    }

//Creating the output file

//Writing out the version of the used instruction set

        fprintf(o,"%c%c%c%c",(version & 0xFF),

                        (version>>8)& 0xFF,

                        (version>>16)& 0xFF,

                        (version>>24));//Little endian

//Address of the __main function, verifing the labels

for(i=0;iwhile

    if(strcmp(lab[i].name,"__main")==0){

#ifdef debug

        printf("__main found:%d::%d,%d\n",lab[i].address,(lab[i].address & 0xFF),lab[i].address>>8);

#endif

//Big or little endian?

//      fprintf(o,"%c%c",(lab[i].address & 0xFF),lab[i].address>>8);//Little

//      fprintf(o,"%c%c",lab[i].address>>8,(lab[i].address & 255));//Big

//      //Big or little endian?32 bit

        fprintf(o,"%c%c%c%c",(lab[i].address & 0xFF),

                        (lab[i].address>>8)& 0xFF,

                        (lab[i].address>>16)& 0xFF,

                        (lab[i].address>>24));//Little

////    fprintf(o,"%c%c%c%c",lab[i].address>>24,

//                      (lab[i].address>>16)& 0xFF,

//                      (lab[i].address>>8)& 0xFF,

//                      (lab[i].address & 255));//Big

        m=1;

        }

    if(lab[i].label_type==0){

        printf("Error:\nThe following label is not defined but used:%s\n"

            ,lab[i].name);

        fclose(d);

        fclose(t);

        fclose(f);

        fclose(o);

        remove("out");

        return(-1);

        }

#ifdef debug

    else{

        printf("Label:%s,position at %d\n",lab[i].name,lab[i].address);

        }

#endif

    }

if(m==0)//If there's no main function, we begin at the start of the code

//    fprintf(o,"%c%c",0,0);//16 bit address

    fprintf(o,"%c%c%c%c",0,0,0,0);//32 bit address

#ifdef debug

    printf("Length of the .stack section:%d\n",stackl);

#endif

//Writing the length of the stack section

        fprintf(o,"%c%c%c%c",(stackl & 0xFF),

                        (stackl>>8)& 0xFF,

                        (stackl>>16)& 0xFF,

                        (stackl>>24));//Little endian

//Writing the length of the next (.data) section

//That's equ:dorg+no of labels!

dorg+=maxlab;

#ifdef debug

    printf("Length of the .data section:%d\n",dorg);

#endif

        fprintf(o,"%c%c%c%c",(dorg & 0xFF),

                        (dorg>>8)& 0xFF,

                        (dorg>>16)& 0xFF,

                        (dorg>>24));//Little endian

//Writing out the labels

for(i=0;i

    if(lab[i].label_type==1)

        lab[i].address+=maxlab;

//    lab[i].address+=1;//+address of the stack at runtime->deleted, done at ini

        //Big or little endian?

//      fprintf(o,"%c%c",(lab[i].address & 0xFF),lab[i].address>>8);//Little

//      fprintf(o,"%c%c",lab[i].address>>8,(lab[i].address & 255));//Big

//      //Big or little endian?32 bit

        fprintf(o,"%c%c%c%c",(lab[i].address & 0xFF),

                        (lab[i].address>>8)& 0xFF,

                        (lab[i].address>>16)& 0xFF,

                        (lab[i].address>>24));//Little

        printf("%d:%d,%d,%d,%d;%d\n",i,(lab[i].address & 0xFF),

                        (lab[i].address>>8)& 0xFF,

                        (lab[i].address>>16)& 0xFF,

                        (lab[i].address>>24),lab[i].address);//Little

////    fprintf(o,"%c%c%c%c",lab[i].address>>24,

//                      (lab[i].address>>16)& 0xFF,

//                      (lab[i].address>>8)& 0xFF,

//                      (lab[i].address & 255));//Big

    }

rewind(d);//Writing the rest of the data section

while(!feof(d)){

    chartmp=fgetc(d);

    if(!feof(d))

        fputc(chartmp,o);

        }

#ifdef debug

    printf("Length of the .text section:%d\n",torg);

#endif

//Writing the length of the next (.text) section

        fprintf(o,"%c%c%c%c",(torg & 0xFF),

                        (torg>>8)& 0xFF,

                        (torg>>16)& 0xFF,

                        (torg>>24));//Little endian

        printf("%d,%d,%d,%d\n",(torg & 0xFF),

                        (torg>>8)& 0xFF,