home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_300 / 344_01 / p2s.l < prev    next >
Text File  |  1990-09-21  |  7KB  |  308 lines
  1. /*
  2. * File: P2S.L
  3. *
  4. * Program: 
  5. *                 P2S
  6. *
  7. *         printf() to streams i/o converter
  8. *
  9. * Description:
  10. *
  11. * Converts printf() calls to << operators
  12. * Uses Lex to find printf's, fprintf's and sprintf's in C source
  13. * and then uses p2s() call to convert the printf arguments to C++ streams
  14. * formatted I/O.
  15. * Does handle things like %6.2f (width and precision flags)
  16. * by generating the appropriate streams manipulators - setw()
  17. * and setprecision().
  18. * Does NOT handle things like %-6.2f (yet) since there are no manipulators
  19. * for left and right justification (if you decide to enhance this to
  20. * handle this or anything else please submit back to CUG or me)
  21. *
  22. * stdin reads inoriginal C source, converted source goes to stdout.
  23. *
  24. * Usage: 
  25. *
  26. * P2S < {.c file with printfs} > {file with streams i/o}
  27. * Options:
  28. *    f - don't convert fprintf()'s
  29. *    p - don't convert printf()'s
  30. *    s - don't convert sprintf()'s
  31. *    i - converts by doing 
  32. *        #ifdef __cplusplus
  33. *          ... streams code ..
  34. *        #else
  35. *          ... old printf code ...
  36. *        #endif
  37. *        to maintain backward compatibility with C (if desired)
  38. *
  39. * Example:
  40. *
  41. * For example to only convert fprintf calls and maintain C compatibility
  42. * the invocation is:
  43. *
  44. *     p2s p s i < foo.c >foo.cpp
  45. *         
  46. *    
  47. * Construction:
  48. *
  49. * Just flex (or lex) this file, and compile the resultant C source. 
  50. * MKP2S.BAT shows how to make program with Flex and Turbo C.
  51. *
  52. * Restrictions:
  53. * 
  54. * You may use this program without restriction as a tool in your own 
  55. * development efforts. 
  56. * You MAY NOT redistribute either the source or executables, in modified
  57. * or unmodified form, for any amount of money or along with any other 
  58. * commercial package. You must include this copyright in any program
  59. * which uses this source and you may not distribute such programs 
  60. * commercially. No restrictions apply to any programs which you converted
  61. * using this tool (using the tool is unrestricted, distributing it or using
  62. * its source is).
  63. * 
  64. * Copyright (c) 1990. Adam Blum, Retrieval Systems Corporation,(703)-524-4534
  65. */
  66.  
  67. %{
  68. #include<stdio.h>
  69. #include<ctype.h>
  70. /* prototypes */
  71. int p2s(char *s1,char *s2);
  72. char *prs(char *p,char *s);
  73. char *getfmt(char *p,int *prec,int *width);
  74. void strrepl(char *s,char *srch,char *repl);
  75.  
  76. #define QUOTE 34
  77.  
  78. /* variables */
  79. int ifdef=0,sprt=1,fprt=1,prt=1,i;
  80.  
  81. %}
  82.  
  83. %%
  84. /*        PATTERNS            */
  85.  
  86. #define.*\n    {ECHO;}
  87. printf\([^\;]*\)\; {
  88.         if(prt)
  89.             p2sprt(yytext,yyleng,yytext+7);
  90.         else {
  91.             ECHO;
  92.         }
  93.         return 1;}
  94. fprintf\([^\;]*\)\; {
  95.         if(fprt)
  96.             p2sprt(yytext,yyleng,yytext+8);
  97.         else{
  98.             ECHO;
  99.         }
  100.         return 1;}
  101.  
  102. sprintf\([^\;]*\)\; {
  103.         if(sprt)
  104.             p2sprt(yytext,yyleng,yytext+8);
  105.         else {
  106.             ECHO;
  107.         }
  108.         return 1;}
  109. .|\n    {ECHO;return 1;}
  110. %%
  111. /*        FUNCTIONS            */
  112. main(int argc,char **argv)
  113. {
  114.     for(i=0;i<argc;i++){
  115.         switch(toupper(argv[i][0])){
  116.         case 'I':ifdef=1;break;
  117.         case 'S':sprt=0;break;
  118.         case 'F':fprt=0;break;
  119.         case 'P':prt=0;break;
  120.         }
  121.     }        
  122.     fprintf(stderr,           
  123. "printf to C++ streams converter, (c) 1990, Adam Blum, Retrieval Systems Corp.\n");
  124.     fprintf(stderr,
  125. "Usage: p2s <{source with printf calls} >{output with streams operators}\n");
  126.     for(;;){
  127.         if(yylex()<1)break;
  128.     }
  129. }
  130.  
  131. ctparens(char *s,int n)
  132. {
  133.     int i,ct=0;
  134.     for(i=0;i<n;i++)    
  135.         if(s[i]=='(')
  136.             ct++;
  137.         else if(s[i]==')')
  138.             ct--;
  139.     return ct;
  140. }
  141.  
  142. /* P2SPRT
  143. * Print the converted strings
  144. */
  145. p2sprt(char *base,int n,char *s)
  146. {
  147.     char s1[256],s2[1024];
  148.     strncpy(s1,s,n);
  149.     s1[n]=0;
  150.     p2s(s1,s2);    
  151.     if(ifdef)
  152.         printf("\n#ifdef __cplusplus\n%s;\n#else\n%s\n#endif\n",s2,base);
  153.     else
  154.          printf("\n/* was %s*/\n%s;",base,s2);
  155. }
  156.  
  157.  
  158. /* P2S
  159. * Convert printf arguments to formatted streams I/O
  160. */
  161. p2s(char *s1,char *s2)
  162. {
  163.     char srch[16],arg[256],*p=s1;
  164.     int replno=0,width,prec,i;
  165.     /* grab the filename first, and pass it through
  166.      untranslated. streams opening and closing of
  167.      file will have to be translated manually */
  168.     for(;isspace(*p);p++)
  169.         ;
  170.     if(*p==QUOTE){
  171.         strcpy(s2,"cout\0");
  172.     }
  173.     else if(!strncmp(p,"stderr",6)){
  174.         strcpy(s2,"cerr\0");
  175.         /* read up to first quote mark for formatting string */
  176.         for(;*p!='"'&&*p;p++)
  177.             ;
  178.  
  179.     }
  180.     else{
  181.         p=prs(p,s2);
  182.         /* stream operator directed to file stream */
  183.         /* read up to first quote mark for formatting string */
  184.         for(;*p!='"'&&*p;p++)
  185.             ;
  186.     }
  187.     if(!*p)return 0; /* not really a printf call */
  188.     p++; /* skip over quote otherwise*/
  189.  
  190.  
  191.     for(;;){
  192.         /* read up to a formatting code (starts with "%")
  193.         but skip any "%%"s and treat them as single "%" */
  194.         for(    i=0;
  195.             (*p!='%'||*(p+1)=='%')    &&
  196.             (*p!=QUOTE||*(p-1)=='\\');
  197.             p++,i++
  198.         )
  199.         {
  200.             arg[i]=*p;
  201.             if(*p=='%'&&*(p+1)=='%')
  202.                 p++;
  203.         }
  204.         if(i){ /* if there is a literal */
  205.             arg[i]=0;
  206.             sprintf(s2+strlen(s2),"<<%c%s%c\0",QUOTE,arg,QUOTE);
  207.         }
  208.         if(*p=='%'){
  209.             p=getfmt(p,&width,&prec);
  210.             if(width>=0)
  211.                 sprintf(s2+strlen(s2),
  212.                     "<<setw(%d)",width);
  213.             if(prec>=0)
  214.                 sprintf(s2+strlen(s2),
  215.                     "<<setprecision(%d)",prec);
  216.             sprintf(s2+strlen(s2),"<<(_%d_)",replno++);
  217.         }
  218.         if(*p==QUOTE)break;
  219.     }
  220.  
  221.     /* read up to and beyond first comma before printf arguments */
  222.     for(;*p!=',';p++)
  223.         ;
  224.     p++;  /* skip over comma */
  225.  
  226.     replno=0;  /* set number back to create search and replace strings */
  227.     for(;;){
  228.         p=prs(p,arg);
  229.         sprintf(srch,"_%d_",replno++);
  230.         strrepl(s2,srch,arg);
  231.         if(*p==')'||!*p)break;
  232.     }
  233.     return 1;
  234. }
  235.  
  236.  
  237. /* GETFMT
  238. * extracts width and precision number from printf formatting code
  239. */
  240. char *getfmt(char *p,int *width,int *prec)
  241. {
  242.     char *period,*last;
  243.     if(*p++!='%')
  244.         return 0; /* wasnt even a formatting code */
  245.     /* find last char of fmt code (the alphabetic char) */
  246.     for(last=p;!isalpha(*last);last++)
  247.         ;
  248.     if(last==p){ /* if its the next one after %, no width or prec */
  249.         *prec=-1;
  250.         *width=-1;
  251.         return last+1; 
  252.     }
  253.     period=strchr(p,'.'); 
  254.     if(period==p) /* no width if . next to % */
  255.         *width=-1;
  256.     else          
  257.         *width=atoi(p);
  258.     *prec=period?atoi(period+1):-1; /* no precision if didnt find period */
  259.     return last+1;
  260. }
  261.  
  262. /*
  263. * PRS
  264. * Parse out field s from buffer pointed to by p, moving p to next field
  265. * field ends on comma, null, or right paren that ends the first left paren
  266. * scope in field, or is out of scope of any parens
  267. */
  268. char *prs(char *p,char *s)
  269. {
  270.     int i,parct=0;
  271.     for(i=0;*p!=','&&*p;p++,i++){
  272.         /* we are sensitive to paren nesting level:
  273.          * if we reach a right paren and we have seen as many or fewer
  274.                  * left parens so far, we have reached end of field 
  275.          */
  276.         if(*p=='(')parct++;
  277.         if(*p==')'){
  278.             if(--parct<0)break;
  279.         }
  280.         s[i]=*p;
  281.     }
  282.     s[i]=0;
  283.     if(!*p||p==')')return p;
  284.     p++;
  285.     return p;
  286. }
  287.  
  288. void strrepl(s,srch,repl)
  289. char *s,*srch,*repl;
  290. {
  291.     char near *found;
  292.     char temp[1024];int ofs;
  293.     for(;;){
  294.         found=(char near *)strstr(s,srch);
  295.         if(found){
  296.             ofs=(int)((char near *)found-(char near *)s);
  297.             strncpy(temp,s,ofs);
  298.             temp[ofs]=0;
  299.             strcat(temp,repl);
  300.             strcat(temp,s+ofs+strlen(srch));
  301.             strcpy(s,temp);
  302.         }
  303.         else
  304.             break;
  305.     }
  306. }
  307.  
  308.