home *** CD-ROM | disk | FTP | other *** search
/ 8bitfiles.net/archives / archives.tar / archives / genie-commodore-file-library / C64-128Toolkit / CREF.SFX / cref2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-27  |  4.3 KB  |  234 lines
  1. /**************************************
  2. *
  3. *  ├╥┼╞2.├ (2 OF 3 SOURCE FILES)
  4. *
  5. *  ╬OTE: USE OF THE '╥┼├╒╥╙╔╓┼'
  6. *  ROUTINES CAUSES STACK OVER-RUN
  7. *  ON THE ├64
  8. **************************************/
  9.  
  10. #INCLUDE <STDIO.H>
  11. #INCLUDE <CREF.H>
  12.  
  13. /* LOOKUP - INSTALL NAME AT OR BELOW
  14.    ROOT */
  15. STRUCT NODE **LOOKUP(ROOT,N)
  16. STRUCT NODE **ROOT;
  17. CHAR *N;
  18. █
  19.  INT COND;
  20.  
  21. #IFDEF ╥┼├╒╥╙╔╓┼
  22.  IF(*ROOT!=╬╒╠╠) █
  23.   IF((COND=LEXCMP(N,(*ROOT)->NAME)) != 0)
  24.    ROOT=LOOKUP((COND<0)?&(*ROOT)->LEFT:&(*ROOT)->RIGHT,N);
  25.  ▌
  26. #ELSE
  27.  WHILE(*ROOT != ╬╒╠╠ && (COND = LEXCMP(N,(*ROOT)->NAME)))
  28.    ROOT=(COND<0)?&(*ROOT)->LEFT:&(*ROOT)->RIGHT;
  29. #ENDIF
  30.  RETURN(ROOT);
  31. ▌
  32.  
  33. /* ADD INSERT ENTRY FOR "NAME" IN
  34.    TREE AT "ROOT" */
  35. STRUCT NODE *ADD(N)
  36. CHAR *N;
  37. █
  38.  CHAR *MALLOC();
  39.  STRUCT NODE *R;
  40.  
  41.  IF((R=(STRUCT NODE *)MALLOC(SIZEOF(STRUCT NODE))) == ╬╒╠╠) █
  42.   FPRINTF(STDOUT,"ABORTED:MEMORY ALLOCATION ERROR\N\N");
  43.   EXIT();
  44.  ▌
  45.  R->LEFT=R->RIGHT=╬╒╠╠;
  46.  R->P.LINES=╬╒╠╠;
  47.  R->NAME=N;
  48.  RETURN(R);
  49. ▌
  50.  
  51. /* TREEWALK - CALL 'FTN' FOR EACH
  52.    NODE IN ORDER */
  53. UNSIGNED TREEWALK(ROOT,FTN)
  54. STRUCT NODE *ROOT;
  55. UNSIGNED(*FTN)();
  56. █
  57. #IFDEF ╥┼├╒╥╙╔╓┼
  58.  IF(ROOT != ╬╒╠╠) █
  59.   TREEWALK(ROOT->LEFT,FTN);
  60.   (*FTN)(ROOT);
  61.   TREEWALK(ROOT->RIGHT,FTN);
  62.  ▌
  63. #ELSE
  64.  STRUCT NODE *STACK,*TMP;
  65.  
  66.  STACK=╬╒╠╠;  /* STACK INITIALLY EMPTY */
  67.  FOR(;;) █
  68.   IF(ROOT != ╬╒╠╠) █
  69.    TMP=ROOT;
  70.    ROOT=ROOT->LEFT;  /* MOVE TO LEFT */
  71.    TMP->LEFT=STACK;
  72.    STACK=TMP;  /* PUSH TMP */
  73.   ▌
  74.   ELSE IF(STACK != ╬╒╠╠) █ /* STACK NOT EMPTY */
  75.    ROOT=STACK;
  76.    STACK=STACK->LEFT;  /* POP */
  77.    (*FTN)(ROOT);  /* VISIT NODE */
  78.    ROOT=ROOT->RIGHT;  /* MOVE RIGHT */
  79.   ▌
  80.   ELSE BREAK;  /* STACK IS EMPTY */
  81.  ▌
  82. #ENDIF
  83. ▌
  84.  
  85. /* INSERT - ADD 'LINEñNO' TO THE 
  86.    CIRCULAR LIST, 'ORIGIN' */
  87. STRUCT INSTANCE *INSERT(ORIGIN,LINEñNO)
  88. STRUCT INSTANCE *ORIGIN;
  89. INT LINEñNO;
  90. █
  91.  CHAR *MALLOC();
  92.  STRUCT INSTANCE *T;
  93.  
  94.  IF(ORIGIN==╬╒╠╠ ▀▀ ORIGIN->LINE != LINEñNO) █
  95.   IF((T=(STRUCT INSTANCE *)MALLOC(SIZEOF(STRUCT INSTANCE))) == ╬╒╠╠) █
  96.    FPRINTF(STDOUT,"ABORTED:MEMORY ALLOCATION ERROR\N\N");
  97.    EXIT();
  98.   ▌
  99.   IF(ORIGIN==╬╒╠╠)
  100.    ORIGIN=T;
  101.   T->LINE=LINEñNO;
  102.   T->NEXT=ORIGIN->NEXT;
  103.   ORIGIN->NEXT=T;
  104.   ORIGIN=T;
  105.  ▌
  106.  RETURN(ORIGIN);
  107. ▌
  108.  
  109. /* USE - LOG AN OCCURRENCE OF "NAME" 
  110.    IN "FILE" AT "LINE" */
  111. UNSIGNED USE(N,FILE,LNE)
  112. CHAR *N,*FILE;
  113. UNSIGNED LNE;
  114. █
  115.  EXTERN STRUCT NODE *SYMñROOT,*FILñROOT;
  116.  CHAR *NEWCPY();
  117.  STRUCT NODE **FT,**NT;
  118.  
  119.  IF(*(NT=LOOKUP(&SYMñROOT,N))==╬╒╠╠)
  120.   *NT=ADD(NEWCPY(N));
  121.  IF(*(NT=LOOKUP(&((*NT)->P.FILES),FILE))==╬╒╠╠) █
  122.   IF(*(FT=LOOKUP(&FILñROOT,FILE))==╬╒╠╠)
  123.    *FT=ADD(NEWCPY(FILE));
  124.   *NT=ADD((*FT)->NAME);
  125.  ▌
  126.  (*NT)->P.LINES=INSERT((*NT)->P.LINES,LNE);
  127. ▌
  128.  
  129. /* GETñNAME - EXTRACT FILE NAME
  130.    FROM LINE */
  131. UNSIGNED GETñNAME(LNE,FILE)
  132. CHAR *LNE,*FILE;
  133. █
  134.  UNSIGNED CPYñUNTL();
  135.  CHAR *DELIM;
  136.  
  137.  WHILE(*LNE==' ')
  138.   ++LNE;
  139.  IF(*LNE!='\N') █  /* IF NONE,USE "FILE" AS IS */
  140.   IF(*LNE=='"') █
  141.    DELIM="\"\N";
  142.    ++LNE;
  143.   ▌
  144.   ELSE IF(*LNE=='<') █
  145.    DELIM=">\N";
  146.    ++LNE;
  147.   ▌
  148.   ELSE DELIM="\N";
  149.   CPYñUNTL(FILE,LNE,DELIM);
  150.  ▌
  151. ▌
  152.  
  153. /* NEWñLINE - RETURN POINTER TO THE
  154.    NEXT LINE */
  155. CHAR *NEWñLINE()
  156. █
  157.  EXTERN INT LINEñCNT;
  158.  STATIC CHAR LINE[═┴╪╠╔╬┼+1];
  159.  
  160.  ++LINEñCNT;
  161.  RETURN(FGETS(LINE,═┴╪╠╔╬┼,STDIN));
  162. ▌
  163.  
  164. /* WHITSPAC - TESTS FOR BLANKS
  165.    AND COMMENTS */
  166. UNSIGNED WHITSPAC(S)
  167. CHAR **S;
  168. █
  169.  WHILE(**S == ' ')  ++*S;
  170.  IF(**S=='/' && *((*S)+1)=='*') █ /* COMMENT */
  171.   WHILE(*(++(*S))!='/') █
  172.    WHILE(*(++(*S))!='*') █
  173.     IF(**S==┼╧╙) █
  174.      IF((*S=NEWñLINE())!=╬╒╠╠)
  175.       --(*S);  /* DUE TO PRE-INCREMENT IN INNER WHILE LOOP */
  176.      ELSE █
  177.       FPRINTF(STDOUT,"UNEXPECTED ┼╧╞\N");
  178.       RETURN(╞┴╠╙┼);
  179.      ▌
  180.     ▌
  181.    ▌
  182.   ▌
  183.   RETURN(╘╥╒┼);
  184.  ▌
  185.  RETURN(╞┴╠╙┼);
  186. ▌
  187.  
  188. /* ISHEX - IS 'C' A HEXADECIMAL DIGIT? */
  189. UNSIGNED ISHEX(C)
  190. CHAR C;
  191. █
  192.  RETURN(('0'<=C&&C<='9')▀▀('A'<=C&&C<='F'));
  193. ▌
  194.  
  195. /* GETOKEN - STRIP LEADING TOKEN
  196.    FROM S */
  197. CHAR GETOKEN(S,T)
  198. CHAR **S,*T;
  199. █
  200.  CHAR ESC();
  201.  CHAR CLASS;
  202.  
  203.  WHILE(WHITSPAC(S)) ++*S;
  204.  IF(ISALPHA(**S)▀▀**S=='ñ') █  /* IDENTIFIER */
  205.   CLASS=╔─;
  206.   DO █
  207.    *(T++)=*((*S)++);
  208.   ▌ WHILE(ISDIGIT(**S)▀▀ISALPHA(**S)▀▀**S=='ñ');
  209.  ▌
  210.  ELSE IF(**S=='\"'▀▀**S=='\'') █  /* STRING OR LITERAL */
  211.   CLASS=**S;
  212.   DO █
  213.    ESC(S);
  214.    ++(*S);
  215.    IF(**S==┼╧╙) █
  216.     IF((*S=NEWñLINE())==╬╒╠╠)
  217.      GOTO OUT;
  218.    ▌
  219.   ▌ WHILE(**S != CLASS);
  220.   ++(*S);
  221.  ▌
  222.  ELSE IF(ISDIGIT(**S)) █
  223.   DO █
  224.    CLASS=*(++(*S));
  225.    CLASS=LOWER(CLASS);  /* N.B. LOWER() MAY BE A MACRO */
  226.   ▌ WHILE(ISHEX(CLASS)▀▀CLASS=='X'▀▀CLASS=='L'▀▀CLASS=='.');
  227.   CLASS=╔╬╘┼╟┼╥;
  228.  ▌
  229.  ELSE CLASS=*(*S)++;
  230. OUT:
  231.  *T=┼╧╙;
  232.  RETURN(CLASS);
  233. ▌
  234.