home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / p / p2c.zip / P2C.C < prev    next >
C/C++ Source or Header  |  1987-03-27  |  11KB  |  417 lines
  1. /*----------------------------------------------------------------------
  2.   PAS2C.C  Version 1.1
  3.   Translate Pascal keywords and operators to C.
  4.   useage:  pas2c < pascal_source  > c_source
  5.     i.e., this is a filter program which filters out the Pascal.
  6.   By James A Mullens <jcm@ornl-msr.arpa>    29-Jan-87
  7.  
  8.   Revisions:
  9.     Version 1.1  17-Feb-87  Changed several keyword translations on the
  10.     advice of James R. Van Zandt <jrv@mitre-bedford.ARPA>.  Added many
  11.     more translations.  Added a source for function strcmpi for the
  12.     unfortunates who don't have this case-insensitive string comparison
  13.     in their C library.
  14.  
  15.     Dan Kegel     15 Mar 87    Made it work on Sun workstation.  Ripped out
  16.     translations that hurt translation of a large (20,000 line) Turbo program.
  17. ----------------------------------------------------------------------*/
  18.  
  19. #include <stdio.h>    /* standard I/O */
  20. #include <ctype.h>    /* character macros */
  21. #include <string.h>    /* string functions */
  22. #include "p2c.h"
  23. #include "ktypes.h"    /* keyword type definitions */
  24.  
  25. boolean WasSemi;    /* kludge to avoid duplicating semicolons */
  26.  
  27. /* Change these translations to fit your desires, but the Pascal names must 
  28.    be written in lower case and must be in alphabetical order.  If you include 
  29.    a C comment in your translation output as a HINT to the programmer, write 
  30.    it in CAPITALs, else write the comment in lower case, eh?
  31. */
  32.  
  33. wnode xlate[] = {
  34.   {T_ZIP,    "and",        "&&"    },
  35.   {T_ARRAY,    "array",    ""    },    /* see parseTypeDecl */
  36.   {T_BEGIN,    "begin",    "{"    },
  37.   {T_ZIP,    "boolean",    "boolean"},
  38.   {T_ZIP,    "byte",        "char"    },    /* Turbo */
  39.   {T_CASE,    "case",        "switch"},
  40.   {T_CONST,    "const",    "/* CONST */"},
  41.   {T_ZIP,    "div",        "/"    },
  42.   {T_ZIP,    "do",        ")"    },
  43.   {T_ZIP,    "downto",    ";/*DOWNTO*/"},
  44.   {T_ZIP,    "else",        "; else"},
  45.   {T_END,    "end",        "}"    },
  46.   {T_ZIP,    "false",    "FALSE"    },    
  47.   {T_FILE,    "file",        ""    },    /* see parseTypeDecl() */
  48.   {T_ZIP,    "for",        "for ("    },
  49.   {T_FORWARD,    "forward",    ""    },
  50.   {T_FUNC,    "function",    ""    },    /* see parseProcedure() */
  51.   {T_ZIP,    "if",        "if ("    },
  52.   {T_ZIP,    "implementation", "/* private (static) section */"},
  53.   {T_ZIP,    "input",    "stdin"    },
  54.   {T_ZIP,    "integer",    "int"    },
  55.   {T_ZIP,    "interface",    "/* exported symbol section */"},
  56.   {T_ZIP,    "ioresult",    "errno"    },    /* UCSD, Turbo */
  57.   {T_LABEL,    "label",    ""    },    /* see parseLabel() */
  58.   {T_ZIP,    "mod",        "%"    },
  59.   {T_ZIP,    "not",        "!"    },
  60.   {T_OF,    "of",        ""    },    /* see parseTypeDecl() */
  61.   {T_ZIP,    "or",        "||"    },
  62.   {T_ZIP,    "output",    "stdout"},
  63.   {T_ZIP,    "packed",    "/* PACKED */"},
  64.   {T_PROC,    "procedure",    "void"    },    /* see parseProcedure() */
  65.   {T_ZIP,    "program",    "main"    },
  66.   {T_ZIP,    "read",        "scanf"    },
  67.   {T_ZIP,    "readln",    "/*LINE*/scanf"},/* hint - read end-of-line */
  68.   {T_ZIP,    "real",        "double"},    /* or "float" */
  69.   {T_RECORD,    "record",    ""    },    /* see parseTypeDecl() */
  70.   {T_ZIP,    "repeat",    "do {"    },
  71.   {T_STRINGTYPE,"string",    ""    },    /* UCSD, Turbo string type */
  72.   {T_ZIP,    "text",        "FILE *"},    /* UCSD, Turbo file type */
  73.   {T_ZIP,    "then",        ")"    },
  74.   {T_ZIP,    "to",        ";"    },
  75.   {T_ZIP,    "true",        "TRUE"    },    
  76.   {T_TYPE,    "type",        ""    },    /* see parseType() */
  77.   {T_ZIP,    "until",    "} until ("},
  78.   {T_ZIP,    "uses",        "/* USES */\n#include"},
  79.   {T_VAR,    "var",        "/* VAR */"},    /* see parseProc, parseVar() */
  80.   {T_ZIP,    "while",    "while ("},
  81.   {T_ZIP,    "with",        "/* WITH */"},    /*hint-set pointer to struct*/
  82.   {T_ZIP,    "write",    "printf"},
  83.   {T_ZIP,    "writeln",    "/*LINE*/printf"},/* hint - write newline */
  84.   {T_ZIP,    "",        ""    }    /* marks end of xlate table */
  85. };
  86.  
  87. wnode theend = {T_ZIP,    "", ""};
  88.  
  89. wnode *hash[26];        /* quick index into the translation array */
  90.  
  91. /* Fill in the quick index ("hash") array 
  92. */
  93. void init_hash()
  94. {
  95.     int ch, cmp;
  96.     wnode *nptr = xlate;
  97.  
  98.     for (ch='a'; ch<='z'; ch++) {
  99.     while (nptr->pname[0] && (cmp = ch - *nptr->pname) > 0) 
  100.         nptr++;
  101.     hash[ch-'a'] = (cmp==0) ? nptr : &theend;
  102.     }
  103. }
  104.  
  105.  
  106. /* compare two strings without regard to case,
  107.    the equivalent of this function may already be in your C library 
  108.    Used to fail on Suns because it used tolower on lowercase chars...
  109.    Assumes second argument already lowercase.
  110. */
  111. int strcmpi(s1,s2)
  112.     register char *s1, *s2;
  113. { 
  114.     register char c1;
  115.  
  116.     while ((c1= *s1++) && *s2) {    /* get char, advance ptr */
  117.     if (isupper(c1)) c1 = tolower(c1);
  118.     if (c1 != *s2) break;
  119.     s2++;
  120.     }
  121.     return(c1 - *s2);
  122. }
  123.  
  124.  
  125. /* Pass an identifier through the translation table; return its
  126.    keyword type.  Translated keyword left in same buffer.
  127. */
  128. int
  129. translate(word)
  130.     register char *word;
  131. { 
  132.     register wnode *xptr;
  133.     int nomatch;
  134.     int c;
  135.  
  136.     c = *word;
  137.     if (isalpha(c)) {
  138.     if (isupper(c)) c=tolower(c);
  139.     xptr = hash[c - 'a'];
  140.     while ( xptr->pname[0] && (nomatch = strcmpi(word,xptr->pname)) > 0 ) 
  141.         xptr++;
  142.     if (!nomatch) {
  143.         word[0]=0;
  144.         if (!WasSemi && xptr->ktype == T_END)
  145.         strcpy(word, ";");
  146.         strcat(word, xptr->cname);
  147.         return(xptr->ktype);
  148.     }
  149.     }
  150.     return(T_ZIP);
  151. }
  152.  
  153. #define Q_NOQUOTE  1
  154. #define Q_ONEQUOTE 2
  155. #define Q_DONE     3
  156. #define Q_ERR      4
  157.  
  158. #define Q_C_ESCAPES  FALSE   /* Set true if your Pascal knows backslashes */
  159.  
  160. /*---- parseQuotedString -------------------------------------------------
  161. Accepts Pascal quoted string from stdin, converts to C quoted string, and 
  162. places in buf.
  163. Examples:
  164.   'hi' -> "hi"    'hi''' -> "hi'"  'hi''''' -> "hi''"
  165.   ''   -> ""      ''''   -> "'"    ''''''   -> "''"
  166.   ''hi' -> ERROR  '''hi' -> "'hi"  '''''hi' -> "''hi"
  167.   'I''m'  -> "I'm"
  168. Double quotes and backslashes are preceded with backslashes, except that
  169. if Q_C_ESCAPES is TRUE, backslashes are left naked.
  170. --------------------------------------------------------------------------*/
  171. void
  172. parseQuotedString(buf)
  173. char *buf;
  174. {
  175.     register char c;
  176.     register char *letter=buf;
  177.     int qstate;
  178.  
  179.     *letter++ = '"';
  180.     qstate = Q_NOQUOTE;
  181.     while (qstate < Q_DONE) {
  182.     switch (c=getchar()) {
  183.     case '\'':
  184.         switch (qstate) {
  185.         case Q_NOQUOTE:  
  186.         qstate = Q_ONEQUOTE; break;
  187.         case Q_ONEQUOTE: 
  188.         *letter++ = c; qstate = Q_NOQUOTE; break;
  189.         }
  190.         break;
  191.     case EOF:
  192.     case '\n':
  193.         qstate= (qstate==Q_ONEQUOTE) ? Q_DONE : Q_ERR;
  194.         ungetc(c,stdin);
  195.         break;
  196.     default:
  197.         switch (qstate) {
  198.         case Q_ONEQUOTE: 
  199.         ungetc(c,stdin); qstate = Q_DONE; break;
  200.         case Q_NOQUOTE:
  201.         if (c=='\\' && !Q_C_ESCAPES) *letter++ = c;
  202.         if (c=='"') *letter++ = '\\';
  203.         *letter++ = c; 
  204.         break; 
  205.         }
  206.     }
  207.     }
  208.     *letter++ = '"';
  209.     *letter++ = '\0';
  210.     if (qstate == Q_ERR) {
  211.     fprintf(stderr,"Newline in string constant: %s\n",buf);
  212.     fprintf(stdout," %c*** \\n IN STRING ***%c ",
  213.         '/', buf, '/');
  214.     }
  215. }
  216.  
  217. void
  218. getTok()
  219. {
  220.     register char *letter = cTok.str;
  221.     register char *sEnd = letter + MAXTOKLEN-3;
  222.     register int c;
  223.  
  224.     c = getchar();
  225.     if (isalnum(c)) {
  226.     while (c != EOF && isalnum(c)) {
  227.         *letter++ = c;
  228.         c = getchar();
  229.     }
  230.     ungetc(c,stdin);
  231.     *letter++ = 0;
  232.     cTok.kind = translate(cTok.str);
  233.     } else {
  234.     switch(c) {
  235.     case '\n':    /* newline */
  236.     case 0x20:    /* space */
  237.     case 0x9:    /* tab */
  238.         do        /* Gather a string of blank space into one token */
  239.         *letter++ = c;
  240.         while ((c=getchar()) != EOF && isspace(c));
  241.         ungetc(c, stdin);
  242.         *letter++ = '\0';
  243.         cTok.kind = T_SPACE;
  244.         break;
  245.     case '\'':                 /* Quoted String */
  246.         parseQuotedString(cTok.str);
  247.         cTok.kind = T_STRING;
  248.         break;
  249.     case '{' :                 /* Curly Comment */
  250.         *letter++='/'; 
  251.         *letter++='*';
  252.         while ((c=getchar()) != EOF && c!='}' && letter!=sEnd)
  253.         *letter++ = c;
  254.         if (letter == sEnd) {
  255.         printf("/***ERROR: Comment too long (sorry) ***/");
  256.         while ((c=getchar()) != EOF && c!='}')
  257.             ;
  258.         }
  259.         strcpy(letter, "*/");
  260.         cTok.kind = T_COMMENT;
  261.         break;
  262.     case '(' : 
  263.         if ((c=getchar())!='*') {        /* Parenthesis */
  264.         ungetc(c,stdin);
  265.         strcpy(letter, "(");
  266.         cTok.kind = T_LPAREN;
  267.         } else {
  268.         register int lastc = '\0';    /* (* Comment *) */
  269.         *letter++='/'; 
  270.         *letter++='*';
  271.         while ((c=getchar())!=EOF && !(c==')' && lastc == '*') && 
  272.             letter != sEnd) {
  273.             lastc = c;
  274.             *letter++ = c;
  275.         }
  276.         if (letter == sEnd) {
  277.             printf("/***ERROR: Comment too long (sorry) ***/");
  278.             while ((c=getchar())!=EOF && !(c==')' && lastc == '*'))
  279.             lastc = c;
  280.         }
  281.         strcpy(letter, "/");        /* * already there! */
  282.         cTok.kind = T_COMMENT;
  283.         }
  284.         break;
  285.     case ')' :
  286.         strcpy(letter, ")");
  287.         cTok.kind = T_RPAREN;
  288.         break;
  289.     case ':' : 
  290.         if ((c=getchar())=='=') {        /* Assignment */
  291.         strcpy(letter, "=");
  292.         cTok.kind = T_ASSIGN;
  293.         } else {                /* Colon */
  294.         ungetc(c,stdin);
  295.         strcpy(letter, ":");
  296.         cTok.kind = T_COLON;
  297.         }
  298.         break;
  299.     case '=':
  300.         strcpy(letter, "==");        /* Might be equality test...*/
  301.         cTok.kind = T_EQUALS;        /* depends on parse state */
  302.         break;
  303.     case '<' : 
  304.         switch (c=getchar()) {
  305.         case '>':  
  306.         strcpy(letter, "!=");
  307.         break;
  308.         case '=':  
  309.         strcpy(letter, "<=");
  310.         break;
  311.         default :  
  312.         ungetc(c,stdin);
  313.         strcpy(letter,"<");
  314.         }
  315.         cTok.kind = T_COMPARE;
  316.         break;
  317.     case '>' : 
  318.         if ((c=getchar()) == '=')
  319.         strcpy(letter, ">=");
  320.         else {
  321.         ungetc(c,stdin);
  322.         strcpy(letter, ">");
  323.         }
  324.         cTok.kind = T_COMPARE;
  325.         break;
  326.     case '^' :
  327.         if ((c=getchar()) == '.') {    /* perhaps we should skip blanks? */
  328.         strcpy(letter, "->");
  329.         cTok.kind = T_STRUCTMEMBER;
  330.         } else {
  331.         ungetc(c,stdin);
  332.         strcpy(letter, "[0]");    /* '*' would have to go in front */
  333.         cTok.kind = T_DEREF;
  334.         }
  335.         break;
  336.     case '$' :            /* Turbo Pascal extension */ 
  337.         strcpy(letter, "0x");
  338.         cTok.kind = T_ZIP;
  339.         break;
  340.     case ';' :             /* Semicolon- translation depends on */
  341.         strcpy(letter, ";");    /* parse state... */
  342.         cTok.kind = T_SEMI;
  343.         break;
  344.     case '.':
  345.         if ((c=getchar()) == '.') {
  346.         cTok.kind = T_RANGE;
  347.         letter[0]=0;
  348.         } else {
  349.         ungetc(c,stdin);
  350.         strcpy(letter, ".");
  351.         cTok.kind = T_ZIP;
  352.         }
  353.         break;
  354.     case '[':
  355.         *letter++ = c; *letter = '\0';
  356.         cTok.kind = T_LBRACKET;
  357.         break;
  358.     case ']':
  359.         *letter++ = c; *letter = '\0';
  360.         cTok.kind = T_RBRACKET;
  361.         break;
  362.     case ',':
  363.         *letter++ = c; *letter = '\0';
  364.         cTok.kind = T_COMMA;
  365.         break;
  366.     case EOF:            /* end of file */
  367.         cTok.kind = T_EOF;
  368.         break;
  369.     default: 
  370.         *letter++ = c;        /* Pass unknown chars thru as tokens */
  371.         *letter = '\0';
  372.         cTok.kind = T_ZIP;
  373.     }
  374.     }
  375. }
  376.  
  377. main(argc, argv)
  378. int argc;
  379. char **argv;
  380. {
  381.     int debug;
  382.     
  383.     debug = (argc > 1);
  384.     init_hash();
  385.     WasSemi = FALSE;
  386.  
  387.     getTok(); 
  388.     do {
  389.     switch(cTok.kind) {
  390.     case T_VAR:
  391.         parseVar();
  392.         break;
  393.     case T_PROC:
  394.     case T_FUNC:
  395.         parseProcedure();
  396.         break;
  397.     case T_LABEL:
  398.         parseLabel();
  399.         break;
  400.     case T_TYPE:
  401.         parseType();
  402.         break;
  403.     default:
  404.         if (debug)
  405.         printf("'%s' %d\n", cTok.str, cTok.kind);
  406.         else {    /* fancy stuff to avoid duplicating semicolons */
  407.         if (cTok.kind != T_SEMI || !WasSemi)
  408.             fputs(cTok.str, stdout);
  409.         if (cTok.kind != T_SPACE && cTok.kind != T_COMMENT)
  410.             WasSemi = (cTok.kind == T_SEMI);
  411.         }
  412.         getTok();
  413.     }
  414.     } while (cTok.kind != T_EOF);
  415. }
  416.  
  417.