/*
*      Z80 - Assembler
*      Copyright (C) 1987-1992 by Udo Munk
*
*      History:
*      17-SEP-1987 Development under Digital Research CP/M 2.2
*      28-JUN-1988 Switched to Unix System V.3
*/

#include <stdio.h>
#include <ctype.h>
#include "z80a.h"
#include "z80aglb.h"

static char *errmsg[] = {               /* Fehlermeldungen fuer fatal() */
       "out of memory: %s",            /* 0 */
       "usage: z80asm -ofile -f[b|m|h] -l[file] -s[n|a] -v -dsymbol ... file ...",
       "Assembly halted",              /* 2 */
       "can't open file %s",           /* 3 */
       "internal error: %s"            /* 4 */
};

main(argc, argv)
int argc;
char *argv[];
{
       int len;

       init();
       options(argc, argv);
       printf("Z80 - Assembler Release %s, %s\n", REL, COPYR);
       pass1();
       pass2();
       if (list_flag) {
               switch (sym_flag) {
               case 0:         /* keine Symboltabelle */
                       break;
               case 1:         /* unsortierte Symboltabelle */
                       lst_sym();
                       break;
               case 2:         /* nach Namen sortierte Symboltabelle */
                       len = copy_sym();
                       n_sort_sym(len);
                       lst_sort_sym(len);
                       break;
               case 3:         /* nach Adressen sortierte Symboltabelle */
                       len = copy_sym();
                       a_sort_sym(len);
                       lst_sort_sym(len);
                       break;
               default:
                       break;
               }
               fclose(lstfp);
       }
       return(errors);
}

/*
*      Initialisierung
*/
init()
{
       errfp = stdout;
}

/*
*      Diese Funktion bearbeitet die beim Aufruf angegebenen Options.
*      Die uebergebenen Dateinamen werden in die entsprechenden
*      Strings uebernommen.
*/
options(argc, argv)
int argc;
char *argv[];
{
       register char *s, *t;
       register int i;
       char *malloc();

       while (--argc > 0 && (*++argv)[0] == '-')
               for (s = argv[0]+1; *s != '\0'; s++)
                       switch (*s) {
                       case 'o':
                       case 'O':
                               if (*++s == '\0') {
                                       puts("name missing in option -o");
                                       usage();
                               }
                               get_fn(objfn, s, OBJEXT);
                               s += (strlen(s) - 1);
                               break;
                       case 'l':
                       case 'L':
                               if (*(s + 1) != '\0') {
                                       get_fn(lstfn, ++s, LSTEXT);
                                       s += (strlen(s) - 1);
                               }
                               list_flag = 1;
                               break;
                       case 's':
                       case 'S':
                               if (*(s + 1) == '\0')
                                       sym_flag = 1;
                               else if ((*(s + 1) == 'n') || (*(s + 1) == 'N'))
                                       sym_flag = 2;
                               else if ((*(s + 1) == 'a') || (*(s + 1) == 'A'))
                                       sym_flag = 3;
                               else {
                                       printf("unknown option -%s\n", s);
                                       usage();
                               }
                               s += (strlen(s) - 1);
                               break;
                       case 'f':
                       case 'F':
                               if ((*(s + 1) == 'b') || (*(s + 1) == 'B'))
                                       out_form = OUTBIN;
                               else if ((*(s + 1) == 'm') || (*(s + 1) == 'M'))
                                       out_form = OUTMOS;
                               else if ((*(s + 1) == 'h') || (*(s + 1) == 'H'))
                                       out_form = OUTHEX;
                               else {
                                       printf("unknown option -%s\n", s);
                                       usage();
                               }
                               s += (strlen(s) - 1);
                               break;
                       case 'd':
                       case 'D':
                               if (*++s == '\0') {
                                       puts("name missing in option -d");
                                       usage();
                               }
                               t = tmp;
                               while (*s)
                                       *t++ = islower(*s) ? toupper(*s++) : *s++;
                               s--;
                               *t = '\0';
                               if (put_sym(tmp, 0))
                                       fatal(F_OUTMEM, "symbols");
                               break;
                       case 'v':
                       case 'V':
                               ver_flag = 1;
                               break;
                       default :
                               printf("unknown option %c\n", *s);
                               usage();
                       }
       i = 0;
       while ((argc--) && (i < MAXFN)) {
               if ((infiles[i] = malloc(LENFN + 1)) == NULL)
                       fatal(F_OUTMEM, "filenames");
               get_fn(infiles[i], *argv++, SRCEXT);
               i++;
       }
       if (i == 0) {
               printf("no input file given\n");
               usage();
       }
}

