home *** CD-ROM | disk | FTP | other *** search
/ CBM Funet Archive / cbm-funet-archive-2003.iso / cbm / programming / msdos / xa214f.lzh / xa214f / src / xap.c < prev    next >
C/C++ Source or Header  |  1998-01-26  |  23KB  |  896 lines
  1.  
  2. /*
  3.     XA65 - 6502 CROSS ASSEMBLER AND UTILITY SUITE
  4.     cOPYRIGHT (c) 1989-1998 aNDR{$e9} fACHAT (A.FACHAT@PHYSIK.TU-CHEMNITZ.DE)
  5.  
  6.     tHIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
  7.     IT UNDER THE TERMS OF THE gnu gENERAL pUBLIC lICENSE AS PUBLISHED BY
  8.     THE fREE sOFTWARE fOUNDATION; EITHER VERSION 2 OF THE lICENSE, OR
  9.     (AT YOUR OPTION) ANY LATER VERSION.
  10.  
  11.     tHIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
  12.     BUT without any warranty; WITHOUT EVEN THE IMPLIED WARRANTY OF
  13.     merchantability OR fitness for a particular purpose.  sEE THE
  14.     gnu gENERAL pUBLIC lICENSE FOR MORE DETAILS.
  15.  
  16.     yOU SHOULD HAVE RECEIVED A COPY OF THE gnu gENERAL pUBLIC lICENSE
  17.     ALONG WITH THIS PROGRAM; IF NOT, WRITE TO THE fREE sOFTWARE
  18.     fOUNDATION, iNC., 675 mASS aVE, cAMBRIDGE, ma 02139, usa.
  19. */
  20.  
  21.  
  22. #INCLUDE  <STDIO.H>
  23. #INCLUDE  <STDLIB.H>
  24. #INCLUDE  <CTYPE.H>
  25. #INCLUDE  <STRING.H>
  26.  
  27. #INCLUDE  "XAH.H"
  28. #INCLUDE  "XAH2.H"
  29.  
  30. #INCLUDE  "XAR.H"
  31. #INCLUDE  "XA.H"
  32. #INCLUDE  "XAM.H"
  33. #INCLUDE  "XAL.H"
  34. #INCLUDE  "XAT.H"
  35. #INCLUDE  "XAP.H"
  36.  
  37. CHAR   S[maxline];
  38. dATEI     *FILEP;
  39.  
  40. STATIC INT TCOMPARE(CHAR*,CHAR**,INT);
  41. STATIC INT PP_REPLACE(CHAR*,CHAR*,INT,INT);
  42. STATIC INT SUCHDEF(CHAR*);
  43. STATIC INT FGETLINE(CHAR*,INT LEN, INT *RLEN, file*);
  44.  
  45. #DEFINE   HASHCODE(N,L)  (N[0]&0X0F){$7c}(((L-1)?(N[1]&0X0F):0)<<4)
  46.  
  47. STATIC INT  ICL_OPEN(CHAR*),PP_IFDEF(CHAR*),PP_IFNDEF(CHAR*);
  48. STATIC INT  PP_ELSE(CHAR*),PP_ENDIF(CHAR*);
  49. STATIC INT  PP_ECHO(CHAR*),PP_IF(CHAR*),PP_PRINT(CHAR*),PP_PRDEF(CHAR*);
  50. STATIC INT  PP_IFLDEF(CHAR*),PP_IFLUSED(CHAR*);
  51. STATIC INT  PP_UNDEF(CHAR*);
  52.  
  53. #DEFINE   anzbef    13
  54. #DEFINE   valbef    6
  55.  
  56. STATIC CHAR *CMD[]={$7b} "ECHO","INCLUDE","DEFINE","UNDEF","PRINTDEF","PRINT",
  57. "IFDEF","IFNDEF","ELSE","ENDIF",
  58.                "IFLDEF","IFLUSED","IF" {$7d};
  59.                
  60. STATIC INT (*FUNC[])(CHAR*) = {$7b} PP_ECHO,ICL_OPEN,PP_DEFINE,PP_UNDEF,
  61.  PP_PRDEF,PP_PRINT, PP_IFDEF,PP_IFNDEF,
  62.                          PP_ELSE,PP_ENDIF,
  63.                          PP_IFLDEF,PP_IFLUSED,PP_IF {$7d};
  64.  
  65. STATIC CHAR *MEM;
  66. STATIC UNSIGNED LONG MEMFRE;
  67. STATIC INT NLF;
  68. STATIC INT NFF;
  69. STATIC INT HASHINDEX[256];
  70.  
  71. STATIC lIST      *LISTE;
  72. STATIC UNSIGNED INT     RLIST;
  73. STATIC INT       FSP;
  74. STATIC INT       LOOPFL;
  75. STATIC dATEI     FLIST[maxfile+1];
  76. STATIC CHAR      IN_LINE[maxline];
  77.  
  78. INT PP_COMAND(CHAR *T)
  79. {$7b}
  80.      INT I,L,ER=1;
  81.  
  82.      I=TCOMPARE(T,CMD,anzbef);
  83.  
  84.      IF(I>=0)
  85.      {$7b}
  86.           IF(LOOPFL && (I<valbef))
  87.                ER=0;
  88.           ELSE
  89.           {$7b}
  90.                L=(INT)STRLEN(CMD[I]);
  91.                WHILE(ISSPACE(T[L])) L++;
  92.  
  93.                ER=(*FUNC[I])(T+L);
  94.           {$7d}
  95.      {$7d}
  96.      RETURN(ER);
  97. {$7d}
  98.  
  99. INT PP_IFDEF(CHAR *T)
  100. {$7b}
  101. /*     INT X;
  102.      PRINTF("T=%S\N",T);
  103.      X=SUCHDEF(T);
  104.      PRINTF("SUCHDEF(T)=%D\N",X);
  105. */   
  106.      LOOPFL=(LOOPFL<<1)+( SUCHDEF(T) ? 0 : 1 );
  107.      RETURN(0);
  108. {$7d}
  109.  
  110. INT PP_IFNDEF(CHAR *T)
  111. {$7b}
  112.      LOOPFL=(LOOPFL<<1)+( SUCHDEF(T) ? 1 : 0 );
  113.      RETURN(0);
  114. {$7d}
  115.  
  116. INT PP_IFLDEF(CHAR *T)
  117. {$7b}
  118. LOOPFL=(LOOPFL<<1)+( LL_PDEF(T) ? 1 : 0 );
  119. RETURN(0);
  120. {$7d}
  121.  
  122. INT PP_IFLUSED(CHAR *T)
  123. {$7b}
  124. INT N;
  125. LOOPFL=(LOOPFL<<1)+( LL_SUCH(T,&N) ? 1 : 0 );
  126. RETURN(0);
  127. {$7d}
  128.  
  129. INT PP_ECHO(CHAR *T)
  130. {$7b}
  131.      INT ER;
  132.      
  133.      IF((ER=PP_REPLACE(S,T,-1,RLIST)))
  134.           ERROUT(ER);
  135.      ELSE
  136.      {$7b}
  137.           LOGOUT(S);
  138.           LOGOUT("\N");
  139.      {$7d}
  140.      RETURN(0);
  141. {$7d}
  142.  
  143. INT PP_PRINT(CHAR *T)
  144. {$7b}
  145.      INT F,A,ER;
  146.      
  147.      LOGOUT(T);
  148.      IF((ER=PP_REPLACE(S,T,-1,RLIST)))
  149.      {$7b}
  150.           LOGOUT("\N");
  151.           ERROUT(ER);
  152.      {$7d}
  153.      ELSE
  154.      {$7b}
  155.           LOGOUT("=");
  156.           LOGOUT(S);
  157.           LOGOUT("=");
  158.           ER=B_TERM(S,&A,&F,PC[SEGMENT]);
  159.           IF(ER)
  160.           {$7b}
  161.                LOGOUT("\N");
  162.                ERROUT(ER);
  163.           {$7d}
  164.           ELSE
  165.                {$7b} SPRINTF(S,"%D\N",A); LOGOUT(S); {$7d}
  166.      {$7d}
  167.      
  168.      RETURN(0);
  169. {$7d}
  170.  
  171. INT PP_IF(CHAR *T)
  172. {$7b}
  173.      INT A,F,L,ER;
  174.  
  175.      IF((ER=PP_REPLACE(S,T,-1,RLIST)))
  176.           ERROUT(ER);
  177.      ELSE
  178.      {$7b}
  179. DSB_LEN = 1;
  180.           F=B_TERM(S,&A,&L,PC[SEGMENT]);
  181. DSB_LEN = 0;
  182.  
  183.           IF((!LOOPFL) && F)     
  184.                ERROUT(F);
  185.           ELSE
  186.                LOOPFL=(LOOPFL<<1)+( A ? 0 : 1 );
  187.      {$7d}
  188.      RETURN(0);
  189. {$7d}
  190.  
  191. INT PP_ELSE(CHAR *T)
  192. {$7b}
  193.      LOOPFL ^=1;
  194.      RETURN(0);
  195. {$7d}
  196.  
  197. INT PP_ENDIF(CHAR *T)
  198. {$7b}
  199.      LOOPFL=LOOPFL>>1;
  200.      RETURN(0);
  201. {$7d}
  202.  
  203. /* PP_UNDEF IS A GREAT HACK TO GET IT WORKING FAST... */
  204. INT PP_UNDEF(CHAR *T) {$7b}
  205.      INT I;
  206.      IF((I=SUCHDEF(T))) {$7b}
  207. I+=RLIST;
  208. LISTE[I].S_LEN=0;
  209.      {$7d}
  210.      RETURN 0;
  211. {$7d}
  212.  
  213. INT PP_PRDEF(CHAR *T)
  214. {$7b}
  215.      CHAR *X;
  216.      INT I,J;
  217.  
  218.      IF((I=SUCHDEF(T)))
  219.      {$7b}
  220.           I+=RLIST;
  221.           X=LISTE[I].SEARCH;
  222.           SPRINTF(S,"\N%S",X);
  223.           IF(LISTE[I].P_ANZ)
  224.           {$7b}
  225.                SPRINTF(S+STRLEN(S),"(");
  226.                FOR(J=0;J<LISTE[I].P_ANZ;J++)
  227.                {$7b}
  228.                     X+=STRLEN(X)+1;
  229.                     SPRINTF(S+STRLEN(S),"%S%C",X,(LISTE[I].P_ANZ-J-1) ? ',' : ')');
  230.                {$7d}
  231.           {$7d}
  232.           SPRINTF(S+STRLEN(S),"=%S\N",LISTE[I].REPLACE);
  233.           LOGOUT(S);
  234.      {$7d}
  235.      RETURN(e_ok);
  236. {$7d}
  237.  
  238. INT SUCHDEF(CHAR *T)
  239. {$7b}
  240.      INT I=0,J,K,L=0;
  241.  
  242.      WHILE(T[L]!=' ' && T[L]!='\0') L++;
  243.  
  244.      IF(RLIST)
  245.      {$7b}
  246.        I=HASHINDEX[HASHCODE(T,L)];
  247.      
  248.        DO   /*FOR(I=0;I<RLIST;I++)*/
  249.        {$7b}
  250.           K=LISTE[I].S_LEN;
  251.           J=0;
  252.  
  253.           IF(K && (K==L))
  254.           {$7b}
  255.                WHILE((T[J]==LISTE[I].SEARCH[J])&&J<K) J++;
  256.                IF(J==K)
  257.                     BREAK;
  258.           {$7d}
  259.           
  260.           IF(!I)
  261.           {$7b}
  262.                I=RLIST;
  263.                BREAK;
  264.           {$7d}
  265.           
  266.           I=LISTE[I].NEXTINDEX;
  267.                
  268.        {$7d} WHILE(1);
  269.      {$7d} 
  270.     
  271.      RETURN(I-RLIST);
  272. {$7d}
  273.  
  274. INT GA_PP(VOID)
  275. {$7b}
  276. RETURN(RLIST);
  277. {$7d}
  278.  
  279. INT GM_PP(VOID)
  280. {$7b}
  281. RETURN(anzdef);
  282. {$7d}
  283.  
  284. LONG GM_PPM(VOID)
  285. {$7b}
  286. RETURN(maxpp);
  287. {$7d}
  288.  
  289. LONG GA_PPM(VOID)
  290. {$7b}
  291. RETURN(maxpp-MEMFRE);
  292. {$7d}
  293.     
  294. INT PP_DEFINE(CHAR *K)
  295. {$7b}
  296.      INT I,ER=e_ok,HASH,RL;
  297.      CHAR H[maxline*2],*T;
  298.      UNSIGNED INT J;
  299.      
  300.      T=K;
  301.           
  302.      IF(RLIST>=anzdef {$7c}{$7c} MEMFRE<maxline*2)
  303.           RETURN(e_nomem);
  304. /*
  305.      PRINTF("DEFINE:MEM=%04LX\N",MEM);
  306.      GETCHAR();
  307. */   
  308.      RL=RLIST++;
  309.      
  310.      LISTE[RL].SEARCH=MEM;
  311.      FOR(I=0; (T[I]!=' ') && (T[I]!='\0') && (T[I]!='(') ;I++)
  312.           *MEM++=T[I];
  313.      *MEM++='\0';
  314.      MEMFRE-=I+1;
  315.      LISTE[RL].S_LEN=I;
  316.      LISTE[RL].P_ANZ=0;
  317.  
  318. /*
  319.      PRINTF("DEFINE:%S\NLEN1=%D\N",LISTE[RL].SEARCH,LISTE[RL].S_LEN);
  320.      GETCHAR();
  321. */ 
  322.      IF(T[I]=='(')
  323.      {$7b}
  324.           WHILE(T[I]!=')' && T[I]!='\0')
  325.           {$7b}
  326.                I++;
  327.                LISTE[RL].P_ANZ++;
  328.                FOR(J=0; T[I+J]!=')' && T[I+J]!=',' && T[I+J]!='\0';J++);
  329.                IF(J<MEMFRE)
  330.                {$7b}
  331.                     STRNCPY(MEM,T+I,J);
  332.                     MEM+=J+1;
  333.                     MEMFRE-=J+1;
  334.                {$7d}
  335.                I+=J;
  336.           {$7d}
  337.           IF(T[I]==')')
  338.                I++;
  339.      {$7d}
  340.      WHILE(T[I]==' ')
  341.           I++;
  342.      T+=I;
  343.      
  344.      PP_REPLACE(H,T,-1,0);
  345.  
  346.      T=H;     
  347.  
  348.      LISTE[RL].REPLACE=MEM;
  349.      STRCPY(MEM,T);
  350.      MEM+=STRLEN(T)+1;
  351. #IF 0/* DEBUG */
  352.      {$7b} CHAR *SS;
  353.      IF(LISTE[RL].P_ANZ)
  354.      {$7b}
  355.           SS=LISTE[RL].SEARCH;
  356.           PRINTF("DEFINE:\N%S(",LISTE[RL].SEARCH);
  357.           FOR(J=0;J<LISTE[RL].P_ANZ;J++)
  358.           {$7b}
  359.                SS+=STRLEN(SS)+1;
  360.                PRINTF("%S%C",SS,(LISTE[RL].P_ANZ-J-1) ? ',' : ')');
  361.           {$7d}
  362.           PRINTF("=%S\N",LISTE[RL].REPLACE);
  363.           GETCHAR();
  364.      {$7d}
  365.      ELSE
  366.      {$7b}
  367.           PRINTF("DEFINE:%S=%S\NLEN1=%D\N",LISTE[RL].SEARCH,
  368.                LISTE[RL].REPLACE,LISTE[RL].S_LEN);
  369.      {$7d}
  370.      {$7d}
  371. #ENDIF
  372.      IF(!ER)
  373.      {$7b}
  374.           HASH=HASHCODE(LISTE[RL].SEARCH,LISTE[RL].S_LEN);
  375.           LISTE[RL].NEXTINDEX=HASHINDEX[HASH];
  376.           HASHINDEX[HASH]=RL;
  377.      {$7d} ELSE
  378.           RLIST=RL;
  379.      
  380.      RETURN(ER);
  381. {$7d}
  382.  
  383. INT TCOMPARE(CHAR S[],CHAR *V[], INT N)
  384. {$7b}
  385.      INT I,J,L;
  386.      STATIC CHAR T[maxline];
  387.  
  388.      FOR(I=0; S[I]!='\0'; I++) 
  389.           T[I]=TOLOWER(S[I]);
  390.      T[I]='\0';
  391.  
  392.      FOR(I=0;I<N;I++)
  393.      {$7b}
  394.           L=(INT)STRLEN(V[I]);
  395.           
  396.           FOR(J=0;J<L;J++)
  397.           {$7b}
  398.                IF(T[J]!=V[I][J])
  399.                     BREAK;
  400.           {$7d}
  401.           IF(J==L)
  402.                BREAK;
  403.      {$7d}
  404.      RETURN((I==N)? -1 : I);
  405. {$7d}
  406.  
  407. INT PP_REPLACE(CHAR *TO, CHAR *TI, INT A,INT B)
  408. {$7b}
  409.      CHAR *T=TO,C,*X,*Y,*MX,*RS;
  410.      INT I,L,N,SL,D,LD,ER=e_ok,HKFL,KLFL;
  411.      CHAR FTI[maxline],FTO[maxline];
  412. /*
  413.      INT FLAG=!STRNCMP(TI,"tout",4);
  414.      IF(FLAG) PRINTF("FLAG=%D\N",FLAG);
  415. */   
  416.      STRCPY(T,TI);
  417.  
  418.      IF(RLIST)
  419.      {$7b}
  420.        WHILE(T[0]!='\0')
  421.        {$7b}
  422.           WHILE(!ISALPHA(T[0]) && T[0]!='_')
  423.                IF(T[0]=='\0')
  424.                     BREAK;    /*RETURN(e_ok);*/
  425.                ELSE
  426.                {$7b}
  427.                     T++;
  428.                     TI++;
  429.                {$7d}
  430.          
  431.           FOR(L=0;ISALNUM(T[L]){$7c}{$7c}T[L]=='_';L++);
  432.           LD=L;
  433. /*          
  434.           IF(FLAG) PRINTF("L=%D,A=%D,T=%S\N",L,A,T);
  435. */        
  436.           IF(A<0)
  437.           {$7b}
  438.             N=HASHINDEX[HASHCODE(T,L)];
  439.             
  440.             DO      
  441.             {$7b}
  442.                SL=LISTE[N].S_LEN;
  443.           
  444.                IF(SL && (SL==L))
  445.                {$7b}
  446.                     I=0;
  447.                     X=LISTE[N].SEARCH;
  448.                     WHILE(T[I]==*X++ && T[I])
  449.                          I++;
  450.  
  451.                     IF(I==SL)
  452.                     {$7b}     
  453.                          RS=LISTE[N].REPLACE;
  454.                          
  455.                          IF(LISTE[N].P_ANZ)        
  456.                          {$7b}
  457.                               STRCPY(FTI,LISTE[N].REPLACE);
  458.  
  459.                               IF(RLIST+LISTE[N].P_ANZ>=anzdef {$7c}{$7c} MEMFRE<maxline*2)
  460.                                    ER=e_nomem;
  461.                               ELSE
  462.                               {$7b}
  463.                                    Y=T+SL;
  464.                                    X=LISTE[N].SEARCH+SL+1;
  465.                                    IF(*Y!='(')
  466.                                         ER=e_syntax;
  467.                                    ELSE
  468.                                    {$7b}
  469.                                         MX=MEM-1;
  470.                                         FOR(I=0;I<LISTE[N].P_ANZ;I++)
  471.                                         {$7b}
  472.                                              LISTE[RLIST+I].SEARCH=X;
  473.                                              LISTE[RLIST+I].S_LEN=(INT)STRLEN(X);
  474.                                              X+=STRLEN(X)+1;
  475.                                              LISTE[RLIST+I].P_ANZ=0;
  476.                                              LISTE[RLIST+I].REPLACE=MX+1;
  477.                                              C=*(++MX)=*(++Y);
  478.                                              HKFL=KLFL=0;
  479.                                              WHILE(C!='\0' 
  480.                                                   && ((HKFL!=0 
  481.                                                        {$7c}{$7c} KLFL!=0) 
  482.                                                        {$7c}{$7c} (C!=',' 
  483.                                                        && C!=')') 
  484.                                                        )
  485.                                                   )
  486.                                              {$7b}
  487.                                                   IF(C=='\"')
  488.                                                        HKFL=HKFL^1;
  489.                                                   IF(!HKFL)
  490.                                                   {$7b}
  491.                                                        IF(C=='(')
  492.                                                             KLFL++;
  493.                                                        IF(C==')')
  494.                                                             KLFL--;
  495.                                                   {$7d}     
  496.                                                   C=*(++MX)=*(++Y);
  497.                                              {$7d}
  498.                                              *MX='\0';
  499.                                              IF(C!=((I==LISTE[N].P_ANZ-1) ? ')' : ','))
  500.                                              {$7b}
  501.                                                   ER=e_anzpar;
  502.                                                   BREAK;
  503.                                              {$7d}
  504.                                         {$7d}   
  505. /*
  506.      PRINTF("REPLACE:\N");
  507.      PRINTF("%S=%S\N",LISTE[N].SEARCH,LISTE[N].REPLACE);
  508.      FOR(I=0;I<LISTE[N].P_ANZ;I++)
  509.           PRINTF("-%S=%S\N",LISTE[RLIST+I].SEARCH,LISTE[RLIST+I].REPLACE);
  510. */
  511.                                         IF(!ER)
  512.                                              ER=PP_REPLACE(FTO,FTI,RLIST,RLIST+I);
  513. /*               IF(FLAG) PRINTF("SL=%D,",SL);*/
  514.                                         SL=(INT)((LONG)Y+1l-(LONG)T);
  515. /*               IF(FLAG) PRINTF("SL=%D\N",SL);*/
  516.                                         RS=FTO;
  517. /*     PRINTF("->%S\N",FTO);*/
  518.                                    {$7d}    
  519.                               {$7d}
  520.                               IF(ER)
  521.                                    RETURN(ER);     
  522.                          {$7d}
  523.  
  524.                          D=(INT)STRLEN(RS)-SL;
  525.  
  526.                          IF(STRLEN(TO)+D>=maxline)
  527.                               RETURN(e_nomem);
  528.  
  529. /*
  530.                          IF(D<0)
  531.                          {$7b}
  532.                               Y=T+SL+D;
  533.                               X=T+SL;
  534.                               WHILE(*Y++=*X++);
  535.                          {$7d}
  536.                          IF(D>0)
  537.                          {$7b}
  538.                               FOR(LL=STRLEN(T);LL>=SL;LL--)
  539.                                    T[LL+D]=T[LL];
  540.                          {$7d}
  541. */
  542.                          IF(D)
  543.                               STRCPY(T+SL+D,TI+SL);
  544.  
  545.                          I=0;
  546.                          WHILE((C=RS[I]))
  547.                               T[I++]=C;
  548.                          L=SL+D;/*=0;*/
  549.                          BREAK;
  550.                     {$7d}
  551.                {$7d}
  552.                IF(!N)
  553.                     BREAK;
  554.                     
  555.                N=LISTE[N].NEXTINDEX;
  556.                
  557.             {$7d} WHILE(1);
  558.           {$7d} ELSE
  559.           {$7b}
  560.             FOR(N=B-1;N>=A;N--)
  561.             {$7b}
  562.                SL=LISTE[N].S_LEN;
  563.           
  564.                IF(SL && (SL==L))
  565.                {$7b}
  566.                     I=0;
  567.                     X=LISTE[N].SEARCH;
  568.                     WHILE(T[I]==*X++ && T[I])
  569.                          I++;
  570.  
  571.                     IF(I==SL)
  572.                     {$7b}     
  573.                          RS=LISTE[N].REPLACE;
  574. /*                         
  575.                          IF(LISTE[N].P_ANZ)        
  576.                          {$7b}
  577.                               STRCPY(FTI,LISTE[N].REPLACE);
  578.                               IF(RLIST+LISTE[N].P_ANZ>=anzdef {$7c}{$7c} MEMFRE<maxline*2)
  579.                                    ER=e_nomem;
  580.                               ELSE
  581.                               {$7b}
  582.                                    Y=T+SL;
  583.                                    X=LISTE[N].SEARCH+SL+1;
  584.                                    IF(*Y!='(')
  585.                                         ER=e_syntax;
  586.                                    ELSE
  587.                                    {$7b}
  588.                                         MX=MEM-1;
  589.                                         FOR(I=0;I<LISTE[N].P_ANZ;I++)
  590.                                         {$7b}
  591.                                              LISTE[RLIST+I].SEARCH=X;
  592.                                              LISTE[RLIST+I].S_LEN=STRLEN(X);
  593.                                              X+=STRLEN(X)+1;
  594.                                              LISTE[RLIST+I].P_ANZ=0;
  595.                                              LISTE[RLIST+I].REPLACE=MX+1;
  596.                                              C=*(++MX)=*(++Y);
  597.                                              HKFL=KLFL=0;
  598.                                              WHILE(C!='\0' 
  599.                                                   && ((HKFL!=0 
  600.                                                        {$7c}{$7c} KLFL!=0) 
  601.                                                        {$7c}{$7c} (C!=',' 
  602.                                                        && C!=')') 
  603.                                                        )
  604.                                                   )
  605.                                              {$7b}
  606.                                                   IF(C=='\"')
  607.                                                        HKFL=HKFL^1;
  608.                                                   IF(!HKFL)
  609.                                                   {$7b}
  610.                                                        IF(C=='(')
  611.                                                             KLFL++;
  612.                                                        IF(C==')')
  613.                                                             KLFL--;
  614.                                                   {$7d}     
  615.                                                   C=*(++MX)=*(++Y);
  616.                                              {$7d}
  617.                                              *MX='\0';
  618.                                              IF(C!=((I==LISTE[N].P_ANZ-1) ? ')' : ','))
  619.                                              {$7b}
  620.                                                   ER=e_anzpar;
  621.                                                   BREAK;
  622.                                              {$7d}  
  623.                                         {$7d}   
  624.                                         IF(!ER)
  625.                                              ER=PP_REPLACE(FTO,FTI,RLIST,RLIST+I);
  626.                                         SL=(INT)((LONG)Y+1l-(LONG)T);
  627.                                         RS=FTO;
  628.                                    {$7d}    
  629.                               {$7d}
  630.                               IF(ER)
  631.                                    RETURN(ER);     
  632.                          {$7d}
  633. */
  634.                          D=(INT)STRLEN(RS)-SL;
  635.  
  636.                          IF(STRLEN(TO)+D>=maxline)
  637.                               RETURN(e_nomem);
  638. /*
  639.                          IF(D<0)
  640.                          {$7b}
  641.                               Y=T+SL+D;
  642.                               X=T+SL;
  643.                               WHILE(*Y++=*X++);
  644.                          {$7d}
  645.                          IF(D>0)
  646.                          {$7b}
  647.                               FOR(LL=STRLEN(T);LL>=SL;LL--)
  648.                                    T[LL+D]=T[LL];
  649.                          {$7d}
  650. */
  651.                          IF(D)
  652.                               STRCPY(T+SL+D,TI+SL);
  653.                               
  654.                          I=0;
  655.                          WHILE((C=RS[I]))
  656.                               T[I++]=C;
  657.                          L+=D;/*0;*/
  658.                          BREAK;
  659.                     {$7d}
  660.                {$7d}
  661.             {$7d}
  662.           {$7d}
  663.           TI+=LD;
  664.           T+=L;
  665.        {$7d}
  666.      {$7d}
  667.      RETURN(e_ok);
  668. {$7d}
  669.  
  670. INT PP_INIT(VOID)
  671. {$7b}
  672.      INT ER;
  673.  
  674.      FOR(ER=0;ER<256;ER++)
  675.           HASHINDEX[ER]=0;
  676.           
  677.      FSP=0;
  678.  
  679.      ER=0;
  680.      MEM=MALLOC(maxpp);
  681.      IF(!MEM) ER=e_nomem;
  682.  
  683.      MEMFRE=maxpp;
  684.      RLIST=0;
  685.      NLF=1;
  686.      NFF=1;
  687.      IF(!ER) {$7b}
  688.           LISTE=MALLOC((LONG)anzdef*SIZEOF(lIST));
  689.   IF(!LISTE) ER=e_nomem;
  690.      {$7d}
  691.      RETURN(ER);
  692. {$7d}
  693.  
  694. INT PP_OPEN(CHAR *NAME)
  695. {$7b}
  696.      file *FP;
  697.  
  698.      FP=XFOPEN(NAME,"R");
  699.  
  700.      STRCPY(FLIST[0].FNAME,NAME);
  701.      FLIST[0].FLINE=0;
  702.      FLIST[0].BDEPTH=B_DEPTH();
  703.      FLIST[0].FILEP=FP;
  704.      FLIST[0].FLINEP=null;    
  705.  
  706.      RETURN(((LONG)FP)==0L);
  707. {$7d}
  708.  
  709. VOID PP_CLOSE(VOID)
  710. {$7b}
  711.      IF(FLIST[FSP].BDEPTH != B_DEPTH()) {$7b}
  712. FPRINTF(STDERR, "bLOCKS NOT CONSISTENT IN FILE %S: START DEPTH=%D, END DEPTH=%D\N",
  713.   FLIST[FSP].FNAME, FLIST[FSP].BDEPTH, B_DEPTH());
  714.      {$7d}
  715.      FCLOSE(FLIST[FSP].FILEP);
  716. {$7d}
  717.  
  718. VOID PP_END(VOID) {$7b} {$7d}
  719.  
  720. dATEI *PP_GETIDAT(VOID) {$7b}
  721. RETURN &FLIST[FSP];
  722. {$7d}
  723.  
  724. INT ICL_CLOSE(INT *C)
  725. {$7b}
  726.      IF(!FSP)
  727.           RETURN(e_eof);
  728.      
  729.      IF(FLIST[FSP].BDEPTH != B_DEPTH()) {$7b}
  730. FPRINTF(STDERR, "bLOCKS NOT CONSISTENT IN FILE %S: START DEPTH=%D, END DEPTH=%D\N",
  731.   FLIST[FSP].FNAME, FLIST[FSP].BDEPTH, B_DEPTH());
  732.      {$7d}
  733.  
  734.      FCLOSE(FLIST[FSP--].FILEP);
  735.      NFF=1;
  736.      *C='\N';
  737.  
  738.      RETURN(e_ok);
  739. {$7d}
  740.  
  741. INT ICL_OPEN(CHAR *TT)
  742. {$7b}
  743.      file *FP2;
  744.      INT J,I=0;
  745.  
  746.      PP_REPLACE(S,TT,-1,RLIST);
  747.  
  748.      IF(FSP>=maxfile)
  749.           RETURN(-1);
  750.  
  751.      IF(S[I]=='<' {$7c}{$7c} S[I]=='"')
  752.           I++;
  753.  
  754.      FOR(J=I;S[J];J++)
  755.           IF(S[J]=='>' {$7c}{$7c} S[J]=='"')
  756.                S[J]='\0';
  757.  
  758.      FP2=XFOPEN(S+I,"R");
  759.  
  760.      IF(!FP2)
  761.           RETURN(e_fnf);
  762.  
  763. SETVBUF(FP2,null,_iofbf,bufsize);
  764.  
  765.      FSP++;
  766.  
  767.      STRCPY(FLIST[FSP].FNAME,S+I);
  768.      FLIST[FSP].FLINE=0;
  769.      FLIST[FSP].BDEPTH=B_DEPTH();
  770.      FLIST[FSP].FLINEP=null;
  771.      FLIST[FSP].FILEP=FP2;
  772.      NFF=1;
  773.  
  774.      RETURN(0);
  775. {$7d}
  776.  
  777. INT PGETLINE(CHAR *T)
  778. {$7b}
  779.      INT C,ER=e_ok;
  780.      INT RLEN, TLEN;
  781.  
  782.      LOOPFL =0;
  783.  
  784.      FILEP =FLIST+FSP;
  785.  
  786.      DO {$7b}
  787.           C=FGETLINE(IN_LINE, maxline, &RLEN, FLIST[FSP].FILEP);
  788.   /* CONTINUATION LINES */
  789.   TLEN = RLEN;
  790.   WHILE(C=='\N' && TLEN && IN_LINE[TLEN-1]=='\\') {$7b}
  791.     C=FGETLINE(IN_LINE + TLEN-1, maxline-TLEN, &RLEN, FLIST[FSP].FILEP);
  792.     TLEN += RLEN-1;
  793.   {$7d}
  794.           IF(IN_LINE[0]=='#')
  795.           {$7b}
  796.                IF((ER=PP_COMAND(IN_LINE+1)))
  797.                {$7b}
  798.                     IF(ER!=1)
  799.                     {$7b}
  800.                          LOGOUT(IN_LINE);
  801.                          LOGOUT("\N");
  802.                     {$7d}
  803.                {$7d}
  804.           {$7d} ELSE
  805.                ER=1;
  806.  
  807.           IF(C==eof)
  808.                ER=ICL_CLOSE(&C);
  809.  
  810.      {$7d} WHILE(!ER {$7c}{$7c} (LOOPFL && ER!=e_eof));
  811.  
  812.      IF(!ER {$7c}{$7c} LOOPFL)
  813.           IN_LINE[0]='\0';
  814.      ER= (ER==1) ? e_ok : ER ;
  815.  
  816.      IF(!ER)
  817.           ER=PP_REPLACE(T,IN_LINE,-1,RLIST);
  818.  
  819.      IF(!ER && NFF)
  820.           ER=e_newfile;
  821.      IF(!ER && NLF)
  822.           ER=e_newline;
  823.      NLF=NFF=0;
  824.  
  825.      FILEP=FLIST+FSP;
  826.      FILEP->FLINEP=IN_LINE;
  827.      
  828.      RETURN(ER);
  829. {$7d}
  830.  
  831.  
  832. /*************************************************************************/
  833.  
  834. INT RGETC(file *FP)
  835. {$7b}
  836.      STATIC INT C,D,FL;
  837.  
  838.      FL=0;
  839.  
  840.      DO
  841.      {$7b}
  842.           WHILE((C=GETC(FP))==13);  /* REMOVE ^m FOR UNICES */
  843.  
  844.           IF(FL && (C=='*'))
  845.           {$7b}
  846.                IF((D=GETC(FP))!='/')
  847.                     UNGETC(D,FP);
  848.                ELSE
  849.                {$7b}
  850.                     FL--;
  851.                     WHILE((C=GETC(FP))==13);
  852.                {$7d}
  853.           {$7d}
  854.  
  855.           IF(C=='\N')
  856.           {$7b}
  857.                FLIST[FSP].FLINE++;
  858.                NLF=1;
  859.           {$7d} ELSE
  860.           IF(C=='/')
  861.           {$7b}
  862.                IF((D=GETC(FP))!='*')
  863.                     UNGETC(D,FP);
  864.                ELSE
  865.                     FL++;
  866.           {$7d}
  867.  
  868.      {$7d} WHILE(FL && (C!=eof));
  869.  
  870.      RETURN(C-'\T'?C:' ');
  871. {$7d}
  872.  
  873. INT FGETLINE(CHAR *T, INT LEN, INT *RLEN, file *FP)
  874. {$7b}
  875.      STATIC INT C,I;
  876.  
  877.      I=0;
  878.  
  879.      DO {$7b}
  880.           C=RGETC(FP);
  881.           
  882.           IF(C==eof {$7c}{$7c} C=='\N')
  883.           {$7b}
  884.              T[I]='\0';
  885.              BREAK;
  886.           {$7d}
  887.           T[I]=C;
  888.           I= (I<LEN-1) ? I+1 : LEN-1;
  889.      {$7d} WHILE(1);
  890.      *RLEN = I;
  891.      RETURN(C);
  892. {$7d}
  893.  
  894.  
  895.  
  896.