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