home *** CD-ROM | disk | FTP | other *** search
/ APDL Public Domain 1 / APDL_PD1A.iso / program / assembler / tasm / c / EXPAND < prev    next >
Encoding:
Text File  |  1992-09-03  |  27.7 KB  |  1,225 lines
  1. /*
  2.         Macro Front-End.  EXPAND.C
  3.         R.J.P.  12/7/92
  4.         Front end for XASM
  5.         14th July 1992          Port to ARC.
  6.         17th July 1992          Change Macro listing.
  7.         17th July 1992          add Time stamp.
  8.         23rd July 1992          Fix another Macro search bug
  9.         15th August 1992        Losing Comments in +C
  10.          3rd September 1992     Fix Numerical Evaluation radix recognition.
  11. */
  12. /* Conditional(  */
  13. /*
  14.         Switches:
  15.           
  16.           /I:input_file         normal Path on both PC & Arc.
  17.           /O:output_file        "         "       "
  18.           
  19.           ** note #INCLUDE directives in source must be of the
  20.           form   DIR/DIR/../DIR/file.ext for PC 
  21.           and    DIR/DIR/../ext/file.ext for the Arc. I use the same
  22.           convention for assembler as that of the 'C' compiler, and the
  23.           Arc version of EXPAND just changes al the '/' to '.' & removes
  24.           the final .ext ....
  25.           
  26.           -C  Chop out all comments.
  27.           +M  Put in Expanded #MACRO definitions
  28.           +U  Generate Time,Date & Source file #DEFINES
  29.           /W: Generate copyright define
  30.           
  31.           #SYMBOL   [<expr>]    Generate a Symbol with a long value known to 
  32.           EXPAND  - EXPAND does not care about #DEFINE #IF etc...
  33.           Expressions allowed for #SYMBOL are more or less the same as 
  34.           in TASM, but the syntax analyser is 'normal'. All expressions
  35.           and constants are held as 'long' (32 bit integer).
  36.           
  37.           ?IF , ?ELSE , ?ENDIF operate for #SYMBOLS as #IF does for
  38.           #DEFINES...
  39.           
  40.           
  41. */
  42.            
  43. #include   <stdio.h>
  44. #include   <stdlib.h>
  45. #include   <stdarg.h>
  46. #include   <string.h>
  47. #include   <ctype.h>
  48. #include   <time.h>
  49. #include   <setjmp.h>
  50.  
  51. #undef          TRUE
  52. #undef          FALSE
  53. #undef          BOOL
  54.  
  55. #define         BOOL    unsigned char
  56. #define         TRUE    1
  57. #define         FALSE   0
  58.  
  59. #define         WS_SIZE         4096
  60.  
  61. typedef  struct {
  62.         char *fn ;
  63.         FILE *fh ;
  64.         void *pt ;
  65.         int  sln ;
  66.       } IFL ;
  67.  
  68. typedef  struct {
  69.                 char    *txt ;
  70.                 unsigned char pn ;
  71.                 void    *nx ;
  72.                 } MacSeg ;
  73.  
  74. typedef   struct {
  75.                 char   *txt ;
  76.                 void   *nx ;
  77.                 } ParamRec ;
  78.  
  79. typedef    struct {
  80.                 char   *txt ;
  81.                 long   sv ;
  82.                 void   *nx ;
  83.                 } SREC ;
  84.                 
  85. typedef  struct {
  86.         int  N;
  87.         char     *mn ;
  88.         MacSeg   *mp ;
  89.         void     *nx ;
  90.          } MLST ;
  91.  
  92. typedef   struct {
  93.         BOOL     on ;
  94.         void     *nx ;
  95.         } CONDLST ; 
  96.        
  97. IFL     *IL = 0 ;       /* In File List. */
  98. char    LB[133] ;       /* Input Char. buffer */
  99. char    CB[133] ;       /* Appended comment buffer */
  100. char    *LP ;           /* Pointer to input buffer */
  101.  
  102. MLST    *ML ;           /* List of Macro Definitions */
  103. char    *W ;            /* Pointer to macro build work-space */
  104.  
  105. SREC    *SL ;           /* Pointer to Symbol List */
  106. CONDLST *EL ;           /* Pointer to switches */
  107.  
  108. BOOL    B_Mlist     = FALSE ;       /* Listing Macros */
  109. BOOL    B_Commlist  = TRUE ;    /* Listing Comments */
  110. BOOL    B_ListOn    = TRUE ;
  111. BOOL    B_Stamp     = FALSE ;
  112.  
  113. char    F_src[65] ;             /* Primary Source file */
  114. char    F_asm[65] ;             /* Output file */
  115. char    T_copyw[25];
  116. FILE    *ALST ;                 /* Output Stream */
  117.  
  118. unsigned int Umem , UmemMax ;
  119. int     Nmacs,Smacs , Nsymbs ,Ssymbs ;
  120. jmp_buf          EvalErr ;
  121.  
  122.  
  123. /*
  124.         Forward Refs.
  125. */
  126.  
  127.  
  128. static   char  *nextc ;
  129. static   long  iexp( int ) ;
  130. static   void  Kill(void) ;
  131. static   char *NextString(void) ;
  132.  
  133.         
  134. static  SREC *SymbolSearch( char *txb , char **la )
  135. {
  136.    int     sl,sx ;
  137.    char    *cp,*Tcp ;
  138.    SREC    *S,*ST ;
  139.  
  140.    if (!SL)  return 0 ;
  141.       
  142.     for( sl = 0 , ST = 0 , S = SL; S ; S = S->nx )
  143.     {
  144.     if ( (cp = strstr( txb,S->txt) ),cp!=0 )
  145.     {
  146.       sx = strlen(S->txt) ;
  147.       if (
  148.            ( 
  149.              (!isalnum(*(cp-1)) && (*(cp-1)!='_') )
  150.              || (cp == txb)         /* Or is first line entry */
  151.            )
  152.        &&   ( !isalnum(*(cp+sx)) && (*(cp+sx)!='_') ) 
  153.        && ( sl < sx )            /* And is longer then Match */
  154.          )
  155.       {sl = sx ; ST = S ; Tcp = cp ; /* Record Symbol Hit */ }
  156.      }
  157.     }
  158. *la = Tcp ;   
  159. return ST ;
  160. } 
  161.  
  162.         
  163. static  SREC *SymbolMatch( char *txb )
  164. {
  165.    SREC    *S;
  166.    char  *cp ;
  167.  
  168.    if (!SL)  return 0 ;
  169.       
  170.    for( S = SL; S ; S = S->nx )
  171.    {
  172.      if ( !strncmp( txb,S->txt,strlen(S->txt) ) )
  173.      {
  174.        cp = txb+strlen(S->txt) ;
  175.         if ( !isalnum(*cp) && (*cp != '_') )   return S ;      
  176.      }
  177.    }  
  178. return 0 ;
  179. } 
  180.   
  181. static long ibexp(void)
  182. {
  183.   long val;
  184.   char  *cp ;
  185.   SREC  *S ;
  186.   int   ir;
  187.   
  188.   while ( isspace(*nextc)) ++nextc ;
  189.   
  190.   switch(*nextc)
  191.   { 
  192.     case '(': *nextc++=' '; val=iexp(0);
  193.       if(  *nextc!=')' ) longjmp(EvalErr,2);
  194.       *nextc++ = ' ' ;    break;
  195.   
  196.     case '+': *nextc++=' '; val=iexp(0);            break;
  197.     
  198.     case '-': *nextc++=' '; val=-iexp(0);           break;
  199.  
  200.     case '%': ir = 2 ; goto L_DECODE;
  201.  
  202.     case '$': ir = 16 ; goto L_DECODE ;
  203.      
  204.     case '@': ir = 8 ;
  205. L_DECODE:
  206.     *nextc++=' '; cp = nextc ; val = strtol(nextc,&nextc,ir) ;
  207.     while( cp != nextc ) *cp++ = ' ' ; break ;
  208.       
  209.     default: 
  210.     if(isdigit(*nextc))
  211.     {
  212.         cp = nextc ;        
  213.         val=strtol(cp,&nextc,10);
  214.         switch (toupper(*nextc))
  215.         {
  216. case 'H' : val = strtol( cp , &nextc , 16) ; break ;
  217. case 'O' : val = strtol( cp , &nextc , 8 ) ; break ;
  218. case 'B' : val = strtol( cp , &nextc , 2 ) ; break ;
  219. default:  break ;
  220.         }      
  221.          while( cp != nextc ) *cp++ = ' ' ;
  222.     }
  223.     else if ( (S = SymbolMatch(nextc)), S!=0 )
  224.     {
  225.        nextc += strlen(S->txt) ;
  226.        val    = S->sv ;
  227.     }               
  228.     else longjmp(EvalErr , 1 );
  229.   }
  230.   return val;
  231. }
  232.  
  233. static long iexp(int n)
  234. {
  235.   long a=ibexp();
  236.   
  237.   for(;;) switch(*nextc)
  238.   { 
  239.     case '+':  if(n>=1) return a;  *nextc++=' ';  a+=iexp(1);  break;
  240.     case '-':  if(n>=1) return a;  *nextc++=' ';  a-=iexp(1);  break;
  241.     case '*':  if(n>=2) return a;  *nextc++=' ';  a*=iexp(2);  break;
  242.     case '/':  if(n>=2) return a;  *nextc++=' ';  a/=iexp(2);  break;
  243.  
  244.     case '&':  if(n>=2) return a;  *nextc++=' ';  a&=iexp(2);  break;
  245.     case '|':  if(n>=2) return a;  *nextc++=' ';  a|=iexp(2);  break;
  246.     case '^':  if(n>=2) return a;  *nextc++=' ';  a^=iexp(2);  break;
  247.     case '>':  if(n>=2) return a;  
  248.                *nextc++=' ' ;
  249.                if( *nextc != '>' )
  250.                              longjmp(EvalErr,3);
  251.                *nextc++=' ';  a>>=iexp(2) ;  break ;
  252.                
  253.     case '<':  if(n>=2) return a;  
  254.                *nextc++=' ' ;
  255.                if( *nextc != '<' )
  256.                              longjmp(EvalErr,3);
  257.                *nextc++=' ';  a<<=iexp(2) ;  break ;
  258.  
  259.     case '\t' : case ' ':  nextc++; break;
  260.     default :return a;
  261.   }
  262. }
  263.  
  264. #ifdef  _ARC_
  265.  
  266. static int strnicmp (const char *sx,const char *tx,int n)
  267. {        
  268.        int   i ;
  269.               
  270.        for( ; n ; n--,sx++,tx++ )
  271.        {
  272.             i = toupper(*sx) - toupper(*tx) ;
  273.             if ( i ) return i ; 
  274.        }
  275. return 0 ;         
  276. }
  277.  
  278. static  char *PathEdit (char *Ipath)
  279. { 
  280.    char *cp ;
  281.    
  282. /*
  283.         Look for PC-type path name.
  284.         - The first path will be an Arc path to the 
  285.         main source-file, but the rest may be PC-style paths
  286.         from the Assembler source #includes.....
  287. */
  288.    if ( !strpbrk(Ipath,"\\/") ) return Ipath ;
  289.    
  290.    cp = strchr(Ipath,'.') ;     /* look for extension */
  291.    if ( cp ) *cp = 0 ;          /* kill it */
  292.    
  293.  
  294.    for(;;)
  295.    {
  296.      cp = strchr(Ipath,'/') ;   /*Path ?*/
  297.      if (!cp)
  298.      {  
  299.         cp = strchr(Ipath,'\\') ;  /*Path? */
  300.         if (!cp)    break ;        /* nothing.. Leave */
  301.      }
  302.      *cp = '.' ;                /* convert */
  303.    }    
  304. return  Ipath ;  
  305. }
  306.  
  307. #endif
  308.  
  309. static int  zstrlen( const char *tx)
  310. {
  311.   return strlen(tx)+2 ;
  312. }
  313.  
  314.   
  315. static  void *Umalloc( unsigned int msz )
  316. {
  317.       char *mg = malloc( msz ) ;
  318.       if (!mg)
  319.       {
  320.         fprintf(stderr,"* Insufficient Memory\n") ;
  321.         Kill() ;
  322.         exit(9) ;
  323.        }
  324. Umem += msz ;               
  325. if (Umem > UmemMax) UmemMax = Umem ;
  326. return (void *) mg ;
  327. }
  328.  
  329. static  void  Ufree( void **mpt , unsigned int msz )
  330. {
  331.      if (*mpt)
  332.      {
  333.      *mpt = 0 ;
  334.      Umem -= msz ;
  335.      free( *mpt ) ;
  336.      }
  337. }
  338.  
  339.  
  340.  
  341. char  *Ustrupr( char *s,int l)
  342. {
  343.  
  344.   char  *ss  =  s ;
  345.   while( *s && l-- )
  346.   *s++ = toupper( *s) ;
  347.   return ss ;
  348. }
  349.  
  350. char   *scan( int ac , char **av , char *tag )
  351. {
  352.   int   sl   =  strlen(tag) ;
  353.   while ( --ac )
  354.   {
  355.     if( !strncmp(tag,Ustrupr(*++av,sl),sl) )
  356.     {
  357.       if (!strlen(*av + sl) )
  358.                 return 0 ;
  359.       else
  360.                 return *av + sl  ;
  361.      }
  362.   }
  363.   return  0  ;
  364. }
  365.  
  366.  
  367. BOOL   scan_sw( int ac , char **av , char *tag )
  368. {
  369.   short   sl   =  strlen(tag) ;
  370.   while ( --ac )
  371.   {
  372.     if( !strncmp(tag,Ustrupr(*++av,sl),sl) )
  373.     {
  374.       if (!strlen(*av + sl) )
  375.                 return TRUE ;
  376.     }
  377.   }
  378.   return  FALSE  ;
  379. }
  380.  
  381.  
  382. static   BOOL  cmdline( int ac,char **av ) 
  383. {
  384.         BOOL  B_in = FALSE ;
  385.         char    *cp ;
  386.         FILE   *TF ;
  387.         
  388.         ALST  = stdout ;
  389.         
  390.         if( (cp = scan(ac,av,"/I:")),cp!=0 )
  391.         {
  392.                 strncpy(F_src,cp,64) ;
  393. #ifdef  _ARC_
  394.                 TF = fopen(PathEdit(F_src),"r") ;
  395. #else                                
  396.                 TF = fopen(F_src,"r") ;
  397. #endif
  398.                 fclose(TF) ;
  399.                 if( !TF )
  400.                 {
  401.                 fprintf(stderr,"/I: %s - Won't Open\n",F_src) ;
  402.                 return TRUE ;
  403.                 }
  404.                 B_in = TRUE ;
  405.         }       
  406.         
  407.         if( (cp = scan(ac,av,"/O:")),cp!=0 )
  408.         {
  409.                 strncpy(F_asm,cp,64) ;
  410. #ifdef  _ARC_
  411.                 ALST = fopen(PathEdit(F_asm),"w") ;
  412. #else                                
  413.                 ALST = fopen(F_asm,"w") ;
  414. #endif
  415.                 if( !ALST )
  416.                 {
  417.                 fprintf(stderr,"/O: %s - Won't Open\n",F_asm) ;
  418.                 return TRUE ;
  419.                 }
  420.         }       
  421.         
  422.         if (scan_sw(ac,av,"-C"))  B_Commlist = FALSE ;
  423.         if (scan_sw(ac,av,"+M"))  B_Mlist = TRUE ;
  424.         if (scan_sw(ac,av,"+U"))  B_Stamp = TRUE ;
  425.  
  426.         if( (cp = scan(ac,av,"/W:")),cp!=0 )
  427.                        strncpy(T_copyw,cp,24) ;  
  428. return  !B_in ;
  429. }
  430.  
  431.  
  432. static void OpError( char *fmt,...)
  433. {
  434.   va_list   argptr;
  435.   
  436.   va_start( argptr, fmt );
  437.  
  438.   fprintf(stderr,"\n%-20s  [%4d] :",IL->fn,IL->sln ) ;
  439.   vfprintf(stderr, fmt, argptr );
  440.   va_end( argptr );
  441. }
  442.  
  443. static void Kill( void)
  444. {
  445.         IFL  *ol ;
  446.         MLST  *M ;
  447.         MacSeg *P ;
  448.         MacSeg *Q ;
  449.         SREC  *S ;
  450.         CONDLST *K ;
  451.  
  452.         while ( IL )
  453.         {
  454.            fclose( IL->fh ) ;
  455.            Ufree( (void **)(&(*IL).fn) , zstrlen( IL->fn ) ) ;
  456.            ol = IL->pt ;
  457.            Ufree( (void **)&IL , sizeof(IFL) ) ;
  458.            IL = ol ;
  459.        }
  460.  
  461.         while ( SL )
  462.         {          
  463.            Ufree( (void **)(&(*SL).txt) , zstrlen( SL->txt ) ) ;
  464.            S = SL->nx ;
  465.            Ufree( (void **)&SL , sizeof(SREC) ) ;
  466.            SL = S ;
  467.         }
  468.  
  469.         while ( EL )
  470.         {          
  471.            K = EL->nx ;
  472.            Ufree( (void **)&EL , sizeof(CONDLST) ) ;
  473.            EL = K ;
  474.         }
  475.  
  476.         while( ML )
  477.         {
  478.           Ufree( (void **)(&(*ML).mn),zstrlen(ML->mn) ) ;
  479.           if( ML->mp)
  480.           {
  481.            P = ML->mp ;
  482.            while( P )
  483.            {
  484.              Ufree( (void **)(&(*P).txt),zstrlen(P->txt) ) ;
  485.              Q = P ;
  486.              P = P->nx ;
  487.              Ufree( (void **)&Q,sizeof(MacSeg) ) ;
  488.           }
  489.          }
  490.          M = ML ;
  491.          ML = ML->nx ;
  492.          Ufree((void **)&M,sizeof(MLST) ) ;
  493.       }
  494.         if (W) Ufree((void **)&W,WS_SIZE) ;
  495.  
  496.         fclose(ALST) ;        
  497. }
  498.  
  499. static int  NewOpen( char *tx)
  500. {
  501. /*
  502.         Used to open a new file, preserve the present file
  503.         and set to read from the new one.
  504. */
  505.         IFL *ol ;
  506.         FILE *tf ;
  507. #ifdef  _ARC_
  508.         if ( (tf = fopen(PathEdit(tx),"r")),tf==0)
  509. #else
  510.         if ( (tf = fopen(tx,"r")),tf==0)
  511. #endif
  512.         {OpError("*Can't open [%s%]\n",tx) ; return 1 ; }
  513.  
  514.         if (!IL)
  515.                ol = 0 ;
  516.         else
  517.                ol = IL ;
  518.  
  519.          IL = (IFL *)Umalloc(sizeof(IFL)) ;
  520.          IL->pt = ol ;
  521.          IL->fn = (char *)Umalloc( zstrlen(tx) ) ;
  522.          strcpy(IL->fn,tx) ;
  523.          IL->fh = tf ;
  524.          IL->sln = 0 ;
  525.  
  526.        return 0 ;
  527. }
  528.  
  529. static int NewClose(void)
  530. {
  531. /*
  532.         Closes the present file , and opens the previous one .
  533. */
  534.  
  535.         IFL  *ol ;
  536.  
  537.         if ( !IL ) return 2 ;
  538.         fclose( IL->fh ) ;
  539.         Ufree( (void **)(&(*IL).fn) ,zstrlen( IL->fn ) ) ;
  540.  
  541.         ol = IL->pt ;
  542.         Ufree( (void **)&IL , sizeof(IFL) ) ;
  543.  
  544.         if ( !ol )  return 1 ;
  545.         IL = ol ;
  546. return 0 ;
  547. }
  548.  
  549.  
  550. static char*  Strim( char *line )
  551. {
  552.     char *cp ;
  553.  
  554.     cp = line+strlen(line)-1 ;
  555.     for(;;) 
  556.     {
  557.     if ( !isspace(*cp) ) break ;
  558.     if( cp == line )
  559.     {  *cp = 0 ; break ;  }
  560.     else
  561.          *cp-- = 0 ;
  562.    }
  563. return line ;
  564. }
  565.  
  566.  
  567.  
  568. static int LoseWhite(void)
  569. {
  570.          while (*LP && isspace(*LP)) LP++ ;
  571.         if ( (*LP == ';') || !(*LP) )  return 1 ;
  572. return 0 ;
  573.  
  574. }
  575.  
  576. char  *RelSymbols [] = {
  577.         "!=","==",">=","<=",">","<",""
  578.                         } ;
  579.                         
  580. static int   Conditional( char *ltxt )
  581. {
  582.     CONDLST  *oc , *M ;
  583.     char     *cp;
  584.     char     **cq ;
  585.     long     cv,exv ;
  586.     int      Irel,i ;
  587.     
  588.     if (!strnicmp(ltxt,"?endif",6) )
  589.     {
  590.       if (!EL ) 
  591.       { OpError("*Extra ?endif\n%s\n",ltxt) ; Kill() ; exit(5) ; }
  592.       oc = EL->nx ;
  593.       Ufree( (void **)&EL , sizeof(CONDLST) ) ;
  594.       EL = oc ;
  595.       return  1 ;
  596.      }    
  597.  
  598.     if (!strnicmp(ltxt,"?else",5) )
  599.     {
  600.       if (!EL ) 
  601.       { OpError("*Extra ?else\n%s\n",ltxt) ; Kill() ; exit(5) ; }
  602.       EL->on  = !EL->on  ;
  603.      return  2 ;
  604.     }
  605.     
  606.     if (strnicmp(ltxt,"?if",3) )  return 0 ;
  607. /*
  608.         Hit an IF .... Evaluate the Expression.
  609.         for the momement, we are only interested in ==0 or != 0
  610. */
  611.         LP += 3 ;
  612.         strcat(LP,"     ");
  613.         cp = NextString() ;
  614.         if (!cp)
  615.         { OpError("* ?if with no expression.\n%s\n",LP) ;Kill() ;exit(5); }
  616.         nextc = cp ;
  617.         cv = iexp(0);
  618. /*
  619.         cv now holds the value of the first expression..
  620.         now, we look to see if there is a relational symbol
  621. */
  622.         Irel  =  0 ;
  623.         
  624.         cp = NextString() ;       
  625.         if( cp )
  626.         {/*1*/
  627. /*
  628.         Searching for relational symbol..
  629. */
  630.         for(i=1,cq=RelSymbols;**cq;i++,cq++)
  631.           if(!strncmp(cp,*cq,strlen(*cq)) )
  632.           { Irel = i ;  break ; }
  633.             
  634.         if (!Irel)
  635.         {
  636.           OpError("*Bad Relational Symbol [%s]\n%s\n",cp,LB) ;
  637.           Kill() ; exit(6) ;
  638.         }
  639. /*
  640.         There was a relational symbol, so there must be a further
  641.         parameter.
  642. */
  643.         cp = NextString() ;
  644.         if (!cp)
  645.         {
  646.           OpError("* ?if with no comparative value.\n%s\n",LP) ;
  647.           Kill() ; exit(6) ;
  648.         }
  649.         nextc = cp ;
  650.         exv = iexp(0);
  651.         }/*1*/
  652.                 
  653.         if (!EL)
  654.                          M = 0 ;
  655.         else
  656.                          M = EL  ;
  657.                          
  658.         EL = (CONDLST *)Umalloc(sizeof(CONDLST)) ;
  659.         EL->nx = M ;
  660.  
  661.         switch( Irel )
  662.         {        
  663. case 0:        EL->on = (cv != 0 )    ; break ;
  664. case 1:        EL->on = (cv != exv )  ; break ;
  665. case 2:        EL->on = (cv == exv )  ; break ;
  666. case 3:        EL->on = (cv >= exv)   ; break ;
  667. case 4:        EL->on = (cv <= exv)   ; break ;
  668. case 5:        EL->on = (cv >  exv)   ; break ;
  669. case 6:        EL->on = (cv <  exv)   ; break ;                
  670. default:        OpError("*Bug! in Relational Switch [%d]\n%s\n",Irel,LB) ;
  671.                 Kill() ; exit(6) ;
  672.         }        
  673. return  3 ;  
  674. }
  675.  
  676. static int  NewLine(void)
  677. {
  678. /*
  679.         Fetches the next line.
  680.         Handles any instances of #include.
  681. */
  682.     char  *csp,*cep ;
  683.  
  684.     LP = LB ;
  685.     for(;;)
  686.     {
  687.     fgets(LB,132,IL->fh) ;
  688.  
  689.     if ( feof(IL->fh) )
  690.     {
  691.       if ( NewClose() ) return 1 ;
  692.       return NewLine() ;
  693.     }
  694. /*
  695.         Process the conditional Directives, and set up
  696.         a record to say if lines are to be processed..
  697. */
  698.     if ( Conditional(LB) ) continue ;
  699.     if ( EL && !EL->on )   continue ;
  700.     break  ;
  701.     }
  702. /*
  703.         Looking for #include in col. 1 of new line.
  704. */
  705.     if (!strnicmp( LB , "#include" ,8) )
  706.     {
  707.       if ( (csp = strchr(LB,'"')),csp != 0 )
  708.       {
  709.        if ( (cep = strchr(csp+1,'"')),cep != 0 )
  710.        {
  711.          *cep = 0 ;
  712.         if ( NewOpen( csp+1 ) ) return 2  ;
  713.         return NewLine() ;
  714.        }
  715.       }
  716.       OpError("*Syntax:\n%s\n",LB) ;
  717.       return 3 ;
  718.     }
  719. /*
  720.         Chop off comments.
  721.         *Note this is a bit unsophisticated...
  722.         it will react to " ...  ;     "  for example..
  723. */       
  724.         *CB = 0  ;
  725.  
  726.         csp = LB ;
  727.         if ( (csp = strchr( LB , ';' )),csp != 0 )
  728.         {
  729.         if( B_Commlist )
  730.         {
  731.          if( csp != LB)
  732.               strcpy(CB,"\t"); /* Tab it if not @ start of line*/
  733.                    
  734.          strcat(CB,Strim(csp)) ; 
  735.          }
  736.         *csp = 0 ; /*  Truncate */
  737.         strcat(LB,"\n") ; 
  738.         }
  739.         ++IL->sln ;   /* count source lines */
  740.  
  741.         Strim(LB) ;
  742. /*
  743.         Check for some Directives.
  744. */
  745.         if( (csp = strchr(LB,'.') ) , csp == 0 ) return 0 ;
  746.         if ( !strnicmp(++csp,"LIST",4) ) B_ListOn = TRUE ;
  747.         else if ( !strnicmp(csp,"NOLIST",6)) B_ListOn = FALSE ;
  748. return 0 ;
  749. }
  750.  
  751.  
  752. static  char *NextString( void )
  753. {
  754.    char *csp ;
  755.  
  756.    if (LoseWhite() ) return (char *)0 ;
  757.    for (csp = LP;*LP;LP++)
  758.    {
  759.     if (
  760.         (*LP==',') || ( (*LP != '_') && ( isspace(*LP) ) )
  761.        )
  762.        {
  763.        *LP = 0 ;
  764.          ++LP ;
  765.        return csp ;
  766.        }
  767.    }
  768. return csp ;
  769. }
  770.  
  771.  
  772.  
  773. static void LoseTempParams( ParamRec *B)
  774. {
  775.   ParamRec *P ;
  776.  
  777.   if ( B )
  778.   {
  779.   while( B )
  780.   {
  781.         Ufree( (void **)(&(*B).txt) , zstrlen(B->txt ) ) ;
  782.         P = B->nx ;
  783.         Ufree( (void **)&B,sizeof(ParamRec) ) ;
  784.         B = P ;
  785.   }
  786.  }
  787. }
  788.  
  789. static int WhichParameter(ParamRec *B)
  790. {
  791. /*
  792.         looks for parameter in LB
  793.         if found , returns number &erases parameter.
  794. */
  795.   int   i;
  796.  
  797.   if ( !B )   return 0 ;
  798.   for ( i=1 ; B ; i++,B=B->nx )
  799.   {
  800.       if( *LP == *B->txt)
  801.                    if (!strncmp(LP,B->txt,strlen(B->txt) ) )
  802.            {
  803.                 LP += strlen(B->txt) ;
  804.                 return i ;
  805.            }
  806.   }
  807. return 0 ;
  808. }
  809.  
  810.  
  811.  
  812. static  int CkSymbolDef( void )
  813. {
  814.         SREC     *M ;
  815.         char     *cp,*cq ;
  816. /*
  817.         Looking for #SYMBOL definition start.
  818. */
  819.         for(;;)
  820.         {/*1*/
  821.         if (strnicmp(LP,"#symbol",7) ) return 0  ;
  822. /*
  823.         Found symbol key-word. check duplicate.
  824. */
  825.         ++Nsymbs ;
  826.         
  827.         LP += 7 ;
  828.         strcat(LP,"   ") ;
  829.         cp = NextString() ;
  830.  
  831.         if ( !cp )
  832.         {OpError("#SYMBOL - no name.\n") ; Kill() ;exit(1) ; }
  833.  
  834.         if ( ( M = SymbolSearch( cp , &cq) ),M !=0  )
  835.         {/*2*/
  836.  
  837. #if  0
  838. /*
  839.         We are  not Allowed to re-use Symbols...
  840. */   
  841.         { OpError("#SYMBOL - Duplicate. %s\n",M->txt); Kill() ;exit(1) ; }
  842. #endif
  843.  
  844.         }/*2*/
  845.         else
  846.         {/*2*/
  847.         if (!SL)
  848.                         M = 0 ;
  849.         else
  850.                         M = SL ;
  851.  
  852.         SL = (SREC *)Umalloc(sizeof(SREC) ) ;
  853.         SL->nx  =  M ;
  854.         SL->txt = (char *)Umalloc(zstrlen(cp)) ;
  855.         strcpy(SL->txt,cp) ;
  856. /*
  857.         now look up the Value.
  858. */
  859.         M = SL ;
  860.         }/*2*/
  861.         nextc   =  NextString() ;
  862.         M->sv  =  iexp(0) ;
  863.         if( B_Mlist) 
  864.           fprintf(ALST,";\t[%s] = %lxH (%ld)\n",M->txt,M->sv,M->sv ) ;
  865.         if ( NewLine() ) break ;
  866.      }/*1*/
  867. return  0 ;
  868. }
  869.  
  870.  
  871. static  void  CkMacroDef( void )
  872. {
  873.         MLST     *M ;
  874.         ParamRec *B = 0,*P,*Q  ;
  875.         MacSeg   *R,*S ;
  876.         char     *cp ;
  877.         char     *wp  ;
  878.         int      i ;
  879. /*
  880.         Looking for #MACRO definition start.
  881. */
  882.         for(;;)
  883.         {/*1*/
  884.           
  885.         if (strnicmp(LP,"#macro",6) ) return  ;
  886. /*
  887.         Found macro key-word. check duplicate.
  888. */
  889.         ++Nmacs ;
  890.         
  891.         LP += 6 ;
  892.         cp = NextString() ;
  893.  
  894.         if ( !cp )
  895.         { OpError("#MACRO - no name.\n") ; Kill() ; exit(1) ; }
  896.  
  897.         if (ML)
  898.         {/*2*/
  899.            M = ML ;
  900.            while( M )
  901.            {/*3*/
  902.            if ( !strncmp(M->mn,cp,strlen(cp)) )
  903.             {/*4*/
  904.                 OpError("#MACRO - Duplicate %s\n%s\n",cp,LB) ;
  905.                 Kill() ;  exit(2) ;
  906.             }/*4*/
  907.                 M = M->nx  ;
  908.            }/*3*/
  909.         }/*2*/
  910.  
  911. /*
  912.         Ok.. not a duplicate.  create a new macro record.
  913. */
  914.         *W = 0 ;
  915.         wp = W ;
  916.         if (!ML)
  917.                         M = 0 ;
  918.         else
  919.            M = ML ;
  920.  
  921.            ML = (MLST *)Umalloc(sizeof (MLST)) ;
  922.            ML->nx  =  M ;
  923.            ML->mn  =  (char *)Umalloc(zstrlen(cp) ) ;
  924.            strcpy(ML->mn,cp) ;
  925.            ML->mp  = R = 0 ;
  926.            ML->N = 0 ;
  927. /*
  928.         now look up the parameters.
  929. */
  930.         cp = NextString() ;
  931.  
  932.         while ( cp )
  933.         {/*2*/
  934.         ++ML->N ;
  935.         Q = (ParamRec *)Umalloc(sizeof(ParamRec)) ;
  936.         if (!B)
  937.                         B = P = Q ;
  938.         else
  939.                         P->nx = Q ;
  940.  
  941.         Q->nx  = 0 ;
  942.         Q->txt = (char *)Umalloc( zstrlen(cp) ) ;
  943.         strcpy (Q->txt,cp) ;
  944.         P = Q ;
  945.         cp = NextString() ;
  946.         }/*2*/
  947.  
  948.         while ( !NewLine() )
  949.         {/*2*/
  950.         if ( !*LB  ) continue ;
  951.         strcat(LB,"\n") ; 
  952. /*
  953.         reading Macro definition.
  954. */
  955.         if (!strnicmp( LB , "#mend" ,5) )
  956.         {/*3*/
  957. /*
  958.         Save the end of the Macro text.
  959.         Deal with the case of a no-parameter macro
  960. */
  961.         S = (MacSeg *)Umalloc( sizeof(MacSeg) ) ;
  962.         if ( !ML->mp )
  963.                            ML->mp = R = S ;
  964.                 else
  965.                            R->nx = S ;
  966.  
  967.         S->txt = (char *)Umalloc( zstrlen(W) ) ;
  968.         strcpy(S->txt,W) ;
  969.         S->nx = 0 ;
  970.         S->pn = 0 ; /* flag no parameter */
  971.  
  972.         LoseTempParams( B ) ;
  973.         break ;  /* return to outer loop for another line */
  974.         }/*3*/
  975.         else
  976. /*
  977.         Process the Macro Text in LP by searching for
  978.         parameter tokens and creating sections of text
  979.         numbered with the parameters to bracket the real
  980.         parameters when they come..
  981. */
  982.         if( B_Mlist) fprintf(ALST,";\t[%s] |\t%s",ML->mn,LB) ;
  983.  
  984.         while ( *LP )
  985.         {/*3*/
  986.         if ( (i = WhichParameter( B )),i !=0 )
  987.         {/*4*/
  988. /*
  989.         found a Parameter, so create a new Record
  990. */
  991.         S = (MacSeg *)Umalloc(sizeof(MacSeg)) ;
  992.         S->txt = (char *)Umalloc( zstrlen(W) ) ;
  993.         S->pn = i ;             /* Parameter following */
  994.         S->nx = 0 ;
  995.         strcpy(S->txt,W) ;      /* text before */
  996.         *W = 0 ;                /* clear text accumulator */
  997.         wp = W ;
  998.         if( !ML->mp)
  999.                 ML->mp = S ;    /* create head pointer */
  1000.         else
  1001.                 R->nx = S ;     /* append to chain */
  1002.         R = S ;
  1003.         }/*4*/
  1004.         else
  1005.         {/*4*/
  1006.           *wp++ = *LP++ ;       /* add to accumulator */
  1007.           *wp = 0 ;
  1008.         }/*4*/
  1009.         }/*3*/  /* Parameter sections */
  1010.         }/*2*/ /*macro Body*/
  1011.                 
  1012.         if ( !NewLine() )  return  ;
  1013.         }/*1*/
  1014. }
  1015.  
  1016. static  char *GetParameter( unsigned char n,ParamRec *B)
  1017. {
  1018.     if (!n) return "" ;     /* null parameter */
  1019.     while (--n)
  1020.     {
  1021.       B=B->nx ;
  1022.       if( !B )
  1023.       { OpError("*SW err GetParameter\n") ; Kill() ; exit(5) ; }
  1024.   }
  1025. return B->txt ;         /* Parameter text */
  1026. }
  1027.  
  1028.  
  1029.  
  1030. static void  SymbolEdit( char *sytx )
  1031. {
  1032.         SREC   *S ;
  1033.         char   *cp,*cb ;
  1034.         char   w[133] ;
  1035.  
  1036.         for(;;)
  1037.         {
  1038.         if ( (S=SymbolSearch(sytx , &cp) ),S==0 ) return ;
  1039. /*
  1040.         Found Symbol in source line.  cp points to start.
  1041.         length of symbol to be edited out is in the record...
  1042. */
  1043.         cb = cp ;
  1044.         cp += strlen(S->txt) ;
  1045.         strcpy(w,cp) ;
  1046.         sprintf(cb,"0%lxH",S->sv) ;
  1047.         strcat(cb,w) ;
  1048.         ++Ssymbs ;               
  1049.         }
  1050. }
  1051.  
  1052.  
  1053. static   void  SymbolFixup( void )
  1054. {   SymbolEdit( LB ) ;  }
  1055.  
  1056.  
  1057. static int  MacroFixup( void )
  1058. {
  1059.         char    *cp,*Tcp ;
  1060.         MLST    TM ;
  1061.         MLST    *M ,*MT ;
  1062.         ParamRec *B = 0,*P,*Q  ;
  1063.         MacSeg   *S ;
  1064.         int      sl,sx ;
  1065.  
  1066.         if (!ML)   return 0 ;
  1067. /*
  1068.         Macros have been defined..
  1069.         look for them.
  1070. */
  1071.  
  1072.    for( sl = 0 , MT = 0 , M = ML; M ; M = M->nx )
  1073.    {/*1*/
  1074.     if ( (cp = strstr( LP,M->mn) ),cp!=0 )
  1075.     {
  1076.       sx = strlen(M->mn) ;
  1077.       if (
  1078.            ( isspace(*(cp-1))       /* Has White space before */
  1079.              || (cp == LP)         /* Or is first line entry */
  1080.            )
  1081.        &&  (
  1082.               isspace(*(cp+sx))       /* And has white Space after */
  1083.              || !*(cp+sx)             /* or is end-of string */
  1084.            )               
  1085.        && ( sl < sx )            /* And is longer then Match */
  1086.           )
  1087.       {
  1088.          sl = sx ; MT = M ; Tcp = cp ; /* Record Macro Hit */
  1089.       }
  1090.      }
  1091.    }/*1*/
  1092.     if ( !MT )  return 0 ;
  1093.        
  1094. /*
  1095.         Found Macro in source line.
  1096. */
  1097.      fprintf(ALST,";\t*M\t%s%s\n",LP ,
  1098.      ( !B_Mlist && B_ListOn )? "\n\t.NOLIST" : "" ) ;
  1099.  
  1100.      ++Smacs ;          /* Another Macro */
  1101.      LP = Tcp ;         /* Point to the Name */
  1102.      cp = NextString() ;  /* goto first Parameter */
  1103.  
  1104.      TM.nx = 0 ;
  1105.      TM.mn = (char *)Umalloc(zstrlen(cp)) ;
  1106.      strcpy(TM.mn,cp) ;
  1107.      TM.mp = 0 ;
  1108.      TM.N = 0 ;
  1109. /*
  1110.         now look up the parameters.
  1111. */
  1112.         cp = NextString() ;
  1113.  
  1114.         while ( cp )
  1115.         {/*1*/
  1116.         ++TM.N ;
  1117.         Q = (ParamRec *)Umalloc(sizeof(ParamRec)) ;
  1118.  
  1119.         if (!B)
  1120.                          B = P = Q ;
  1121.         else
  1122.                          P->nx  = Q ;
  1123.         Q->nx  = 0 ;
  1124.         Q->txt = (char *)Umalloc(zstrlen( cp )) ;
  1125.         strcpy (Q->txt,cp) ;
  1126.         P = Q ;
  1127.         cp = NextString() ;
  1128.         }/*1*/
  1129. /*
  1130.         All parameters of current Macro found.
  1131.         First compare number of parameters..
  1132. */
  1133.         if (MT->N  != TM.N)
  1134.         {/*1*/
  1135.         OpError("*Incorrect # Params :%s (%d)\n%s\n",MT->mn,MT->N,LB) ;
  1136.         LoseTempParams (B ) ; Kill() ; exit(4) ;
  1137.         }/*1*/
  1138. /*
  1139.          do the substitution...
  1140. */
  1141.         S = MT->mp ;   /* pointer to parts */
  1142.         while( S )
  1143.         {
  1144.  
  1145.         sprintf(W,"%s%s",S->txt,GetParameter(S->pn,B) ) ;
  1146.         SymbolEdit(W) ;
  1147.         fprintf(ALST,"%s",W) ;
  1148.         S = S->nx ;
  1149.         }
  1150.  
  1151.         LoseTempParams(B) ;
  1152.         
  1153.      fprintf(ALST,"%s",
  1154.        ( !B_Mlist && B_ListOn )? "\t.LIST\n" : "" ) ;
  1155.  
  1156.         return  1 ;
  1157.  
  1158. return 0 ;
  1159. }
  1160.  
  1161. static void Time_Date_Stamp(void)
  1162. {
  1163.    time_t tv ;
  1164.    struct tm  *tpt ;
  1165.    char * cp ;
  1166.    
  1167.    time( &tv ) ;
  1168.    tpt = localtime( &tv ) ;
  1169.   
  1170.    fprintf(ALST,"#DEFINE\tDATE__\t\x22%s\x22\n"  ,Strim(asctime(tpt) ) ) ;  
  1171.    cp = strrchr( F_src ,'\\') ;
  1172.    fprintf(ALST,"#DEFINE\tFILE__\t\x22%s\x22\n"  ,(cp)?++cp:F_src) ;     
  1173. }
  1174.  
  1175. int main (int ac,char **av )
  1176. {
  1177. fprintf(stderr,"Macro Expansion For TASM  R.J.P. V:3.5  3rd September 1992\n") ;
  1178.  
  1179.         if ( cmdline(ac,av) )
  1180.         {
  1181.         fprintf(stderr,"Syntax : EXPAND /I:infile /O:outfile [-C] [+M]\n") ;
  1182.         return 1;
  1183.         }
  1184.  
  1185.    NewOpen( F_src ) ;
  1186.    
  1187.    W  = (char *)Umalloc( 4096  ) ; /* general work space */
  1188.    if( B_Stamp )
  1189.                 Time_Date_Stamp() ;
  1190.  
  1191.    if (*T_copyw )
  1192.     fprintf(ALST,"#DEFINE\tCOPYW__\t\x22%s\x22\n" ,T_copyw ) ;
  1193.     
  1194.    if (setjmp(EvalErr) )
  1195.    {
  1196.      OpError("#SYMBOL - Evaluation.\n%s\n" ,LB) ;
  1197.      Kill() ;     exit( 6 ) ;
  1198.    }
  1199.    
  1200.  
  1201.    while ( !NewLine()  )
  1202.    {
  1203.       if (!LoseWhite() )
  1204.       {/*1*/
  1205.         if (!CkSymbolDef() )
  1206.         {/*2*/
  1207.           SymbolFixup() ;
  1208.           CkMacroDef() ;
  1209.           if(!MacroFixup() )
  1210.           {/*3*/
  1211.              sprintf(W,"%s%s",LB,CB ) ;
  1212.              if(*W) fprintf(ALST,"%s\n",W) ;
  1213.           }/*3*/
  1214.          }/*2*/
  1215.        }/*1*/
  1216.       else if (B_Commlist)  fprintf(ALST,"%s\n",CB ) ;
  1217.                                
  1218.     }
  1219. Kill() ;
  1220. fprintf(stderr,
  1221.            "Macros:%d, Found %d Symbols:%d Used %d Memory %u. Bytes\n"
  1222.                 ,Nmacs,Smacs,Nsymbs,Ssymbs, UmemMax ) ;                
  1223. return 0 ;
  1224. }
  1225.