/*
*      An den Argumenten in der Befehlszeile ist was falsch,
*      Gebrauchsanleitung ausgeben und abbrechen.
*/
usage()
{
       fatal(F_USAGE, NULL);
}

/*
*      Fehlermeldung ausgeben und abbrechen
*/
fatal(i, arg)
register int i;
register char *arg;
{
       void exit();

       printf(errmsg[i], arg);
       putchar('\n');
       exit(1);
}

/*
*      Pass 1:
*        - Lauf ueber alle Quelldateien
*/
pass1()
{
       register int fi;

       pass = 1;
       pc = 0;
       fi = 0;
       if (!ver_flag)
               puts("Pass 1");
       open_o_files(infiles[fi]);
       while (infiles[fi] != NULL) {
               if (!ver_flag)
                       printf("   Read    %s\n", infiles[fi]);
               p1_file(infiles[fi]);
               fi++;
       }
       if (errors) {
               fclose(objfp);
               unlink(objfn);
               printf("%d error(s)\n", errors);
               fatal(F_HALT, NULL);
       }
}

/*
*      Pass 1:
*        - Lauf ueber eine Quelldatei
*
*      Input:  Name der zu bearbeitenden Quelldatei
*/
p1_file(fn)
char *fn;
{
       c_line = 0;
       srcfn = fn;
       if ((srcfp = fopen(fn, READA)) == NULL)
               fatal(F_FOPEN, fn);
       while (p1_line())
               ;
       fclose(srcfp);
       if (iflevel)
               asmerr(E_MISEIF);
}

/*
*      Pass 1:
*        - Eine Zeile Quelle verarbeiten
*
*      Output: 1 Zeile verarbeitet
*              0 EOF erreicht
*/
p1_line()
{
       register char *p;
       register int i;
       register struct opc *op;
       char *get_label(), *get_opcode(), *get_arg();
       struct opc *search_op();

       if ((p = fgets(line, MAXLINE, srcfp)) == NULL)
               return(0);
       c_line++;
       p = get_label(label, p);
       p = get_opcode(opcode, p);
       p = get_arg(operand, p);
       if (strcmp(opcode, ENDFILE) == 0)
               return(0);
       if (*opcode) {
               if ((op = search_op(opcode)) != NULL) {
                       i = (*op->op_fun)(op->op_c1, op->op_c2);
                       if (gencode)
                               pc += i;
               } else
                       asmerr(E_ILLOPC);
       } else
               if (*label)
                       put_label();
       return(1);
}

/*
*      Pass 2:
*        - Lauf ueber alle Quelldateien
*/
pass2()
{
       register int fi;

       pass = 2;
       pc = 0;
       fi = 0;
       if (!ver_flag)
               puts("Pass 2");
       obj_header();
       while (infiles[fi] != NULL) {
               if (!ver_flag)
                       printf("   Read    %s\n", infiles[fi]);
               p2_file(infiles[fi]);
               fi++;
       }
       obj_end();
       fclose(objfp);
       printf("%d error(s)\n", errors);
}

/*
*      Pass 2:
*        - Lauf ueber eine Quelldatei
*
*      Input:  Name der zu bearbeitenden Quelldatei
*/
p2_file(fn)
char *fn;
{
       c_line = 0;
       srcfn = fn;
       if ((srcfp = fopen(fn, READA)) == NULL)
               fatal(F_FOPEN, fn);
       while (p2_line())
               ;
       fclose(srcfp);
}

/*
*      Pass 2:
*        - Eine Zeile Quelle verarbeiten
*
*      Output: 1 Zeile verarbeitet
*              0 EOF erreicht
*/
p2_line()
{
       register char *p;
       register int op_count;
       register struct opc *op;
       char *get_label(), *get_opcode(), *get_arg();
       struct opc *search_op();

       if ((p = fgets(line, MAXLINE, srcfp)) == NULL)
               return(0);
       c_line++;
       s_line++;
       p = get_label(label, p);
       p = get_opcode(opcode, p);
       p = get_arg(operand, p);
       if (strcmp(opcode, ENDFILE) == 0) {
               lst_line(pc, 0);
               return(0);
       }
       if (*opcode) {
               op = search_op(opcode);
               op_count = (*op->op_fun)(op->op_c1, op->op_c2);
               if (gencode) {
                       lst_line(pc, op_count);
                       obj_writeb(op_count);
                       pc += op_count;
               } else {
                       sd_flag = 2;
                       lst_line(0, 0);
               }
       } else {
               sd_flag = 2;
               lst_line(0, 0);
       }
       return(1);
}

