?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. /*
  2.         CASM.C  --      Written by Leor Zolman, 2/82
  3.  
  4.         "C Assembly Language" preprocessor. Prepares .CSM-coded assembly
  5.         language source files for assembly using ASM.COM or MAC.COM.
  6.         See the CASM Appendix in the BDS C User's Guide for complete info.
  7.  
  8.         Modifications: 
  9.           Adapted for v1.6, 5/86, LZ
  10.           Adapted For v1.5, 11/14/82, LZ
  11.           Enable n-level nested INCLUDEs, Cliff Lasser & Leor Zolman, 1/85
  12.           Made to work with with CTOA CRL-to-ASM postprocessor, 11/83, K. Kenny
  13.  
  14.         Compile and link:
  15.  
  16.                 cc casm.c -o -e4b00
  17.  
  18.                 l2 casm
  19.         (or)    clink casm [-n]
  20. */
  21.  
  22. #include <stdio.h>
  23.  
  24. #define TITLE "BD Software CRL-format ASM Preprocessor v1.60\n"
  25.  
  26.  
  27. /*
  28.  *      Customizable definitions:
  29.  */
  30.  
  31. #define VIDEO  1                /* true for video terminal, false otherwise  */
  32. #define DEFUSER ""              /* default "include file" user area prefix   */
  33.                                 /* form: "nn/", or "" for currently logged   */
  34. #define DEFDISK ""              /* default disk for include files            */
  35.                                 /* form: "d:" , or "" for currently logged   */
  36. #define CASMEXT ".CSM"          /* extension on input files                  */
  37. #define ASMEXT  ".ASM"          /* extension on output files                 */
  38. #define SUBFILE "A:$$$.SUB"     /* Submit file to erase on error. To not     */
  39.                                 /* erase any, use a null string ("")         */
  40.  
  41. #define CONTROL_C 3             /* Abort character                           */
  42. #define EQUMAX  500             /* maximum number of EQU ops                 */
  43. #define FUNCMAX 100             /* maximum number of functions               */
  44. #define NFMAX   25              /* max no. of extern funcs in one function   */
  45. #define LABMAX  150             /* max number of local labels in one func    */
  46. #define TXTBUFSIZE 2000         /* max text for labels & extern func. names  */
  47. #define NESTMAX 3               /* max nesting of includes                   */
  48.  
  49. /*
  50.  *      End of customizable section
  51.  */
  52.  
  53. #define DIRSIZE 512             /* max # of byte in CRL directory       */
  54. #define TPALOC  0x100           /* base of TPA in your system           */
  55.  
  56.                 /* Global data used throughout processing
  57.                    of the input file:                                   */
  58.  
  59. FILE    *fptab[NESTMAX];        /* input file pointer table             */
  60. FILE    *cfp;                   /* currently active input file pointer  */
  61.  
  62. FILE    *ofp;                   /* FP for output file                   */
  63.  
  64. char    *cfname;                /* pointer to name of current input file */
  65. char    iname[NESTMAX][30];     /* filenames for current input files    */
  66. char    oname[30];              /* filename of output file              */
  67. int     nestlev;                /* nest level: 0 for top, max NESTMAX-1 */
  68. char    wrkbuf[30];
  69.  
  70. char    *equtab[EQUMAX];        /* table of absolute symbols            */
  71. int     equcount;               /* # of entries in equtab               */
  72.  
  73. char    *fnames[FUNCMAX];       /* list of functions in the source file */
  74. int     fcount;                 /* # of entries in fnames               */
  75.  
  76. int     lino,savlino[NESTMAX];  /* line number values used for error    */
  77.                                 /* reporting.                           */
  78.  
  79. char    doingfunc;              /* true if currently processing a function */
  80.  
  81. char    errf;                   /* true if an error has been detected      */
  82. char    verbose;                /* true to insert wordy comments in output */
  83. char    careful;                /* true to detect old CMAC.LIB macros      */
  84. char    blankflag;              /* true if last line processed was null    */
  85. char    debug;                  /* true if debugging option given          */
  86.  
  87.                 /* Global data used during the processing of a
  88.                    single function in the source file:                     */
  89.  
  90. char    *nflist[NFMAX];         /* list of needed functions for a function */
  91. int     nfcount;                /* number of entries in nflist             */
  92.  
  93. struct {
  94.         char *labnam;           /* name of function label                  */
  95.         char defined;           /* whether it has been defined yet         */
  96. } lablist[LABMAX];
  97.  
  98. int     labcount;               /* number of local labels in a function    */
  99.  
  100. char    txtbuf[TXTBUFSIZE],     /* where text of needed function names     */
  101.         *txtbufp;               /* and function labels go                  */
  102.  
  103. char    linbuf[MAXLINE],                /* text line buffers                */
  104.         linsav[MAXLINE],
  105.         workbuf[MAXLINE],
  106.         undrbuf[MAXLINE],
  107.         pbuf[MAXLINE], *pbufp;
  108.  
  109. char    *cfunam;                /* pointer to name of current function      */
  110. int     relblc;                 /* relocation object count for a function   */
  111.  
  112. char    pastnfs;                /* true if we've passed all needed function */
  113.                                 /* declarations ("external" pseudo ops)     */
  114.  
  115. int     argcnt;                 /* values set by the "parse_line" function  */
  116. char    *label,
  117.         *op,
  118.         *argsp,
  119.         *args[40];
  120.  
  121. char    *gpcptr;                /* general-purpose text pointer             */
  122.  
  123. /*
  124.  * Open main input file, open output file, initialize needed globals
  125.  * and process the file:
  126.  */
  127.  
  128. main(aarghc,aarghv)
  129. char **aarghv;
  130. {
  131.         int i,j,k;
  132.         char c, *inpnam, *outnam;
  133.  
  134.         puts(TITLE);
  135.  
  136.         initequ();              /* initialize EQU table with reserved words */
  137.         fcount = 0;             /* haven't seen any functions yet       */
  138.         doingfunc = FALSE;      /* not currently processing a function  */
  139.         errf = FALSE;           /* no errors yet */
  140.         verbose = careful = debug = FALSE;
  141.         inpnam = outnam = NULL;         /* haven't seen any names yet   */
  142.         blankflag = FALSE;      /* haven't just processed a null line   */
  143.         nestlev = 0;            /* at top level  to start with          */
  144.        
  145.         while (--aarghc)
  146.         {
  147.                 ++aarghv;               /* bump to next arg text        */
  148.                 if (**aarghv == '-')
  149.                 {
  150.                     switch(c = aarghv[0][1])
  151.                     {
  152.                         case 'F':
  153.                                 careful = 1;
  154.                                 break;
  155.  
  156.                         case 'C':
  157.                                 verbose = 1;
  158.                                 break;
  159.  
  160.                         case 'O':
  161.                                 if (aarghv[0][2])
  162.                                         outnam = &aarghv[0][2];
  163.                                 else if (--aarghc)
  164.                                         outnam = *++aarghv;
  165.                                 else goto usage;
  166.  
  167.                                 break;
  168.  
  169.                         case 'D':
  170.                                 debug = TRUE;
  171.                                 break;
  172.  
  173.                         default: goto usage;
  174.                     }
  175.                 }
  176.                 else
  177.                         inpnam = *aarghv;
  178.         }
  179.  
  180.         if (!inpnam) {
  181.   usage:        puts("Usage:\tcasm [-f] [-c] [-o <name>] <filename>\n");
  182.                 puts("-F: flag old CMAC.LIB macros if spotted\n");
  183.                 puts("-C: don't strip comments from input and output\n");
  184.                 puts("-O <name>: Call the output file <name>.ASM\n");
  185.                 exit();
  186.         }
  187.  
  188.                                 /* set up filenames with proper extensions: */
  189.         for (i = 0; (c = inpnam[i]) && c != '.'; i++)
  190.                 iname[0][i] = c;
  191.         iname[0][i] = '\0';
  192.  
  193.         strcpy(oname, outnam ? outnam : iname[0]);
  194.         strcat(iname[0],CASMEXT);       /* input filename               */
  195.         cfname = iname[0];              /* current filename pointer     */
  196.  
  197.        
  198.         if ((cfp = fopen(cfname, "r")) == NULL)
  199.                 exit(printf("Can't open %s\n",cfname));
  200.         fptab[0] = cfp;
  201.         if (debug)
  202.                 printf("cfp = %04x\n",cfp);
  203.        
  204.         if (!hasdot(oname))
  205.                 strcat(oname,ASMEXT);           /* output filename      */
  206.         if ((ofp = fopen(oname, "w")) == NULL)
  207.                 exit(printf("Can't create %s\n",oname));
  208.  
  209.                                         /* begin writing output file    */
  210.         fprintf2(ofp,"\nTPALOC\t\tEQU\t%04xH\n",TPALOC);
  211.  
  212.         fprintf2(ofp,"\nSYS$EXTFLAG\tSET\t0\n");
  213.         fprintf2(ofp,"SYS$EXTADDR\tSET\t0\n");
  214.         fprintf2(ofp,"SYS$EXTSIZE\tSET\t0\n");
  215.         fprintf2(ofp,"\t\tORG\tTPALOC+0205H\n\n");
  216.  
  217.         lino = 1;                       /* initialize line count        */
  218.  
  219.         while (get_line()) {            /* main loop                    */
  220.                 if (kbhit() && getchar() == CONTROL_C)
  221.                         abort("Aborted by ^C\n");
  222.                 process_line();         /* process lines till EOF       */
  223.                 lino++;
  224.         }
  225.  
  226.         if (doingfunc)                  /* if ends inside a function, error */
  227.                 abort("File ends, but last function is unterminated\n");
  228.  
  229.         if (errf)
  230.         {
  231.                 puts("Fix those errors and try again...");
  232.                 unlink(oname);
  233.                 if (*SUBFILE)
  234.                         unlink(SUBFILE);
  235.         }
  236.         else
  237.         {
  238.                                                         /* end of functions */
  239.                 fputs2("\nEND$CRL\t\tEQU\t$-TPALOC\n",ofp);
  240.                 putdir();                       /* now put out CRL directory */
  241.                 fputs2("\t\tEND\n",ofp);        /* end of ASM file      */
  242.                 fputc(CPMEOF,ofp);              /* CP/M EOF character   */
  243.                 fclose(cfp);                    /* close input file     */
  244.                 fclose(ofp);                    /* close output file    */
  245.                 printf("%s is ready to be assembled.\n",oname);
  246.         }
  247. }
  248.  
  249. /*
  250.  * Get a line of text from input stream, and process
  251.  * "include" ops on the fly:
  252.  */
  253.  
  254. int get_line()
  255. {
  256.         int i;
  257.  
  258. top:    if (!fgets2(linbuf, MAXLINE, cfp)) {    /* on EOF:              */
  259.                 if (nestlev) {                  /* in "include" file?   */
  260.                         fclose(cfp);            /* yes; return to previous; */
  261.                         cfp = fptab[--nestlev]; /* restore buffer ptr */
  262.                         cfname = iname[nestlev];        /* and filename */
  263.                         lino = savlino[nestlev] + 1;    /* and line no. */
  264.                         return get_line();
  265.                 }
  266.                 else return NULL;
  267.         }
  268.  
  269.         if (!verbose)                           /* strip commments, default */
  270.         {
  271.                 for (i = 0; linbuf[i]; i++)
  272.                 {
  273.                         if (linbuf[i] == ';')
  274.                         {
  275.                                 while (i && isspace(linbuf[i-1]))
  276.                                         i--;
  277.                                 if (!i && blankflag)
  278.                                 {
  279.                                         lino++;
  280.                                         goto top;
  281.                                 }
  282.                                 strcpy(&linbuf[i], "\n");
  283.                                 blankflag = TRUE;
  284.                                 break;
  285.                         }
  286.                         if (linbuf[i] == '\'' || linbuf[i] == '"')
  287.                                 break;
  288.                 }
  289.                 if (!linbuf[i])
  290.                         blankflag = FALSE;             
  291.         }
  292.  
  293.         parse_line();                           /* not EOF. Parse line       */
  294.         if (streq(op,"INCLUDE")  ||             /* check for file inclusion  */
  295.             streq(op,"MACLIB")) {
  296.                 if (nestlev == NESTMAX)      /* if nested to the max, error  */
  297.                         abort("Only %d inclusion level[s] allowed",NESTMAX);
  298.                 if (!argsp)
  299.                         abort("No filename specified");
  300.                                         /* set up for inclusion      */
  301.                 savlino[nestlev++] = lino;
  302.  
  303.                 for (i = 0; !isspace(argsp[i]); i++)    /* put null after    */
  304.                         ;                               /* filename          */
  305.                 argsp[i] = '\0';
  306.  
  307.                 *wrkbuf = '\0';
  308.  
  309.                 if (*argsp == '<') {            /* look for magic delimiters */
  310.                         strcpy(wrkbuf,DEFUSER);
  311.                         if (argsp[2] != ':')    /* if no explicit disk given */
  312.                                 strcat(wrkbuf,DEFDISK); /* then use default */
  313.                         strcat(wrkbuf,argsp+1);
  314.                         if (wrkbuf[i = strlen(wrkbuf) - 1] == '>')
  315.                                 wrkbuf[i] = '\0';
  316.                 } else if (*argsp == '"') {
  317.                         strcpy(wrkbuf,argsp+1);
  318.                         if (wrkbuf[i = strlen(wrkbuf) - 1] == '"')
  319.                                 wrkbuf[i] = '\0';
  320.                 } else
  321.                         strcpy(wrkbuf,argsp);
  322.  
  323.                 while ((cfp = fopen(wrkbuf, "r")) == NULL)
  324.                         if (hasdot(wrkbuf))
  325.                                 abort("Missing include file: %s\n", wrkbuf);
  326.                         else
  327.                                 strcat(wrkbuf, ".LIB");
  328.                                
  329.                 strcpy(&iname[nestlev], wrkbuf);
  330.                 cfname = iname[nestlev];
  331.                 fptab[nestlev] = cfp;
  332.                 lino = 1;
  333.                 return get_line();
  334.         }
  335.         return 1;
  336. }
  337.  
  338. parse_line()
  339. {
  340.         int i;
  341.         char c;
  342.  
  343.         label = op = argsp = NULL;
  344.         argcnt = 0;
  345.  
  346.         strcpy2(pbuf,linbuf);
  347.         strcpy2(linsav,linbuf);
  348.         pbufp = pbuf;
  349.  
  350.         if (!*pbufp) return;            /* ignore null lines            */
  351.         if (!isspace(c = *pbufp)) {
  352.                 if (c == ';')
  353.                         return;         /* totally ignore comment lines */
  354.                 label = pbufp;          /* set pointer to label         */
  355.                 while (isidchr(*pbufp)) /* pass over label identifier   */
  356.                         pbufp++;
  357.                 *pbufp++ = '\0';        /* place null after identifier  */
  358.         }
  359.  
  360.         skip_wsp(&pbufp);
  361.         if (!*pbufp || *pbufp == ';')
  362.                 return;
  363.         op = pbufp;                     /* set pointer to op mnemonic   */
  364.         while (isalpha(*pbufp))
  365.                 pbufp++;                /* skip over the op             */
  366.         if (*pbufp) *pbufp++ = '\0';    /* place null after the op      */
  367.  
  368.  
  369.                                         /* now process arguments        */
  370.         skip_wsp(&pbufp);
  371.         if (!*pbufp || *pbufp == ';')
  372.                 return;
  373.         argsp = linsav + (pbufp - pbuf); /* set pointer to arg list     */
  374.  
  375.                                 /* create vector of ptrs to all args
  376.                                    that are possibly relocatable        */
  377.         for (argcnt = 0; argcnt < 40;) {
  378.                 while (!isidstrt(c = *pbufp))
  379.                         if (!c || c == ';')
  380.                                 return;
  381.                         else
  382.                                 pbufp++;
  383.  
  384.                 if (isidchr(*(pbufp - 1))) {
  385.                         pbufp++;
  386.                         continue;
  387.                 }
  388.  
  389.                 args[argcnt++] = pbufp;                
  390.                 while (isidchr(*pbufp)) pbufp++;
  391.                 if (*pbufp) *pbufp++ = '\0';
  392.         }
  393.         error("Too many operands in this instruction for me to handle\n");
  394. }
  395.  
  396. process_line()
  397. {
  398.         char *cptr, c;
  399.         int i,j;
  400.  
  401.         if (op) {
  402.                         /* check for definitions of global data that will be
  403.                            exempt from relocation when encountered in the
  404.                            argument field of assembly instructions:        */
  405.  
  406.            if (streq(op,"EQU") || streq(op,"SET") ||
  407.                 (!doingfunc &&
  408.                         (streq(op,"DS") || streq(op,"DB") || streq(op,"DW"))))
  409.            {
  410.                 fputnam(ofp,linbuf);
  411.                 cptr = sbrk2(strlen(label) + 1);
  412.                 strcpy(cptr,label);
  413.                 equtab[equcount++] = cptr;
  414.                 if (equcount >= EQUMAX)
  415.                         abort(
  416.                   "Too many EQU lines...increase 'EQUMAX' and recompile CASM");
  417.                 return;
  418.            }
  419.  
  420.            if (streq(op,"EXTERNAL")) {
  421.                 if (!doingfunc) abort(
  422.                  "'External's for a function must appear inside the function");
  423.                 if (pastnfs) error(
  424.                  "Externals must all be together at start of function\n");
  425.                 for (i = 0; i < argcnt; i++) {
  426.                         nflist[nfcount++] = txtbufp;
  427.                         strcpy(txtbufp,args[i]);
  428.                         bumptxtp(args[i]);
  429.                 }
  430.                 if (nfcount >= NFMAX) {
  431.                   printf("Too many external functions in function \"%s\"\n",
  432.                                         cfunam);
  433.                   abort("Change the NFMAX constant and recompile CASM");
  434.                 }
  435.                 return;
  436.            }
  437.  
  438.            if (streq(op,"FUNCTION")) {
  439.  
  440.                 if (doingfunc) {
  441.                         printf("'Function' op encountered in a function.\n");
  442.                         abort("Did you forget an 'endfunc' op?");
  443.                 }
  444.                 if (!argcnt)
  445.                         abort("A name is required for the 'function' op");
  446.  
  447.                 cfunam = sbrk2(strlen(args[0]) + 1);
  448.                 fnames[fcount++] = cfunam;
  449.                 strcpy(cfunam,args[0]);
  450. #if VIDEO              
  451.                 if (debug) putchar('\n');
  452.                 printf("Processing the %s function...          \r",cfunam);
  453.                 if (debug) putchar('\n');
  454. #endif
  455.                 doingfunc = 1;
  456.                 txtbufp = txtbuf;
  457.                 labcount = 0;
  458.                 nfcount = 0;
  459.                 pastnfs = 0;
  460.  
  461.                 if (verbose)
  462.                         fprintf2(ofp,"\n\n; The \"%s\" function:\n",cfunam);
  463.  
  464.                 fputnam(ofp, cfunam);
  465.                 fputs2("$BEG\tEQU\t$-TPALOC\n", ofp);
  466.                 return;
  467.            }
  468.  
  469.            if (streq(op,"ENDFUNC") || streq(op,"ENDFUNCTION")) {
  470.                 if (!doingfunc)
  471.                   abort("'Endfunc' op encountered while not in a function");
  472.  
  473.                 if (!pastnfs) flushnfs();    /* flush needed function list */
  474.                 fputnam (ofp, cfunam);
  475.                 fputs2("$END\tEQU\t$\n", ofp);
  476.                 doreloc();                   /* flush relocation parameters */
  477.  
  478.                 for (i = 0; i < labcount; i++)  /* detect undefined labels */
  479.                   if (!lablist[i].defined) {
  480.                         printf("The label %s in function %s is undefined\n",
  481.                                         lablist[i].labnam,cfunam);
  482.                         errf = 1;
  483.                   }
  484.                 doingfunc = 0;
  485.                 return;
  486.            }
  487.         }
  488.  
  489.         if (careful)
  490.           if (streq(op,"RELOC") || streq(op,"DWREL") || streq(op,"DIRECT") ||
  491.             streq(op,"ENDDIR") || streq(op,"EXREL") || streq(op,"EXDWREL") ||
  492.             streq(op,"PRELUDE") || streq(op,"POSTLUDE") || streq(op,"DEFINE"))
  493.                 error("Old macro '%s' leftover from \"CMAC.LIB\" days...\n",
  494.                                                         op);
  495.  
  496.                                 /* Don't scan conditional pseudo op lines */
  497.         if (streq(op,"IF") || streq(op,"ENDIF"))
  498.                 return fputnam(ofp,linbuf);
  499.  
  500.                                 /* No special pseudo ops, so now process
  501.                                    the line as a line of assemby code:  */
  502.  
  503.         if (streq(op,"END")) return;            /* don't allow "end" yet     */
  504.  
  505.         if (!doingfunc || (!label && !op))      /* if nothing interesting on */
  506.                 return fputnam(ofp,linbuf);     /* line, ignore it      */
  507.         if (!pastnfs)                           /* if haven't flushed needed */
  508.                 flushnfs();                     /* function list yet, do it  */
  509.  
  510.                                                 /* check for possible label  */
  511.         if (label) {
  512.                 sprintf (undrbuf, "%s$L$%s\tEQU\t$-%s$STRT\n",
  513.                                 cfunam, label, cfunam);
  514.                 fputnam (ofp,undrbuf);
  515.                 for (i=0; linbuf[i]; i++)
  516.                         if (isspace(linbuf[i]) || linbuf[i] == ':')
  517.                                 break;
  518.                         else
  519.                                 linbuf[i] = ' ';
  520.                 if (linbuf[i] == ':') linbuf[i] = ' ';
  521.                 for (i = 0; i < labcount; i++)    /* check if in label table */
  522.                   if (streq(label,lablist[i].labnam)) {         /* if found, */
  523.                         if (lablist[i].defined) {  /* check for redefinition */
  524.                                 error("Re-defined label:");
  525.                                 printf("%s, in function %s\n",
  526.                                                 lablist[i].labnam,cfunam);
  527.                         }
  528.                          else
  529.                                 lablist[i].defined = 1;
  530.                         goto out;
  531.                   }
  532.                 lablist[i].labnam = txtbufp;    /* add new entry to */
  533.                 lablist[i].defined = 1;         /* label list       */
  534.                 strcpy(txtbufp,label);
  535.                 bumptxtp(label);
  536.                 if (labcount++ >= LABMAX)
  537.                         error("Label table overflow. Increase LABMAX");
  538.         }
  539. out:
  540.         if (!op) return fputnam (ofp, linbuf);  /* if label only, all done   */
  541.  
  542.                                                 /* if a non-relocatable op,  */
  543.         if (norelop(op)) return fputnam(ofp,linbuf);    /* then we're done   */
  544.  
  545.         if (argcnt && doingfunc)
  546.           for (i = 0; i < argcnt; i++) {
  547.                 if (gpcptr = isef(args[i]))
  548.                    sprintf(workbuf,"%s$EF$%s-%s$STRT",
  549.                                 cfunam,gpcptr,cfunam);
  550.                 else if (norel(args[i])) continue;
  551.                 else {
  552.                         sprintf(workbuf,"%s$L$%s",cfunam,args[i]);
  553.                         for (j = 0; j < labcount; j++)
  554.                                 if (streq(args[i],lablist[j].labnam))
  555.                                         goto out2;
  556.                         lablist[j].labnam = txtbufp;    /* add new entry to */
  557.                         lablist[j].defined = 0;         /* label list       */
  558.                         strcpy(txtbufp,args[i]);
  559.                         bumptxtp(txtbufp);
  560.                         labcount++;
  561.                 }                  
  562.  
  563.         out2:
  564.                 replstr(linbuf, workbuf, args[i] - pbuf, strlen(args[i]));
  565.  
  566.                 if (streq(op,"DW")) {
  567.                         sprintf (undrbuf, "%s$R%03d\tEQU\t$-%s$STRT\n",
  568.                                 cfunam, relblc++, cfunam);
  569.                         fputnam (ofp, undrbuf);
  570.                         if (argcnt > 1)
  571.                           error("Only one relocatable value allowed per DW\n");
  572.                 }
  573.                 else {
  574.                         sprintf (undrbuf,"%s$R%03d\tEQU\t$+1-%s$STRT\n",
  575.                                 cfunam, relblc++, cfunam);
  576.                         fputnam (ofp, undrbuf);
  577.                         }
  578.                 break;
  579.           }
  580.         fputnam (ofp, linbuf);
  581. }
  582.  
  583.  
  584. /*
  585.         Test for ops in which there is guanranteed to be no need
  586.         for generation of relocation parameters. Note that the list
  587.         of non-relocatable ops doesn't necessarily have to be complete,
  588.         because for any op that doesn't match, an argument must still
  589.         pass other tests before it is deemed relocatable. This only
  590.         speeds things up by telling the program not to bother checking
  591.         the arguments.
  592. */
  593.  
  594. norelop(op)
  595. char *op;
  596. {
  597.         if (streq(op,"MOV")) return 1;
  598.         if (streq(op,"INR")) return 1;
  599.         if (streq(op,"DCR")) return 1;
  600.         if (streq(op,"INX")) return 1;
  601.         if (streq(op,"DCX")) return 1;
  602.         if (streq(op,"DAD")) return 1;
  603.         if (streq(op,"MVI")) return 1;
  604.         if (streq(op,"DB")) return 1;
  605.         if (streq(op,"DS")) return 1;
  606.         if (op[2] == 'I') {
  607.                 if (streq(op,"CPI")) return 1;
  608.                 if (streq(op,"ORI")) return 1;
  609.                 if (streq(op,"ANI")) return 1;
  610.                 if (streq(op,"ADI")) return 1;
  611.                 if (streq(op,"SUI")) return 1;
  612.                 if (streq(op,"SBI")) return 1;
  613.                 if (streq(op,"XRI")) return 1;
  614.                 if (streq(op,"ACI")) return 1;
  615.         }
  616.         if (streq(op,"ORG")) return 1;
  617.         if (streq(op,"TITLE")) return 1;
  618.         if (streq(op,"PAGE")) return 1;
  619.         if (streq(op,"EJECT")) return 1;
  620.         if (streq(op,"MACRO")) return 1;
  621.         return 0;
  622. }
  623.  
  624.  
  625. flushnfs()
  626. {
  627.         int i,j, length;
  628.  
  629.         pastnfs = 1;
  630.         relblc = 0;
  631.  
  632.         if (verbose)
  633.                 fputs2("\n\n; List of needed functions:\n",ofp);
  634.  
  635.         for (i=0; i < nfcount; i++) {
  636.                 strcpy(workbuf,"\t\tDB\t'");
  637.                 length = strlen(nflist[i]);
  638.                 length = length < 8 ? length : 8;
  639.                 for (j = 0; j < length - 1; j++)
  640.                         workbuf[6+j] = nflist[i][j];
  641.                 workbuf[6+j] = '\0';
  642.                 fprintf2(ofp,"%s','%c'+80H\n",workbuf,nflist[i][j]);
  643.         }
  644.  
  645.         fputs2("\t\tDB\t0\n",ofp);
  646.  
  647.         if (verbose)
  648.                 fputs2("\n; Length of body:\n",ofp);
  649.  
  650.         sprintf(undrbuf,"\t\tDW\t%s$END-$-2\n",cfunam);
  651.         fputnam (ofp, undrbuf);
  652.  
  653.         if (verbose)
  654.                 fputs2("\n; Body:\n",ofp);
  655.  
  656.         sprintf(undrbuf,"%s$STRT\tEQU\t$\n",cfunam);
  657.         fputnam (ofp, undrbuf);
  658.         if (nfcount) {
  659.                 sprintf(undrbuf,"%s$R%03d\tEQU\t$+1-%s$STRT\n",
  660.                         cfunam,relblc++,cfunam);
  661.                 fputnam (ofp, undrbuf);
  662.                 sprintf(undrbuf,"\t\tJMP\t%s$STRTC-%s$STRT\n",cfunam,cfunam);
  663.                 fputnam (ofp, undrbuf);
  664.         }
  665.         sprintf(undrbuf,"%s$EF$%s\tEQU\t%s$STRT\n",cfunam,cfunam,cfunam);
  666.         fputnam (ofp, undrbuf);
  667.         for (i=0; i < nfcount; i++) {
  668.                 sprintf(undrbuf,"%s$EF$%s\tJMP\t0\n",cfunam,nflist[i]);
  669.                 fputnam (ofp, undrbuf);
  670.                 }
  671.         sprintf(undrbuf,"\n%s$STRTC\tEQU\t$\n",cfunam);
  672.         fputnam (ofp, undrbuf);
  673. }
  674.  
  675.  
  676. doreloc()
  677. {
  678.         int i;
  679.  
  680.         if(verbose)
  681.                 fputs2("\n; Relocation parameters:\n",ofp);
  682.  
  683.         fprintf2(ofp,"\t\tDW\t%d\n",relblc);
  684.         for(i = 0; i < relblc; i++)
  685.                 fprintf2(ofp,"\t\tDW\t%s$R%03d\n",cfunam,i);
  686.         fputs2("\n",ofp);
  687. }
  688.  
  689. putdir()
  690. {
  691.         int i,j, length;
  692.         int bytecount;
  693.  
  694.         bytecount = 0;
  695.  
  696.         fputs2("\n\t\tORG\tTPALOC\n\n; Directory:\n",ofp);
  697.         for (i = 0; i < fcount; i++) {
  698.                 strcpy(workbuf,"\t\tDB\t'");
  699.                 length = strlen(fnames[i]);
  700.                 length = length < 8 ? length : 8;
  701.                 for (j = 0; j < length - 1; j++)
  702.                         workbuf[6+j] = fnames[i][j];
  703.                 workbuf[6+j] = '\0';
  704.                 fprintf2(ofp,"%s','%c'+80H\n",workbuf,fnames[i][j]);
  705.                 sprintf(undrbuf,"\t\tDW\t%s$BEG\n",fnames[i]);
  706.                 fputnam (ofp, undrbuf);
  707.                 bytecount += (length + 2);
  708.         }
  709.         fputs2("\t\tDB\t80H\n\t\tDW\tEND$CRL\n",ofp);
  710.  
  711.         bytecount += 3;
  712.         if (bytecount > DIRSIZE) {
  713.                 printf("CRL Directory size will exceed 512 bytes;\n");
  714.                 printf("Break the file up into smaller chunks, please!\n");
  715.                 exit(-1);
  716.         }
  717.  
  718.         fputs2("\n\n; External information:\n", ofp);
  719.         fputs2("\t\tORG\tTPALOC+0200H\n", ofp);
  720.         fputs2("\t\tIF\tSYS$EXTFLAG\n", ofp);
  721.         fputs2("\t\tDB\t0BDH\n", ofp);
  722.         fputs2("\t\tDW\tSYS$EXTADDR\n", ofp);
  723.         fputs2("\t\tENDIF\n", ofp);
  724.         fputs2("\t\tIF\tNOT SYS$EXTFLAG\n", ofp);
  725.         fputs2("\t\tDB\t0, 0, 0\n", ofp);
  726.         fputs2("\t\tENDIF\n", ofp);
  727.         fputs2("\t\tDW\tSYS$EXTSIZE\n", ofp);
  728.  
  729. }
  730.  
  731.  
  732. initequ()
  733. {
  734.         equtab[0] = "A";
  735.         equtab[1] = "B";
  736.         equtab[2] = "C";
  737.         equtab[3] = "D";
  738.         equtab[4] = "E";
  739.         equtab[5] = "H";
  740.         equtab[6] = "L";
  741.         equtab[7] = "M";
  742.         equtab[8] = "SP";
  743.         equtab[9] = "PSW";
  744.         equtab[10]= "AND";
  745.         equtab[11]= "OR";
  746.         equtab[12]= "MOD";
  747.         equtab[13]= "NOT";
  748.         equtab[14]= "XOR";
  749.         equtab[15]= "SHL";
  750.         equtab[16]= "SHR";
  751.         equcount = 14;
  752. }
  753.  
  754.  
  755. int isidchr(c)  /* return true if c is legal character in identifier */
  756. char c;
  757. {      
  758.         return isalpha(c) || c == '$' || isdigit(c) || c == '.' || c == '_';
  759. }
  760.  
  761.  
  762. int isidstrt(c) /* return true if c is legal as first char of idenfitier */
  763. char c;
  764. {
  765.         return isalpha(c) || c == '_';
  766. }
  767.  
  768.  
  769. int streq(s1, s2)       /* return true if the two strings are equal */
  770. char *s1, *s2;
  771. {
  772.         if (*s1 != *s2) return 0;       /* special case for speed */
  773.         while (*s1) if (*s1++ != *s2++) return 0;
  774.         return (*s2) ? 0 : 1;
  775. }
  776.  
  777.  
  778. skip_wsp(strptr)        /* skip white space at *strptr and modify the ptr */
  779. char **strptr;
  780. {
  781.         while (isspace(**strptr)) (*strptr)++;
  782. }
  783.  
  784.  
  785. strcpy2(s1,s2)  /* copy s2 to s1, converting to upper case as we go */
  786. char *s1, *s2;
  787. {
  788.         while (*s2)
  789.              *s1++ = toupper(*s2++);
  790.         *s1 = '\0';
  791. }
  792.  
  793.  
  794. /*
  795.         General-purpose string-replacement function:
  796.                 'string'        is pointer to entire string,
  797.                 'insstr'        is pointer to string to be inserted,
  798.                 'pos'           is the position in 'string' where 'insstr'
  799.                                 is to be inserted
  800.                 'lenold'        is the length of the substring in 'string'
  801.                                 that is being replaced.
  802. */
  803.  
  804. replstr(string, insstr, pos, lenold)
  805. char *string, *insstr;
  806. {
  807.         int length, i, j, k, x;
  808.  
  809.         length = strlen(string);
  810.         x = strlen(insstr);
  811.         k = x - lenold;
  812.         i = string + pos + lenold;
  813.         if (k) movmem(i, i+k, length - (pos + lenold) + 1);
  814.         for (i = 0, j = pos; i < x; i++, j++)
  815.                 string[j] = insstr[i];
  816. }
  817.  
  818. /*      Function to put text to the output file, replacing underscores with
  819.         cues to keep ASM happy.   */
  820.  
  821. fputnam (file, str)
  822.     FILE *file;
  823.     char *str;
  824.     {
  825.         char c;
  826.         char quoted;
  827.         quoted = FALSE;
  828.         while (c = *str++) {
  829.                 if (c == '\'') quoted ^= 1;
  830.                 else if (c == '\n') putc2 ('\r', file);
  831.                 if (c == '_' && !quoted) putc2 ('Q', file);
  832.                 else putc2 (c, file);
  833.                 }
  834.         }
  835.  
  836. putc2(c,file)
  837. FILE *file;
  838. {
  839.         if (debug)
  840.                 putchar(c);
  841.         else
  842.                 fputc(c, file);
  843. }
  844.  
  845.  
  846. error(msg,arg1,arg2)
  847. char *msg;
  848. {
  849.         printf("\n\7%s: %d: ",cfname,lino);
  850.         printf(msg,arg1,arg2);
  851.         errf = 1;
  852. }
  853.  
  854.  
  855. abort(msg,arg1,arg2)
  856. char *msg;
  857. {
  858.         int i;
  859.  
  860.         error(msg,arg1,arg2);
  861.         putchar('\n');
  862.         for (i = nestlev; i >= 0; i--)
  863.                 fclose(fptab[i]);
  864.         if (*SUBFILE)
  865.                 unlink(SUBFILE);
  866.         exit(-1);
  867. }
  868.  
  869.  
  870. sbrk2(n)        /* allocate storage and check for out of space condition */
  871. {
  872.         int i;
  873.         if ((i = sbrk(n)) == ERROR)
  874.                 abort("Out of storage allocation space\n");
  875.         return i;
  876. }
  877.  
  878. bumptxtp(str)   /* bump txtbufp by size of given string + 1 */
  879. char *str;
  880. {
  881.         txtbufp += strlen(str) + 1;
  882.         if (txtbufp >= txtbuf + (TXTBUFSIZE - 8))
  883.          abort("Out of text space. Increase TXTBUFSIZE and recompile CASM");
  884. }
  885.  
  886.  
  887. int norel(id)   /* return true if identifier is exempt from relocatetion */
  888. char *id;
  889. {
  890.         if (isequ(id)) return 1;
  891.         return 0;
  892. }
  893.  
  894.  
  895. int isequ(str)  /* return true if given string is in the EQU table */
  896. char *str;
  897. {
  898.         int i;
  899.         for (i = 0; i < equcount; i++)
  900.                 if (streq(str,equtab[i]))
  901.                         return 1;
  902.         return 0;
  903. }
  904.  
  905.  
  906. char *isef(str) /* return nflist entry if given string is an external */
  907. char *str;      /* function name */
  908. {
  909.         int i;
  910.         for (i = 0; i < nfcount; i++)
  911.                 if (streq(str,nflist[i]))
  912.                         return nflist[i];
  913.         return 0;
  914. }
  915.  
  916. int hasdot(str) /* return true if given string has a dot in it */
  917. char *str;
  918. {
  919.         while (*str)
  920.                 if (*str++ == '.')
  921.                         return TRUE;
  922.         return FALSE;
  923. }
  924.  
  925. fgets2(arg1, arg2, arg3)
  926. {
  927.         int i;
  928.         i = fgets(arg1, arg2, arg3);
  929.         if (debug)
  930.                 printf("\n fgets got --> %s\n",arg1);
  931.         return i;
  932. }
  933.  
  934.  
  935.  
  936. fputs2(arg1,arg2)
  937. {
  938.         if (debug)
  939.                 puts(arg1);
  940.         else
  941.                 if (fputs(arg1,arg2) == ERROR)
  942.                         abort("Out of disk space for output file.");
  943. }
  944.  
  945. fprintf2(arg1,arg2,arg3,arg4,arg5)
  946. {
  947.         if (debug)
  948.                 printf(arg2, arg3, arg4, arg5);
  949.         else
  950.                 if (fprintf(arg1,arg2,arg3,arg4,arg5) == ERROR)
  951.                         abort("Out of disk space for output file.");
  952. }
  953.