home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 379b.lha / p2c_v1.13a / examples / c / cref.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-03  |  7.4 KB  |  434 lines
  1. /* Output from p2c, the Pascal-to-C translator */
  2. /* From input file "dist/examples/cref.p" */
  3.  
  4.  
  5. #include <p2c/p2c.h>
  6.  
  7.  
  8. /*  linesperpage = 139;  */
  9.  
  10. #define maxnamelen      30
  11.  
  12.  
  13. #define k_normal        0
  14. #define k_proc          1
  15. #define k_var           2
  16. #define k_const         3
  17. #define k_type          4
  18. #define k_strlit        5
  19. #define k_extproc       6
  20. #define k_kw            7
  21. #define k_prockw        8
  22. #define k_varkw         9
  23. #define k_constkw       10
  24. #define k_typekw        11
  25. #define k_beginkw       12
  26.  
  27. typedef struct occur {
  28.   struct occur *next;
  29.   long lnum, fnum;
  30.   boolean defn;
  31. } occur;
  32.  
  33.  
  34. typedef struct node {
  35.   struct node *left, *right;
  36.   Char name[maxnamelen + 1];
  37.   occur *first;
  38.   short kind;
  39. } node;
  40.  
  41.  
  42. Static FILE *f;
  43. Static Char fn[121];
  44. Static long fnum;
  45. Static Char buf[256], name[256];
  46. Static boolean good;
  47. Static long i, j, lnum;
  48. Static node *np, *base;
  49. Static occur *op;
  50. Static short curkind, section;
  51. Static long paren, brace;
  52.  
  53.  
  54.  
  55. Static Void lookup(name, np)
  56. Char *name;
  57. node **np;
  58. {
  59.   node **npp;
  60.  
  61.   if (strlen(name) > maxnamelen)
  62.     name[maxnamelen] = '\0';
  63.   npp = &base;
  64.   while (*npp != NULL && strcmp((*npp)->name, name)) {
  65.     if (strcmp(name, (*npp)->name) < 0)
  66.       npp = &(*npp)->left;
  67.     else
  68.       npp = &(*npp)->right;
  69.   }
  70.   if (*npp != NULL) {
  71.     *np = *npp;
  72.     return;
  73.   }
  74.   *np = (node *)Malloc(sizeof(node));
  75.   *npp = *np;
  76.   strcpy((*np)->name, name);
  77.   (*np)->first = NULL;
  78.   (*np)->left = NULL;
  79.   (*np)->right = NULL;
  80.   (*np)->kind = k_normal;
  81. }
  82.  
  83.  
  84. Static Void kw(name_, kind)
  85. Char *name_;
  86. short kind;
  87. {
  88.   Char name[256];
  89.   node *np;
  90.  
  91.   strcpy(name, name_);
  92.   lookup(name, &np);
  93.   np->kind = kind;
  94. }
  95.  
  96.  
  97. Static Void cref(np, kind)
  98. node *np;
  99. short kind;
  100. {
  101.   occur *op;
  102.  
  103.   op = (occur *)Malloc(sizeof(occur));
  104.   op->next = np->first;
  105.   np->first = op;
  106.   op->lnum = lnum;
  107.   op->fnum = fnum;
  108.   op->defn = (((1L << ((long)kind)) &
  109.            ((1L << ((long)k_var)) | (1L << ((long)k_type)) |
  110.         (1L << ((long)k_const)) | (1L << ((long)k_proc)))) != 0);
  111.   if (op->defn || kind == k_strlit || (kind == k_extproc && np->kind == k_normal))
  112.     np->kind = kind;
  113. }
  114.  
  115.  
  116.  
  117. Static Void traverse(np)
  118. node *np;
  119. {
  120.   occur *op;
  121.   long i;
  122.  
  123.   if (np == NULL)
  124.     return;
  125.   traverse(np->left);
  126.   if ((long)np->kind < (long)k_kw) {
  127.     switch (np->kind) {
  128.  
  129.     case k_var:
  130.       fprintf(f, "V:");
  131.       break;
  132.  
  133.     case k_type:
  134.       fprintf(f, "T:");
  135.       break;
  136.  
  137.     case k_const:
  138.       fprintf(f, "C:");
  139.       break;
  140.  
  141.     case k_proc:
  142.       fprintf(f, "P:");
  143.       break;
  144.  
  145.     case k_strlit:
  146.       fprintf(f, "S:");
  147.       break;
  148.  
  149.     case k_extproc:
  150.       fprintf(f, "E:");
  151.       break;
  152.  
  153.     case k_normal:
  154.       fprintf(f, "X:");
  155.       break;
  156.     }
  157.     fputs(np->name, f);
  158.     i = 0;
  159.     op = np->first;
  160.     while (op != NULL) {
  161.       if (i == 0) {
  162.     fprintf(f, "\n   ");
  163.     i = 5;
  164.       }
  165.       fprintf(f, " %ld/%ld", op->lnum, op->fnum);
  166.       if (op->defn)
  167.     putc('*', f);
  168.       i--;
  169.       op = op->next;
  170.     }
  171.     putc('\n', f);
  172.   }
  173.   traverse(np->right);
  174. }
  175.  
  176.  
  177.  
  178. main(argc, argv)
  179. int argc;
  180. Char *argv[];
  181. {
  182.   Char STR1[256];
  183.   Char *TEMP;
  184.   long FORLIM;
  185.  
  186.   PASCAL_MAIN(argc, argv);
  187.   f = NULL;
  188.   base = NULL;
  189.   fnum = 0;
  190.   kw("procedure", k_prockw);
  191.   kw("function", k_prockw);
  192.   kw("var", k_varkw);
  193.   kw("record", k_varkw);
  194.   kw("type", k_typekw);
  195.   kw("const", k_constkw);
  196.   kw("begin", k_beginkw);
  197.   kw("end", k_kw);
  198.   kw("do", k_kw);
  199.   kw("for", k_kw);
  200.   kw("to", k_kw);
  201.   kw("while", k_kw);
  202.   kw("repeat", k_kw);
  203.   kw("until", k_kw);
  204.   kw("if", k_kw);
  205.   kw("then", k_kw);
  206.   kw("else", k_kw);
  207.   kw("case", k_kw);
  208.   kw("of", k_kw);
  209.   kw("div", k_kw);
  210.   kw("mod", k_kw);
  211.   kw("nil", k_kw);
  212.   kw("not", k_kw);
  213.   kw("and", k_kw);
  214.   kw("or", k_kw);
  215.   kw("with", k_kw);
  216.   kw("array", k_kw);
  217.   kw("integer", k_kw);
  218.   kw("char", k_kw);
  219.   kw("boolean", k_kw);
  220.   kw("true", k_kw);
  221.   kw("false", k_kw);
  222.   printf("\nPascal Cross Reference Utility\n\n");
  223.   do {
  224.     fnum++;
  225.     printf("Name of cross-reference file #%ld? ", fnum);
  226.     fgets(fn, 121, stdin);
  227.     TEMP = strchr(fn, '\n');
  228.     if (TEMP != NULL)
  229.       *TEMP = 0;
  230.     good = true;
  231.     if (*fn != '\0') {
  232.       TRY(try1);
  233.     if (f != NULL)
  234.       f = freopen(fn, "r", f);
  235.     else
  236.       f = fopen(fn, "r");
  237.     if (f == NULL) {
  238.       P_escapecode = -10;
  239.       P_ioresult = FileNotFound;
  240.       goto _Ltry1;
  241.     }
  242.       RECOVER2(try1,_Ltry1);
  243.     if (P_escapecode != -10)
  244.       _Escape(P_escapecode);
  245.     good = false;
  246.     printf("Can't read file!\n");
  247.       ENDTRY(try1);
  248.     } else
  249.       good = false;
  250.     if (good) {
  251.       lnum = 0;
  252.       section = k_normal;
  253.       curkind = k_normal;
  254.       paren = 0;
  255.       while (!P_eof(f)) {
  256.     lnum++;
  257.     fgets(buf, 256, f);
  258.     TEMP = strchr(buf, '\n');
  259.     if (TEMP != NULL)
  260.       *TEMP = 0;
  261. /* p2c: dist/examples/cref.p, line 228:
  262.  * Note: Null character at end of sprintf control string [148] */
  263.     strcpy(STR1, buf);
  264.     strcpy(buf, STR1);
  265.     i = 1;
  266.     while (buf[i - 1] == ' ')
  267.       i++;
  268.     do {
  269.       while (!(buf[i - 1] == '\0' || buf[i - 1] == '_' ||
  270.            isalnum(buf[i - 1]))) {
  271.         switch (buf[i - 1]) {
  272.  
  273.         case ':':
  274.         case '=':
  275.           if (brace == 0)
  276.         curkind = k_normal;
  277.           break;
  278.  
  279.         case ';':
  280.           if (brace == 0)
  281.         curkind = section;
  282.           break;
  283.  
  284.         case '\'':
  285.           if (brace == 0) {
  286.         i++;
  287.         j = i;
  288.         while ((buf[i - 1] != '\'' || buf[i] == '\'') &&
  289.                buf[i - 1] != '\0') {
  290.           if (buf[i - 1] == '\'')
  291.             i += 2;
  292.           else
  293.             i++;
  294.         }
  295.         if (buf[i - 1] == '\0')
  296.           i--;
  297.         sprintf(name, "'%.*s'", (int)(i - j), buf + j - 1);
  298.         lookup(name, &np);
  299.         cref(np, k_strlit);
  300.           }
  301.           break;
  302.  
  303.         case '(':
  304.           if (brace == 0) {
  305.         if (buf[i] == '*') {
  306.           brace = 1;
  307.           i++;
  308.         } else {
  309.           paren++;
  310.           curkind = k_normal;
  311.         }
  312.           }
  313.           break;
  314.  
  315.         case ')':
  316.           if (brace == 0)
  317.         paren--;
  318.           break;
  319.  
  320.         case '*':
  321.           if (buf[i] == ')') {
  322.         brace = 0;
  323.         i++;
  324.           }
  325.           break;
  326.  
  327.         case '{':
  328.           brace = 1;
  329.           break;
  330.  
  331.         case '}':
  332.           brace = 0;
  333.           break;
  334.         }
  335.         i++;
  336.       }
  337.       if (buf[i - 1] != '\0') {
  338.         j = i;
  339.         if (isdigit(buf[i - 1]) && i > 1 && buf[i - 2] == '-')
  340.           j--;
  341.         while (buf[i - 1] == '_' || isalnum(buf[i - 1]))
  342.           i++;
  343.         if (brace == 0) {
  344.           sprintf(name, "%.*s", (int)(i - j), buf + j - 1);
  345.           FORLIM = strlen(name);
  346.           for (j = 1; j <= FORLIM; j++) {
  347.         if (isupper(buf[j - 1]))
  348.           buf[j - 1] += 32;
  349.           }
  350.           while (buf[i - 1] == ' ')
  351.         i++;
  352.           lookup(name, &np);
  353.           switch (np->kind) {
  354.  
  355.           case k_varkw:
  356.         if (paren == 0) {
  357.           section = k_var;
  358.           curkind = section;
  359.         }
  360.         break;
  361.  
  362.           case k_typekw:
  363.         section = k_type;
  364.         curkind = section;
  365.         break;
  366.  
  367.           case k_constkw:
  368.         section = k_const;
  369.         curkind = section;
  370.         break;
  371.  
  372.           case k_prockw:
  373.         section = k_normal;
  374.         curkind = k_proc;
  375.         break;
  376.  
  377.           case k_beginkw:
  378.         section = k_normal;
  379.         curkind = k_normal;
  380.         break;
  381.  
  382.           case k_kw:
  383.         /* blank case */
  384.         break;
  385.  
  386.           default:
  387.         if (curkind == k_normal && buf[i - 1] == '(')
  388.           cref(np, k_extproc);
  389.         else
  390.           cref(np, curkind);
  391.         break;
  392.           }
  393.         }
  394.       }
  395.     } while (buf[i - 1] != '\0');
  396.       }
  397.       if (paren != 0)
  398.     printf("Warning: ending paren count = %ld\n", paren);
  399.       if (f != NULL)
  400.     fclose(f);
  401.       f = NULL;
  402.     }
  403.   } while (*fn != '\0');
  404.   putchar('\n');
  405.   do {
  406.     printf("Output file name: ");
  407.     fgets(fn, 121, stdin);
  408.     TEMP = strchr(fn, '\n');
  409.     if (TEMP != NULL)
  410.       *TEMP = 0;
  411.   } while (*fn == '\0');
  412.   if (f != NULL)
  413.     f = freopen(fn, "w", f);
  414.   else
  415.     f = fopen(fn, "w");
  416.   if (f == NULL)
  417.     _EscIO(FileNotFound);
  418.   traverse(base);
  419.   if (f != NULL)
  420.     fclose(f);
  421.   f = NULL;
  422.   if (f != NULL)
  423.     fclose(f);
  424.   exit(0);
  425. }
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433. /* End. */
  434.