/*
*      Oeffnen der Ausgabedateien: Objectdatei und bei Option
*      -l der Listdatei. Der Dateiname der Quelldatei wird
*      uebergeben. Die Dateinamen der Object- und Listdatei
*      werden, wenn nicht hinter den Optionen -l und -o angegeben,
*      aus dem Quelldateinamen erzeugt.
*/
open_o_files(source)
register char *source;
{
       char *strcpy(), *strcat(), *strrchr();
       register char *p;

       if (*objfn == '\0')
               strcpy(objfn, source);
       if ((p = strrchr(objfn, '.')) != NULL)
               strcpy(p, OBJEXT);
       else
               strcat(objfn, OBJEXT);

       if (out_form == OUTHEX)
               objfp = fopen(objfn, WRITEA);
       else
               objfp = fopen(objfn, WRITEB);
       if (objfp == NULL)
               fatal(F_FOPEN, objfn);
       if (list_flag) {
               if (*lstfn == '\0')
                       strcpy(lstfn, source);
               if ((p = strrchr(lstfn, '.')) != NULL)
                       strcpy(p, LSTEXT);
               else
                       strcat(lstfn, LSTEXT);
               if ((lstfp = fopen(lstfn, WRITEA)) == NULL)
                       fatal(F_FOPEN, lstfn);
               errfp = lstfp;
       }
}

/*
*      Einen Dateinamen in "dest" aus "src" und "ext" zusammenbauen
*/
get_fn(dest, src, ext)
char *dest, *src, *ext;
{
       char *strrchr(), *strcat();
       register int i;
       register char *sp, *dp;

       i = 0;
       sp = src;
       dp = dest;
       while ((i++ < LENFN) && (*sp != '\0'))
               *dp++ = *sp++;
       *dp = '\0';
       if ((strrchr(dest,'.') == NULL) && (strlen(dest) <= (LENFN-strlen(ext))))
               strcat(dest, ext);
}

/*
*      Extrahieren der Labels, Konstanten und Variablen aus
*      einer Zeile Quelltext mit Umwandlung in Grosschrift
*      und Begrenzung der Laenge.
*/
char *get_label(s, l)
register char *s, *l;
{
       register int i;

       i = 0;
       if (*l == LINCOM)
               goto comment;
       while (!isspace(*l) && *l != COMMENT && *l != LABSEP && i < SYMSIZE) {
               *s++ = islower(*l) ? toupper(*l++) : *l++;
               i++;
       }
comment:
       *s = '\0';
       return(l);
}

/*
*      Extrahieren des Op-Codes aus einer Zeile Quelltext ab der
*      uebergebenen Position. Der String wird bei der Uebertragung
*      in Grosschrift umgewandelt.
*/
char *get_opcode(s, l)
register char *s, *l;
{
       if (*l == LINCOM)
               goto comment;
       while (!isspace(*l) && *l != COMMENT && *l != LABSEP)
               l++;
       if (*l == LABSEP)
               l++;
       while (*l == ' ' || *l == '\t')
               l++;
       while (!isspace(*l) && *l != COMMENT)
               *s++ = islower(*l) ? toupper(*l++) : *l++;
comment:
       *s = '\0';
       return(l);
}

/*
*      Extrahieren des Operanden aus einer Zeile Quelltext ab der
*      uebergebenen Position. Der String wird bei der Uebertragung
*      in Grosschrift umgewandelt und Blanks sowie Tabs werden
*      ueberlesen. Strings, die in ' eingeschlossen sind, werden
*      ohne Aenderung kopiert.
*/
char *get_arg(s, l)
register char *s, *l;
{
       if (*l == LINCOM)
               goto comment;
       while (*l == ' ' || *l == '\t')
               l++;
       while (*l != '\n' && *l != COMMENT) {
               if (isspace(*l)) {
                       l++;
                       continue;
               }
               if (*l != STRSEP) {
                       *s++ = islower(*l) ? toupper(*l) : *l;
                       l++;
                       continue;
               }
               *s++ = *l++;
               if (*(s - 2) == 'F')    /* EX AF,AF' !!!!! */
                       continue;
               while (*l != STRSEP) {
                       if (*l == '\n' || *l == '\0' || *l == COMMENT)
                               goto comment;
                       *s++ = *l++;
               }
               *s++ = *l++;
       }
comment:
       *s = '\0';
       return(l);
}

You are viewing proxied material from gopher.floodgap.com. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.