home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume34 / cproto / patch05 / patch5
Encoding:
Text File  |  1992-11-29  |  48.7 KB  |  1,849 lines
  1. diff  -c2 old/CHANGES new/CHANGES
  2. *** old/CHANGES    Wed Jun 10 21:03:00 1992
  3. --- new/CHANGES    Sat Nov 28 23:18:24 1992
  4. ***************
  5. *** 1,4 ****
  6. --- 1,46 ----
  7.   Version 3
  8.   
  9. + Patchlevel 5
  10. + 
  11. + - Fix: The -v option did not output declarations for function pointers.
  12. + - Fix: String literals continued over more than one line messed up the
  13. +   line number count.
  14. + - Fix: The program generated incorrect prototypes for functions that take
  15. +   a variable argument list using <varargs.h>.
  16. + - Fix: When converting functions from the standard input, cproto generated
  17. +   no output if no functions needed to be converted.
  18. + - Fix: Now does not output a warning if an untagged struct is found in a
  19. +   typedef declaration.
  20. + - Added the -b option which rewrites function definition heads to
  21. +   include both old style and new style declarations separated by a
  22. +   conditional compilation directive.  For example, the program can
  23. +   generate
  24. + 
  25. +     #ifdef ANSI_FUNC
  26. + 
  27. +     int
  28. +     main (int argc, char *argv[])
  29. +     #else
  30. + 
  31. +     int
  32. +     main (argc, argv)
  33. +     int argc;
  34. +     char *argv[]
  35. +     #endif
  36. +     {
  37. +     }
  38. + 
  39. +   Added the -B option to set the preprocessor directive that appears
  40. +   at the beginning of such definitions.
  41. + - Added the keyword "interrupt" to the set of type qualifiers when compiled
  42. +   on a UNIX system.
  43. + - The MS-DOS version now recognizes the type modifiers introduced by
  44. +   Microsoft C/C++ 7.00.
  45. + - Now recognizes ANSI C trigraphs (yuck!).
  46. + - Now use "#if __STDC__" instead of "#if defined(__STDC__)".
  47. + - GNU bison orders the y.tab.c sections differently than yacc, which
  48. +   resulted in references to variables before they were declared.  The
  49. +   grammar specification was modified to also be compatible with bison.
  50. + 
  51.   Patchlevel 4
  52.   
  53. ***************
  54. *** 7,11 ****
  55.     For example, for the definition
  56.   
  57. !       typedef char *caddr_t;
  58.   
  59.       int strlen (s)
  60. --- 49,53 ----
  61.     For example, for the definition
  62.   
  63. !     typedef char *caddr_t;
  64.   
  65.       int strlen (s)
  66. ***************
  67. *** 16,20 ****
  68.     cproto generated the incorrect prototype
  69.   
  70. !       int strlen(int s);
  71.   
  72.   - Added implementation of the ANSI function tmpfile() for systems that
  73. --- 58,62 ----
  74.     cproto generated the incorrect prototype
  75.   
  76. !     int strlen(int s);
  77.   
  78.   - Added implementation of the ANSI function tmpfile() for systems that
  79. ***************
  80. *** 64,68 ****
  81.     For example, for the definition
  82.   
  83. !       typedef unsigned short ushort;
  84.   
  85.       void test (x)
  86. --- 106,110 ----
  87.     For example, for the definition
  88.   
  89. !     typedef unsigned short ushort;
  90.   
  91.       void test (x)
  92. ***************
  93. *** 73,81 ****
  94.     cproto generated the incorrect prototype
  95.   
  96. !       void test(ushort x);
  97.   
  98.     while the correct one is
  99.   
  100. !       void test(int x);
  101.   
  102.   - Fix: Incorrect prototypes were generated for functions that returned
  103. --- 115,123 ----
  104.     cproto generated the incorrect prototype
  105.   
  106. !     void test(ushort x);
  107.   
  108.     while the correct one is
  109.   
  110. !     void test(int x);
  111.   
  112.   - Fix: Incorrect prototypes were generated for functions that returned
  113. diff  -c2 old/config.h new/config.h
  114. *** old/config.h    Fri Jul 03 13:37:52 1992
  115. --- new/config.h    Sat Nov 28 23:27:44 1992
  116. ***************
  117. *** 1,3 ****
  118. ! /* $Id: config.h 3.4 92/07/03 13:37:48 cthuang Exp $
  119.    *
  120.    * cproto configuration and system dependencies
  121. --- 1,3 ----
  122. ! /* $Id: config.h 3.5 1992/11/29 04:27:30 cthuang Exp $
  123.    *
  124.    * cproto configuration and system dependencies
  125. ***************
  126. *** 43,47 ****
  127.   #endif
  128.   
  129. ! #if defined(__STDC__) || defined(MSDOS)
  130.   #include <stdlib.h>
  131.   #include <string.h>
  132. --- 43,47 ----
  133.   #endif
  134.   
  135. ! #if __STDC__ || defined(MSDOS)
  136.   #include <stdlib.h>
  137.   #include <string.h>
  138. diff  -c2 old/cproto.1 new/cproto.1
  139. *** old/cproto.1    Wed Jun 10 21:03:02 1992
  140. --- new/cproto.1    Sat Nov 28 23:34:08 1992
  141. ***************
  142. *** 1,3 ****
  143. ! .\" $Id: cproto.1 3.6 92/06/10 20:55:39 cthuang Exp $
  144.   .\"
  145.   .de EX        \"Begin example
  146. --- 1,3 ----
  147. ! .\" $Id: cproto.1 3.7 1992/11/29 04:34:05 cthuang Exp $
  148.   .\"
  149.   .de EX        \"Begin example
  150. ***************
  151. *** 14,18 ****
  152.   .if t .sp .5
  153.   ..
  154. ! .TH CPROTO 1 "April 7, 1992"
  155.   .SH NAME
  156.   cproto \- generate C function prototypes and convert function definitions
  157. --- 14,18 ----
  158.   .if t .sp .5
  159.   ..
  160. ! .TH CPROTO 1 "October 24, 1992"
  161.   .SH NAME
  162.   cproto \- generate C function prototypes and convert function definitions
  163. ***************
  164. *** 31,35 ****
  165.   Optionally,
  166.   .B cproto
  167. ! also outputs declarations for any variables defined in the file.
  168.   If no
  169.   .I file
  170. --- 31,35 ----
  171.   Optionally,
  172.   .B cproto
  173. ! also outputs declarations for variables defined in the files.
  174.   If no
  175.   .I file
  176. ***************
  177. *** 88,98 ****
  178.   .SH OPTIONS
  179.   .TP
  180. - .B \-a
  181. - Convert function definitions from the old style to the ANSI C style.
  182. - .TP
  183.   .B \-e
  184.   Output the keyword
  185.   .B extern
  186. ! in front of every declaration having global scope.
  187.   .TP
  188.   .BI \-f n
  189. --- 88,95 ----
  190.   .SH OPTIONS
  191.   .TP
  192.   .B \-e
  193.   Output the keyword
  194.   .B extern
  195. ! in front of every generated prototype or declaration that has global scope.
  196.   .TP
  197.   .BI \-f n
  198. ***************
  199. *** 169,177 ****
  200.   declarations as well.
  201.   .TP
  202.   .B \-t
  203.   Convert function definitions from the ANSI C style to the traditional style.
  204.   .TP
  205. ! .B \-v
  206. ! Also output declarations for variables defined in the source.
  207.   .LP
  208.   .nf
  209. --- 166,205 ----
  210.   declarations as well.
  211.   .TP
  212. + .B \-v
  213. + Also output declarations for variables defined in the source.
  214. + .TP
  215. + .B \-a
  216. + Convert function definitions from the old style to the ANSI C style.
  217. + .TP
  218.   .B \-t
  219.   Convert function definitions from the ANSI C style to the traditional style.
  220.   .TP
  221. ! .B \-b
  222. ! Rewrite function definition heads to include both old style and new style
  223. ! declarations separated by a conditional compilation directive.
  224. ! For example, the program can generate this function definition:
  225. ! .EX
  226. ! #ifdef ANSI_FUNC
  227. ! 
  228. ! int
  229. ! main (int argc, char *argv[])
  230. ! #else
  231. ! 
  232. ! int
  233. ! main (argc, argv)
  234. ! int argc;
  235. ! char *argv[]
  236. ! #endif
  237. ! {
  238. ! }
  239. ! .EE
  240. ! .TP
  241. ! .BI \-B directive
  242. ! Set the conditional compilation directive to output at the beginning of
  243. ! function definitions generated by the \-b option.
  244. ! The default is
  245. ! .EX
  246. ! #ifdef ANSI_FUNC
  247. ! .EE 
  248.   .LP
  249.   .nf
  250. ***************
  251. *** 185,189 ****
  252.   The format is specified by a template in the form
  253.   .EX
  254. ! " int main ( a, b )"
  255.   .EE
  256.   but you may replace each space in this string with any number of
  257. --- 213,217 ----
  258.   The format is specified by a template in the form
  259.   .EX
  260. ! " int f ( a, b )"
  261.   .EE
  262.   but you may replace each space in this string with any number of
  263. ***************
  264. *** 191,195 ****
  265.   For example, the option
  266.   .EX
  267. ! -F"int main(\\n\\ta,\\n\\tb\\n\\t)"
  268.   .EE
  269.   will produce
  270. --- 219,223 ----
  271.   For example, the option
  272.   .EX
  273. ! -F"int f(\\n\\ta,\\n\\tb\\n\\t)"
  274.   .EE
  275.   will produce
  276. ***************
  277. *** 201,205 ****
  278.   .EE
  279.   .TP
  280. ! .BI \-D name\[=value\]
  281.   This option is passed through to the preprocessor and is used to define 
  282.   symbols for use with conditionals such as
  283. --- 229,233 ----
  284.   .EE
  285.   .TP
  286. ! .BI \-D name[=value]
  287.   This option is passed through to the preprocessor and is used to define 
  288.   symbols for use with conditionals such as
  289. diff  -c2 old/cproto.c new/cproto.c
  290. *** old/cproto.c    Wed Jun 10 21:03:08 1992
  291. --- new/cproto.c    Sat Nov 28 23:27:52 1992
  292. ***************
  293. *** 1,3 ****
  294. ! /* $Id: cproto.c 3.6 92/06/10 20:56:26 cthuang Exp $
  295.    *
  296.    * C function prototype generator and function definition converter
  297. --- 1,3 ----
  298. ! /* $Id: cproto.c 3.7 1992/11/29 04:27:49 cthuang Exp $
  299.    *
  300.    * C function prototype generator and function definition converter
  301. ***************
  302. *** 4,8 ****
  303.    */
  304.   #ifndef lint
  305. ! static char rcsid[] = "$Id: cproto.c 3.6 92/06/10 20:56:26 cthuang Exp $";
  306.   #endif
  307.   #include <stdio.h>
  308. --- 4,8 ----
  309.    */
  310.   #ifndef lint
  311. ! static char rcsid[] = "$Id: cproto.c 3.7 1992/11/29 04:27:49 cthuang Exp $";
  312.   #endif
  313.   #include <stdio.h>
  314. ***************
  315. *** 48,51 ****
  316. --- 48,54 ----
  317.   boolean proto_comments = TRUE;
  318.   
  319. + /* Conditional compilation directive output in front of function definitions */
  320. + char *func_directive = "#ifdef ANSI_FUNC";
  321. + 
  322.   /* Output formats for function declarators */
  323.   FuncFormat fmt[] = {
  324. ***************
  325. *** 111,115 ****
  326.   put_error ()
  327.   {
  328. !     fprintf(stderr, "\"%s\", line %d: ", cur_file_name(), cur_line_num());
  329.   }
  330.   
  331. --- 114,118 ----
  332.   put_error ()
  333.   {
  334. !     fprintf(stderr, "\"%s\", line %u: ", cur_file_name(), cur_line_num());
  335.   }
  336.   
  337. ***************
  338. *** 226,255 ****
  339.       fprintf(stderr, "usage: %s [ option ... ] [ file ... ]\n", progname);
  340.       fputs("Options:\n", stderr);
  341. !     fputs("  -a       Convert function definitions to ANSI style\n", stderr);
  342. !     fputs("  -c       Omit comments in generated prototypes\n", stderr);
  343. !     fputs("  -e       Output \"extern\" keyword before global declarations\n",
  344. !     stderr);
  345. !     fputs("  -f n     Set function prototype style (0 to 4)\n", stderr);
  346. !     fputs("  -p       Disable formal parameter promotion\n", stderr);
  347. !     fputs("  -q       Disable include file read failure messages\n", stderr);
  348. !     fputs("  -s       Output static declarations\n", stderr);
  349. !     fputs("  -t       Convert function definitions to traditional style\n",
  350. !     stderr);
  351. !     fputs("  -v       Output variable declarations\n", stderr);
  352. !     fputs("  -m name  Set name of prototype macro\n", stderr);
  353. !     fputs("  -d       Omit prototype macro definition\n", stderr);
  354. !     fputs("  -P fmt   Set prototype format template \" int main (a, b)\"\n",
  355. !     stderr);
  356. !     fputs("  -F fmt   Set function definition format template \" int main (a, b)\"\n",
  357. !     stderr);
  358. !     fputs("  -C fmt   Set format for function definition with parameter comments\n",
  359. !     stderr);
  360. !     fputs("  -D name[=value]\n", stderr);
  361. !     fputs("  -U name\n", stderr);
  362. !     fputs("  -I directory\n", stderr);
  363. !     fputs("           Set C preprocessor options\n", stderr);
  364. !     fputs("  -E cpp   Run specified C preprocessor command\n", stderr);
  365. !     fputs("  -E 0     Do not run any C preprocessor\n", stderr);
  366. !     fputs("  -V       Print version information\n", stderr);
  367.       exit(1);
  368.   }
  369. --- 229,252 ----
  370.       fprintf(stderr, "usage: %s [ option ... ] [ file ... ]\n", progname);
  371.       fputs("Options:\n", stderr);
  372. !     fputs("  -a, -t           Convert function definitions to ANSI or traditional style\n", stderr);
  373. !     fputs("  -b               Rewrite function definitions in both styles\n", stderr);
  374. !     fputs("  -c               Omit comments in generated prototypes\n", stderr);
  375. !     fputs("  -e               Output \"extern\" keyword before global declarations\n", stderr);
  376. !     fputs("  -f n             Set function prototype style (0 to 4)\n", stderr);
  377. !     fputs("  -p               Disable formal parameter promotion\n", stderr);
  378. !     fputs("  -q               Disable include file read failure messages\n", stderr);
  379. !     fputs("  -s               Output static declarations\n", stderr);
  380. !     fputs("  -v               Output variable declarations\n", stderr);
  381. !     fputs("  -m name          Set name of prototype macro\n", stderr);
  382. !     fputs("  -d               Omit prototype macro definition\n", stderr);
  383. !     fputs("  -P template      Set prototype format template \" int f (a, b)\"\n", stderr);
  384. !     fputs("  -F template      Set function definition format template \" int f (a, b)\"\n", stderr);
  385. !     fputs("  -C template      Set format for function definition with parameter comments\n", stderr);
  386. !     fputs("  -D name[=value]  Define C preprocessor symbol\n", stderr);
  387. !     fputs("  -U name          Undefine C preprocessor symbol\n", stderr);
  388. !     fputs("  -I directory     Add #include search directory\n", stderr);
  389. !     fputs("  -E command       Run specified C preprocessor command\n", stderr);
  390. !     fputs("  -E 0             Do not run any C preprocessor\n", stderr);
  391. !     fputs("  -V               Print version information\n", stderr);
  392.       exit(1);
  393.   }
  394. ***************
  395. *** 291,295 ****
  396.   #ifdef CPP
  397.       /* Allocate buffer for C preprocessor command line. */
  398. !     n = strlen(CPP) + 1;
  399.       for (i = 0; i < argc; ++i) {
  400.       n += strlen(argv[i]) + 1;
  401. --- 288,292 ----
  402.   #ifdef CPP
  403.       /* Allocate buffer for C preprocessor command line. */
  404. !     n = strlen(cpp) + 1;
  405.       for (i = 0; i < argc; ++i) {
  406.       n += strlen(argv[i]) + 1;
  407. ***************
  408. *** 300,304 ****
  409.   #endif
  410.   
  411. !     while ((c = getopt(argc, argv, "aC:cD:dE:eF:f:I:m:P:pqstU:Vv")) != EOF) {
  412.       switch (c) {
  413.       case 'I':
  414. --- 297,301 ----
  415.   #endif
  416.   
  417. !     while ((c = getopt(argc, argv, "aB:bC:cD:dE:eF:f:I:m:P:pqstU:Vv")) != EOF) {
  418.       switch (c) {
  419.       case 'I':
  420. ***************
  421. *** 319,322 ****
  422. --- 316,325 ----
  423.           func_style = FUNC_ANSI;
  424.           break;
  425. +     case 'B':
  426. +         func_directive = optarg;
  427. +         break;
  428. +     case 'b':
  429. +         func_style = FUNC_BOTH;
  430. +         break;
  431.       case 'c':
  432.           proto_comments = FALSE;
  433. ***************
  434. *** 429,433 ****
  435.   
  436.       if (proto_style == PROTO_MACRO && define_macro) {
  437. !     printf("#if defined(__STDC__) || defined(__cplusplus)\n");
  438.       printf("#define %s(s) s\n", macro_name);
  439.       printf("#else\n");
  440. --- 432,436 ----
  441.   
  442.       if (proto_style == PROTO_MACRO && define_macro) {
  443. !     printf("#if __STDC__ || defined(__cplusplus)\n");
  444.       printf("#define %s(s) s\n", macro_name);
  445.       printf("#else\n");
  446. diff  -c2 old/cproto.h new/cproto.h
  447. *** old/cproto.h    Wed Jun 10 21:03:08 1992
  448. --- new/cproto.h    Sat Nov 28 23:27:46 1992
  449. ***************
  450. *** 1,3 ****
  451. ! /* $Id: cproto.h 3.5 92/04/11 19:27:44 cthuang Exp $
  452.    *
  453.    * Declarations for C function prototype generator
  454. --- 1,3 ----
  455. ! /* $Id: cproto.h 3.6 1992/11/29 04:27:30 cthuang Exp $
  456.    *
  457.    * Declarations for C function prototype generator
  458. ***************
  459. *** 45,48 ****
  460. --- 45,49 ----
  461.   #define FUNC_TRADITIONAL    1    /* traditional style */
  462.   #define FUNC_ANSI        2    /* ANSI style */
  463. + #define FUNC_BOTH        3    /* both styles */
  464.   typedef int FuncDefStyle;
  465.   
  466. ***************
  467. *** 56,59 ****
  468. --- 57,61 ----
  469.       FuncDefStyle func_def;        /* style of function definition */
  470.       ParameterList params;        /* function parameters */
  471. +     boolean pointer;            /* TRUE if it declares a pointer */
  472.       struct declarator *head;        /* head function declarator */
  473.       struct declarator *func_stack;    /* stack of function declarators */
  474. ***************
  475. *** 79,83 ****
  476.       Text text;
  477.       DeclSpec decl_spec;
  478. !     Parameter parameter;
  479.       ParameterList param_list;
  480.       Declarator *declarator;
  481. --- 81,85 ----
  482.       Text text;
  483.       DeclSpec decl_spec;
  484. !     Parameter *parameter;
  485.       ParameterList param_list;
  486.       Declarator *declarator;
  487. ***************
  488. *** 127,130 ****
  489. --- 129,133 ----
  490.   extern boolean proto_comments;
  491.   extern boolean quiet;
  492. + extern char *func_directive;
  493.   extern int num_inc_dir;
  494.   extern char *inc_dir[];
  495. ***************
  496. *** 137,141 ****
  497.   extern void put_error();
  498.   extern void init_parser(), process_file(), pop_file();
  499. ! extern char *cur_file_name();
  500.   extern unsigned cur_line_num();
  501.   extern FILE *cur_tmp_file();
  502. --- 140,144 ----
  503.   extern void put_error();
  504.   extern void init_parser(), process_file(), pop_file();
  505. ! extern char *cur_file_name(), *cur_text();
  506.   extern unsigned cur_line_num();
  507.   extern FILE *cur_tmp_file();
  508. diff  -c2 old/grammar.y new/grammar.y
  509. *** old/grammar.y    Wed Jun 10 21:03:02 1992
  510. --- new/grammar.y    Sat Nov 28 23:27:42 1992
  511. ***************
  512. *** 1,3 ****
  513. ! /* $Id: grammar.y 3.6 92/06/10 20:56:07 cthuang Exp $
  514.    *
  515.    * yacc grammar for C function prototype generator
  516. --- 1,3 ----
  517. ! /* $Id: grammar.y 3.7 1992/11/29 04:27:30 cthuang Exp $
  518.    *
  519.    * yacc grammar for C function prototype generator
  520. ***************
  521. *** 46,49 ****
  522. --- 46,52 ----
  523.       T_ASMARG
  524.   
  525. +     /* va_dcl from <varargs.h> */
  526. +     T_VA_DCL
  527. + 
  528.   %type <decl_spec> decl_specifiers decl_specifier
  529.   %type <decl_spec> storage_class type_specifier type_qualifier
  530. ***************
  531. *** 66,78 ****
  532.   #define YYMAXDEPTH 150
  533.   
  534. ! /* Declaration specifier attributes for the typedef statement currently being
  535. !  * scanned.
  536.    */
  537.   static int cur_decl_spec_flags;
  538.   
  539. ! /* Pointer to parameter list for the current function definition. */
  540.   static ParameterList *func_params;
  541.   
  542. ! /* Pointer to current declarator in function parameter declaration. */
  543.   static Declarator *cur_declarator;
  544.   
  545. --- 69,87 ----
  546.   #define YYMAXDEPTH 150
  547.   
  548. ! /* declaration specifier attributes for the typedef statement currently being
  549. !  * scanned
  550.    */
  551.   static int cur_decl_spec_flags;
  552.   
  553. ! /* pointer to parameter list for the current function definition */
  554.   static ParameterList *func_params;
  555.   
  556. ! /* A parser semantic action sets this pointer to the current declarator in
  557. !  * a function parameter declaration in order to catch any comments following
  558. !  * the parameter declaration on the same line.  If the lexer scans a comment
  559. !  * and <cur_declarator> is not NULL, then the comment is attached to the
  560. !  * declarator.  To ignore subsequent comments, the lexer sets this to NULL
  561. !  * after scanning a comment or end of line.
  562. !  */
  563.   static Declarator *cur_declarator;
  564.   
  565. ***************
  566. *** 80,88 ****
  567.   static char buf[MAX_TEXT_SIZE];
  568.   
  569. ! /* Table of typedef names */
  570.   static SymbolTable *typedef_names;
  571.   
  572. ! /* Table of type qualifiers */
  573.   static SymbolTable *type_qualifiers;
  574.   %}
  575.   %%
  576. --- 89,114 ----
  577.   static char buf[MAX_TEXT_SIZE];
  578.   
  579. ! /* table of typedef names */
  580.   static SymbolTable *typedef_names;
  581.   
  582. ! /* table of type qualifiers */
  583.   static SymbolTable *type_qualifiers;
  584. + 
  585. + /* information about the current input file */
  586. + typedef struct {
  587. +     char *base_name;        /* base input file name */
  588. +     char *file_name;        /* current file name */
  589. +     FILE *file;         /* input file */
  590. +     unsigned line_num;        /* current line number in input file */
  591. +     FILE *tmp_file;        /* temporary file */
  592. +     long begin_comment;     /* tmp file offset after last written ) or ; */
  593. +     long end_comment;        /* tmp file offset after last comment */
  594. +     boolean convert;        /* if TRUE, convert function definitions */
  595. +     boolean changed;        /* TRUE if conversion done in this file */
  596. + } IncludeStack;
  597. + 
  598. + static IncludeStack *cur_file;    /* current input file */
  599. + 
  600. + extern void yyerror();
  601.   %}
  602.   %%
  603. ***************
  604. *** 120,124 ****
  605. --- 146,159 ----
  606.   linkage_specification
  607.       : T_EXTERN T_STRING_LITERAL braces
  608. +     {
  609. +         /* Provide an empty action here so bison will not complain about
  610. +          * incompatible types in the default action it normally would
  611. +          * have generated.
  612. +          */
  613. +     }
  614.       | T_EXTERN T_STRING_LITERAL declaration
  615. +     {
  616. +         /* empty */
  617. +     }
  618.       ;
  619.   
  620. ***************
  621. *** 130,134 ****
  622.       | decl_specifiers init_declarator_list ';'
  623.       {
  624. -         check_untagged(&$1);
  625.           if (func_params != NULL) {
  626.           set_param_types(func_params, &$1, &$2);
  627. --- 165,168 ----
  628. ***************
  629. *** 227,230 ****
  630. --- 261,265 ----
  631.   opt_declaration_list
  632.       : /* empty */
  633. +     | T_VA_DCL
  634.       | declaration_list
  635.       ;
  636. ***************
  637. *** 372,376 ****
  638.           func_style == FUNC_TRADITIONAL && cur_file->convert) {
  639.           gen_func_declarator($1);
  640. !         fputs(yytext, cur_file->tmp_file);
  641.           }
  642.           cur_declarator = $$;
  643. --- 407,411 ----
  644.           func_style == FUNC_TRADITIONAL && cur_file->convert) {
  645.           gen_func_declarator($1);
  646. !         fputs(cur_text(), cur_file->tmp_file);
  647.           }
  648.           cur_declarator = $$;
  649. ***************
  650. *** 417,420 ****
  651. --- 452,456 ----
  652.           $$->text = xstrdup(buf);
  653.           $$->begin = $1.begin;
  654. +         $$->pointer = TRUE;
  655.       }
  656.       | direct_declarator
  657. ***************
  658. *** 507,515 ****
  659.       : parameter_declaration
  660.       {
  661. !         new_param_list(&$$, &$1);
  662.       }
  663.       | parameter_list ',' parameter_declaration
  664.       {
  665. !         add_param_list(&$$, &$1, &$3);
  666.       }
  667.       ;
  668. --- 543,551 ----
  669.       : parameter_declaration
  670.       {
  671. !         new_param_list(&$$, $1);
  672.       }
  673.       | parameter_list ',' parameter_declaration
  674.       {
  675. !         add_param_list(&$$, &$1, $3);
  676.       }
  677.       ;
  678. ***************
  679. *** 519,523 ****
  680.       {
  681.           check_untagged(&$1);
  682. !         new_parameter(&$$, &$1, $2);
  683.       }
  684.       | decl_specifiers abs_declarator
  685. --- 555,559 ----
  686.       {
  687.           check_untagged(&$1);
  688. !         $$ = new_parameter(&$1, $2);
  689.       }
  690.       | decl_specifiers abs_declarator
  691. ***************
  692. *** 524,528 ****
  693.       {
  694.           check_untagged(&$1);
  695. !         new_parameter(&$$, &$1, $2);
  696.       }
  697.       | decl_specifiers
  698. --- 560,564 ----
  699.       {
  700.           check_untagged(&$1);
  701. !         $$ = new_parameter(&$1, $2);
  702.       }
  703.       | decl_specifiers
  704. ***************
  705. *** 529,533 ****
  706.       {
  707.           check_untagged(&$1);
  708. !         new_parameter(&$$, &$1, NULL);
  709.       }
  710.       ;
  711. --- 565,569 ----
  712.       {
  713.           check_untagged(&$1);
  714. !         $$ = new_parameter(&$1, NULL);
  715.       }
  716.       ;
  717. ***************
  718. *** 628,631 ****
  719. --- 664,668 ----
  720.   
  721.   %%
  722. + 
  723.   #ifdef MSDOS
  724.   #include "lex_yy.c"
  725. ***************
  726. *** 650,659 ****
  727.   {
  728.       static char *keywords[] = {
  729. !     "const", "volatile",
  730.   #ifdef MSDOS
  731.       "_cdecl", "_export", "_far", "_fastcall", "_fortran", "_huge",
  732.       "_interrupt", "_loadds", "_near", "_pascal", "_saveregs", "_segment",
  733.       "_cs", "_ds", "_es", "_ss", "_seg",
  734. !     "cdecl", "far", "huge", "interrupt", "near", "pascal",
  735.   #endif
  736.       };
  737. --- 687,700 ----
  738.   {
  739.       static char *keywords[] = {
  740. !     "const", "volatile", "interrupt",
  741.   #ifdef MSDOS
  742. +     "cdecl", "far", "huge", "near", "pascal",
  743.       "_cdecl", "_export", "_far", "_fastcall", "_fortran", "_huge",
  744.       "_interrupt", "_loadds", "_near", "_pascal", "_saveregs", "_segment",
  745.       "_cs", "_ds", "_es", "_ss", "_seg",
  746. !     "__cdecl", "__export", "__far", "__fastcall", "__fortran", "__huge",
  747. !     "__inline", "__interrupt", "__loadds", "__near", "__pascal",
  748. !     "__saveregs", "__segment", "__stdcall", "__syscall",
  749. !     "__cs", "__ds", "__es", "__ss", "__seg",
  750.   #endif
  751.       };
  752. diff  -c2 old/lex.l new/lex.l
  753. *** old/lex.l    Wed Jun 10 21:03:02 1992
  754. --- new/lex.l    Sat Nov 28 23:54:16 1992
  755. ***************
  756. *** 1,4 ****
  757.   %{
  758. ! /* $Id: lex.l 3.7 92/06/10 20:56:04 cthuang Exp $
  759.    *
  760.    * Lexical analyzer for C function prototype generator
  761. --- 1,4 ----
  762.   %{
  763. ! /* $Id: lex.l 3.8 1992/11/29 04:54:14 cthuang Exp $
  764.    *
  765.    * Lexical analyzer for C function prototype generator
  766. ***************
  767. *** 8,32 ****
  768.   static int ly_count;    /* number of occurances of %% */
  769.   
  770. - /* information about the current input file */
  771. - typedef struct {
  772. -     char *base_name;        /* base input file name */
  773. -     char *file_name;        /* current file name */
  774. -     FILE *file;         /* input file */
  775. -     unsigned line_num;        /* current line number in input file */
  776. -     FILE *tmp_file;        /* temporary file */
  777. -     long begin_comment;     /* tmp file offset after last written ) or ; */
  778. -     long end_comment;        /* tmp file offset after last comment */
  779. -     boolean convert;        /* if TRUE, convert function definitions */
  780. -     boolean changed;        /* TRUE if conversion done in this file */
  781.   #ifdef FLEX_SCANNER
  782. !     YY_BUFFER_STATE buffer;    /* flex scanner state */
  783.   #endif
  784. - } IncludeStack;
  785.   
  786.   static int inc_depth;                /* include nesting level */
  787.   static IncludeStack inc_stack[MAX_INC_DEPTH];    /* stack of included files */
  788. - static IncludeStack *cur_file;            /* current file */
  789.   static SymbolTable *included_files;        /* files already included */
  790.   
  791.   static void save_text();
  792.   static void save_text_offset();
  793. --- 8,21 ----
  794.   static int ly_count;    /* number of occurances of %% */
  795.   
  796.   #ifdef FLEX_SCANNER
  797. ! /* flex scanner state */
  798. ! static YY_BUFFER_STATE buffer_stack[MAX_INC_DEPTH];
  799.   #endif
  800.   
  801.   static int inc_depth;                /* include nesting level */
  802.   static IncludeStack inc_stack[MAX_INC_DEPTH];    /* stack of included files */
  803.   static SymbolTable *included_files;        /* files already included */
  804.   
  805. + static void update_line_num();
  806.   static void save_text();
  807.   static void save_text_offset();
  808. ***************
  809. *** 35,42 ****
  810.   static void do_include();
  811.   
  812.   #ifdef yywrap
  813.   #undef yywrap
  814.   #endif
  815. - static int yywrap();
  816.   %}
  817.   
  818. --- 24,31 ----
  819.   static void do_include();
  820.   
  821. + extern void yyerror();
  822.   #ifdef yywrap
  823.   #undef yywrap
  824.   #endif
  825.   %}
  826.   
  827. ***************
  828. *** 45,49 ****
  829.   DIGIT        [0-9]
  830.   ID        {LETTER}({LETTER}|{DIGIT})*
  831. ! STRING        \"(\\\"|[^"\n])*\"
  832.   QUOTED        ({STRING}|\'(\\\'|[^'\n])*\'|\\.)
  833.   
  834. --- 34,38 ----
  835.   DIGIT        [0-9]
  836.   ID        {LETTER}({LETTER}|{DIGIT})*
  837. ! STRING        \"(\\\"|[^"])*\"
  838.   QUOTED        ({STRING}|\'(\\\'|[^'\n])*\'|\\.)
  839.   
  840. ***************
  841. *** 59,66 ****
  842.   <LEXYACC>^"%%"        { save_text(); if (++ly_count >= 2) BEGIN INITIAL; }
  843.   <LEXYACC>^"%{"        { save_text(); BEGIN INITIAL; }
  844. ! <LEXYACC>{QUOTED}|.    save_text();
  845.   <INITIAL>^"%}"        { save_text(); BEGIN LEXYACC; }
  846.   
  847.   <INITIAL>#{WS}*     { save_text(); BEGIN CPP1; }
  848.   
  849.   <CPP1>define{WS}+{ID}    {
  850. --- 48,57 ----
  851.   <LEXYACC>^"%%"        { save_text(); if (++ly_count >= 2) BEGIN INITIAL; }
  852.   <LEXYACC>^"%{"        { save_text(); BEGIN INITIAL; }
  853. ! <LEXYACC>{QUOTED}    { save_text(); update_line_num(); }
  854. ! <LEXYACC>.        save_text();
  855.   <INITIAL>^"%}"        { save_text(); BEGIN LEXYACC; }
  856.   
  857.   <INITIAL>#{WS}*     { save_text(); BEGIN CPP1; }
  858. + <INITIAL>"??="{WS}*     { save_text(); BEGIN CPP1; }
  859.   
  860.   <CPP1>define{WS}+{ID}    {
  861. ***************
  862. *** 125,129 ****
  863.               }
  864.   <INITIAL>"..."        { save_text(); return T_ELLIPSIS; }
  865. ! <INITIAL>{STRING}    { save_text(); return T_STRING_LITERAL; }
  866.   
  867.   <INITIAL>asm        { save_text(); BEGIN ASM; return T_ASM; }
  868. --- 116,124 ----
  869.               }
  870.   <INITIAL>"..."        { save_text(); return T_ELLIPSIS; }
  871. ! <INITIAL>{STRING}    {
  872. !                 save_text();
  873. !                 update_line_num();
  874. !                 return T_STRING_LITERAL;
  875. !             }
  876.   
  877.   <INITIAL>asm        { save_text(); BEGIN ASM; return T_ASM; }
  878. ***************
  879. *** 130,136 ****
  880.   <ASM>"("        save_text();
  881.   <ASM>")"        { save_text(); BEGIN INITIAL; return T_ASMARG; }
  882. ! <ASM>{QUOTED}|.     save_text();
  883.   
  884. ! <INITIAL>_based[^(]*\([^)]*\)    { save_text_offset(); return T_TYPE_QUALIFIER; }
  885.   
  886.   <INITIAL>auto        { save_text_offset(); return T_AUTO; }
  887. --- 125,132 ----
  888.   <ASM>"("        save_text();
  889.   <ASM>")"        { save_text(); BEGIN INITIAL; return T_ASMARG; }
  890. ! <ASM>{QUOTED}         { save_text(); update_line_num(); }
  891. ! <ASM>.             save_text();
  892.   
  893. ! <INITIAL>__?based[^(]*\([^)]*\)    { save_text_offset(); return T_TYPE_QUALIFIER; }
  894.   
  895.   <INITIAL>auto        { save_text_offset(); return T_AUTO; }
  896. ***************
  897. *** 152,155 ****
  898. --- 148,152 ----
  899.   <INITIAL>struct     { save_text_offset(); return T_STRUCT; }
  900.   <INITIAL>union        { save_text_offset(); return T_UNION; }
  901. + <INITIAL>va_dcl        { save_text_offset(); return T_VA_DCL; }
  902.   
  903.   <INITIAL>{ID}        {
  904. ***************
  905. *** 167,177 ****
  906.                    * containing a ] appears between the brackets.
  907.                    */
  908. -                 int i;
  909. - 
  910.                   save_text_offset();
  911. !                 for (i = 0; i < yyleng; ++i) {
  912. !                 if (yytext[i] == '\n')
  913. !                     cur_file->line_num++;
  914. !                 }
  915.                   return T_BRACKETS;
  916.               }
  917. --- 164,174 ----
  918.                    * containing a ] appears between the brackets.
  919.                    */
  920.                   save_text_offset();
  921. !                 update_line_num();
  922. !                 return T_BRACKETS;
  923. !             }
  924. ! <INITIAL>"??("[^?]*"??)"    {
  925. !                 save_text_offset();
  926. !                 update_line_num();
  927.                   return T_BRACKETS;
  928.               }
  929. ***************
  930. *** 184,188 ****
  931.                   return T_INITIALIZER;
  932.               }
  933. ! <INIT1>{QUOTED}|.    save_text();
  934.   
  935.   <INIT2>"{"        { save_text(); ++curly; }
  936. --- 181,186 ----
  937.                   return T_INITIALIZER;
  938.               }
  939. ! <INIT1>{QUOTED}        { save_text(); update_line_num(); }
  940. ! <INIT1>.        save_text();
  941.   
  942.   <INIT2>"{"        { save_text(); ++curly; }
  943. ***************
  944. *** 194,198 ****
  945.                   }
  946.               }
  947. ! <INIT2>{QUOTED}|.    save_text();
  948.   
  949.   <INITIAL>"{"        {
  950. --- 192,197 ----
  951.                   }
  952.               }
  953. ! <INIT2>{QUOTED}        { save_text(); update_line_num(); }
  954. ! <INIT2>.        save_text();
  955.   
  956.   <INITIAL>"{"        {
  957. ***************
  958. *** 210,214 ****
  959.                   }
  960.               }
  961. ! <CURLY>{QUOTED}|.    save_text();
  962.   
  963.   [ \t\f]+        save_text();
  964. --- 209,214 ----
  965.                   }
  966.               }
  967. ! <CURLY>{QUOTED}        { save_text(); update_line_num(); }
  968. ! <CURLY>.        save_text();
  969.   
  970.   [ \t\f]+        save_text();
  971. ***************
  972. *** 220,223 ****
  973. --- 220,236 ----
  974.   %%
  975.   
  976. + /* If the matched text contains any new line characters, then update the
  977. +  * current line number.
  978. +  */
  979. + static void
  980. + update_line_num ()
  981. + {
  982. +     char *p = yytext;
  983. +     while (*p != '\0') {
  984. +     if (*p++ == '\n')
  985. +         cur_file->line_num++;
  986. +     }
  987. + }
  988. + 
  989.   /* Save the matched text in the temporary file.
  990.    */
  991. ***************
  992. *** 277,281 ****
  993.   }
  994.   
  995. ! /* Scan rest of preprocessor statement.
  996.    */
  997.   static void
  998. --- 290,294 ----
  999.   }
  1000.   
  1001. ! /* Scan rest of preprocessor directive.
  1002.    */
  1003.   static void
  1004. ***************
  1005. *** 282,286 ****
  1006.   get_cpp_directive ()
  1007.   {
  1008. !     int c, lastc = '\0';
  1009.   
  1010.       while ((c = input()) != 0) {
  1011. --- 295,301 ----
  1012.   get_cpp_directive ()
  1013.   {
  1014. !     char c, lastc[4];
  1015. !     
  1016. !     lastc[0] = lastc[1] = lastc[2] = lastc[3] = '\0';
  1017.   
  1018.       while ((c = input()) != 0) {
  1019. ***************
  1020. *** 290,294 ****
  1021.       case '\n':
  1022.           cur_file->line_num++;
  1023. !         if (lastc != '\\') {
  1024.           BEGIN INITIAL;
  1025.           return;
  1026. --- 305,309 ----
  1027.       case '\n':
  1028.           cur_file->line_num++;
  1029. !         if (lastc[2] != '\\' && strcmp(lastc, "??""/") != 0) {
  1030.           BEGIN INITIAL;
  1031.           return;
  1032. ***************
  1033. *** 296,304 ****
  1034.           break;
  1035.       case '*':
  1036. !         if (lastc == '/')
  1037.           get_comment();
  1038.           break;
  1039.       }
  1040. !     lastc = c;
  1041.       }
  1042.   }
  1043. --- 311,321 ----
  1044.           break;
  1045.       case '*':
  1046. !         if (lastc[2] == '/')
  1047.           get_comment();
  1048.           break;
  1049.       }
  1050. !     lastc[0] = lastc[1];
  1051. !     lastc[1] = lastc[2];
  1052. !     lastc[2] = c;
  1053.       }
  1054.   }
  1055. ***************
  1056. *** 344,347 ****
  1057. --- 361,372 ----
  1058.   }
  1059.   
  1060. + /* Return the text of the current lexical token.
  1061. +  */
  1062. + char *
  1063. + cur_text ()
  1064. + {
  1065. +     return yytext;
  1066. + }
  1067. + 
  1068.   #ifdef NEED_tmpfile
  1069.   /*
  1070. ***************
  1071. *** 356,360 ****
  1072.   tmpfile ()
  1073.   {
  1074. !     char name[1024];
  1075.       char *tmpdir;
  1076.       FILE *f;
  1077. --- 381,385 ----
  1078.   tmpfile ()
  1079.   {
  1080. !     char name[MAX_TEXT_SIZE];
  1081.       char *tmpdir;
  1082.       FILE *f;
  1083. ***************
  1084. *** 400,405 ****
  1085.   
  1086.   #ifdef FLEX_SCANNER
  1087. !     cur_file->buffer = yy_create_buffer(yyin, YY_BUF_SIZE);
  1088. !     yy_switch_to_buffer(cur_file->buffer);
  1089.   #endif
  1090.   
  1091. --- 425,430 ----
  1092.   
  1093.   #ifdef FLEX_SCANNER
  1094. !     buffer_stack[inc_depth] = yy_create_buffer(yyin, YY_BUF_SIZE);
  1095. !     yy_switch_to_buffer(buffer_stack[inc_depth]);
  1096.   #endif
  1097.   
  1098. ***************
  1099. *** 408,412 ****
  1100.       cur_file->tmp_file = tmpfile();
  1101.       if (cur_file->tmp_file == NULL) {
  1102. !         fprintf(stderr, "%s: cannot create temporary file %s\n", progname);
  1103.           cur_file->convert = FALSE;
  1104.       }
  1105. --- 433,437 ----
  1106.       cur_file->tmp_file = tmpfile();
  1107.       if (cur_file->tmp_file == NULL) {
  1108. !         fprintf(stderr, "%s: cannot create temporary file\n", progname);
  1109.           cur_file->convert = FALSE;
  1110.       }
  1111. ***************
  1112. *** 449,456 ****
  1113.   
  1114.       if (cur_file->convert) {
  1115. !     if (cur_file->changed) {
  1116. !         if (yyin == stdin) {
  1117. !         put_file(stdout);
  1118. !         } else if ((outf = fopen(cur_file->base_name, "w")) != NULL) {
  1119.           put_file(outf);
  1120.           fclose(outf);
  1121. --- 474,481 ----
  1122.   
  1123.       if (cur_file->convert) {
  1124. !     if (yyin == stdin) {
  1125. !         put_file(stdout);
  1126. !     } else if (cur_file->changed) {
  1127. !         if ((outf = fopen(cur_file->base_name, "w")) != NULL) {
  1128.           put_file(outf);
  1129.           fclose(outf);
  1130. ***************
  1131. *** 457,461 ****
  1132.           } else {
  1133.           fprintf(stderr, "%s: cannot create file %s\n", progname,
  1134. !             cur_file->base_name);
  1135.           }
  1136.       }
  1137. --- 482,486 ----
  1138.           } else {
  1139.           fprintf(stderr, "%s: cannot create file %s\n", progname,
  1140. !          cur_file->base_name);
  1141.           }
  1142.       }
  1143. ***************
  1144. *** 475,479 ****
  1145.   
  1146.   #ifdef FLEX_SCANNER
  1147. !     yy_switch_to_buffer(cur_file->buffer);
  1148.   #endif
  1149.       }
  1150. --- 500,504 ----
  1151.   
  1152.   #ifdef FLEX_SCANNER
  1153. !     yy_switch_to_buffer(buffer_stack[inc_depth]);
  1154.   #endif
  1155.       }
  1156. ***************
  1157. *** 524,528 ****
  1158.    * nested include file.
  1159.    */
  1160. ! static int
  1161.   yywrap ()
  1162.   {
  1163. --- 549,553 ----
  1164.    * nested include file.
  1165.    */
  1166. ! int
  1167.   yywrap ()
  1168.   {
  1169. diff  -c2 old/Makefile.bc new/Makefile.bc
  1170. *** old/Makefile.bc    Wed Jun 10 21:03:02 1992
  1171. --- new/Makefile.bc    Sat Nov 28 23:27:32 1992
  1172. ***************
  1173. *** 1,3 ****
  1174. ! # $Id: makefile.bc 3.1 92/03/03 10:45:53 cthuang Exp $
  1175.   #
  1176.   # Borland C++ makefile for C prototype generator
  1177. --- 1,3 ----
  1178. ! # $Id: Makefile.bc 3.1 1992/03/03 10:45:53 cthuang Exp $
  1179.   #
  1180.   # Borland C++ makefile for C prototype generator
  1181. diff  -c2 old/Makefile.msc new/Makefile.msc
  1182. *** old/Makefile.msc    Wed Jun 10 21:03:02 1992
  1183. --- new/Makefile.msc    Sat Nov 28 23:27:36 1992
  1184. ***************
  1185. *** 1,3 ****
  1186. ! # $Id: makefile.msc 3.3 92/06/10 20:55:56 cthuang Exp $
  1187.   #
  1188.   # Microsoft C makefile for C prototype generator
  1189. --- 1,3 ----
  1190. ! # $Id: Makefile.msc 3.4 1992/11/29 04:27:30 cthuang Exp $
  1191.   #
  1192.   # Microsoft C makefile for C prototype generator
  1193. ***************
  1194. *** 11,16 ****
  1195.   CC = cl
  1196.   CFLAGS = -AC $(DEFINES)
  1197. ! LIBS = \c6\lib\setargv.obj
  1198. ! LDFLAGS = /link /noe /stack:4096
  1199.   
  1200.   DIST1 = README CHANGES cproto.man
  1201. --- 11,16 ----
  1202.   CC = cl
  1203.   CFLAGS = -AC $(DEFINES)
  1204. ! LIBS = \c7\lib\setargv.obj
  1205. ! LDFLAGS = /F 1000
  1206.   
  1207.   DIST1 = README CHANGES cproto.man
  1208. diff  -c2 old/Makefile.uni new/Makefile.uni
  1209. *** old/Makefile.uni    Wed Jun 10 21:03:02 1992
  1210. --- new/Makefile.uni    Sat Nov 28 23:27:36 1992
  1211. ***************
  1212. *** 1,3 ****
  1213. ! # $Id: makefile.uni 3.5 92/06/10 20:56:00 cthuang Exp $
  1214.   #
  1215.   # UNIX makefile for C prototype generator
  1216. --- 1,3 ----
  1217. ! # $Id: Makefile.uni 3.5 1992/06/10 20:56:00 cthuang Exp $
  1218.   #
  1219.   # UNIX makefile for C prototype generator
  1220. diff  -c2 old/patchlev.h new/patchlev.h
  1221. *** old/patchlev.h    Wed Jun 10 21:03:08 1992
  1222. --- new/patchlev.h    Fri Jun 26 08:27:12 1992
  1223. ***************
  1224. *** 1 ****
  1225. ! #define PATCHLEVEL 4
  1226. --- 1 ----
  1227. ! #define PATCHLEVEL 5
  1228. diff  -c2 old/popen.c new/popen.c
  1229. *** old/popen.c    Wed Jun 10 21:03:08 1992
  1230. --- new/popen.c    Sat Nov 28 23:27:52 1992
  1231. ***************
  1232. *** 1,3 ****
  1233. ! /* $Id: popen.c 3.3 92/06/10 20:56:30 cthuang Exp $
  1234.    *
  1235.    * Imitate a UNIX pipe in MS-DOS.
  1236. --- 1,3 ----
  1237. ! /* $Id: popen.c 3.3 1992/06/10 20:56:30 cthuang Exp $
  1238.    *
  1239.    * Imitate a UNIX pipe in MS-DOS.
  1240. diff  -c2 old/semantic.c new/semantic.c
  1241. *** old/semantic.c    Wed Jun 10 21:03:08 1992
  1242. --- new/semantic.c    Sat Nov 28 23:27:56 1992
  1243. ***************
  1244. *** 1,3 ****
  1245. ! /* $Id: semantic.c 3.6 92/06/10 20:56:35 cthuang Exp $
  1246.    *
  1247.    * Semantic actions executed by the parser of the
  1248. --- 1,3 ----
  1249. ! /* $Id: semantic.c 3.7 1992/11/29 04:27:49 cthuang Exp $
  1250.    *
  1251.    * Semantic actions executed by the parser of the
  1252. ***************
  1253. *** 11,15 ****
  1254.   static Declarator *func_declarator;
  1255.   
  1256. ! /* Where the declarator appears */
  1257.   static int where;
  1258.   
  1259. --- 11,18 ----
  1260.   static Declarator *func_declarator;
  1261.   
  1262. ! /* Role of the function declarator
  1263. !  * FUNC_PROTO if it is the declarator in a function prototype.
  1264. !  * FUNC_DEF if it is the declarator in a function definition.
  1265. !  */
  1266.   static int where;
  1267.   
  1268. ***************
  1269. *** 105,108 ****
  1270. --- 108,112 ----
  1271.       d->head = d;
  1272.       d->func_stack = NULL;
  1273. +     d->pointer = FALSE;
  1274.       return d;
  1275.   }
  1276. ***************
  1277. *** 116,120 ****
  1278.       free(d->text);
  1279.       free(d->name);
  1280. !     free_param_list(&(d->params));
  1281.       if (d->func_stack != NULL)
  1282.       free_declarator(d->func_stack);
  1283. --- 120,124 ----
  1284.       free(d->text);
  1285.       free(d->name);
  1286. !     free_param_list(&d->params);
  1287.       if (d->func_stack != NULL)
  1288.       free_declarator(d->func_stack);
  1289. ***************
  1290. *** 162,175 ****
  1291.   }
  1292.   
  1293. ! /* Initialize the parameter structure.
  1294.    */
  1295. ! void
  1296. ! new_parameter (param, decl_spec, declarator)
  1297. ! Parameter *param;        /* parameter to be initialized */
  1298.   DeclSpec *decl_spec;
  1299.   Declarator *declarator;
  1300.   {
  1301.       if (decl_spec == NULL) {
  1302. !     new_decl_spec(&(param->decl_spec), "", 0L, DS_JUNK);
  1303.       } else {
  1304.       param->decl_spec = *decl_spec;
  1305. --- 166,181 ----
  1306.   }
  1307.   
  1308. ! /* Create a new parameter structure.
  1309.    */
  1310. ! Parameter *
  1311. ! new_parameter (decl_spec, declarator)
  1312.   DeclSpec *decl_spec;
  1313.   Declarator *declarator;
  1314.   {
  1315. +     Parameter *param;
  1316. +     param = (Parameter *)xmalloc(sizeof(Parameter));
  1317. + 
  1318.       if (decl_spec == NULL) {
  1319. !     new_decl_spec(¶m->decl_spec, "", 0L, DS_NONE);
  1320.       } else {
  1321.       param->decl_spec = *decl_spec;
  1322. ***************
  1323. *** 182,185 ****
  1324. --- 188,192 ----
  1325.   
  1326.       param->comment = NULL;
  1327. +     return param;
  1328.   }
  1329.   
  1330. ***************
  1331. *** 190,197 ****
  1332.   Parameter *param;
  1333.   {
  1334. !     free_decl_spec(&(param->decl_spec));
  1335.       free_declarator(param->declarator);
  1336.       if (param->comment != NULL)
  1337.       free(param->comment);
  1338.   }
  1339.   
  1340. --- 197,205 ----
  1341.   Parameter *param;
  1342.   {
  1343. !     free_decl_spec(¶m->decl_spec);
  1344.       free_declarator(param->declarator);
  1345.       if (param->comment != NULL)
  1346.       free(param->comment);
  1347. +     free(param);
  1348.   }
  1349.   
  1350. ***************
  1351. *** 213,223 ****
  1352.   Parameter *param;
  1353.   {
  1354. !     Parameter *p;
  1355. ! 
  1356. !     p = (Parameter *)xmalloc(sizeof(Parameter));
  1357. !     *p = *param;
  1358. !     
  1359. !     param_list->first = param_list->last = p;
  1360. !     p->next = NULL;
  1361.   
  1362.       param_list->begin_comment = param_list->end_comment = 0;
  1363. --- 221,226 ----
  1364.   Parameter *param;
  1365.   {
  1366. !     param_list->first = param_list->last = param;
  1367. !     param->next = NULL;
  1368.   
  1369.       param_list->begin_comment = param_list->end_comment = 0;
  1370. ***************
  1371. *** 237,241 ****
  1372.       next = p->next;
  1373.       free_parameter(p);
  1374. -     free(p);
  1375.       p = next;
  1376.       }
  1377. --- 240,243 ----
  1378. ***************
  1379. *** 245,249 ****
  1380.   }
  1381.   
  1382. ! /* Add the function parameter declaration to the list.
  1383.    */
  1384.   void
  1385. --- 247,251 ----
  1386.   }
  1387.   
  1388. ! /* Add the parameter to the function parameter list.
  1389.    */
  1390.   void
  1391. ***************
  1392. *** 252,264 ****
  1393.   Parameter *param;
  1394.   {
  1395. -     Parameter *p;
  1396. - 
  1397. -     p = (Parameter *)xmalloc(sizeof(Parameter));
  1398. -     *p = *param;
  1399. - 
  1400.       to->first = from->first;
  1401. !     from->last->next = p;
  1402. !     to->last = p;
  1403. !     p->next = NULL;
  1404.   }
  1405.   
  1406. --- 254,261 ----
  1407.   Parameter *param;
  1408.   {
  1409.       to->first = from->first;
  1410. !     from->last->next = param;
  1411. !     to->last = param;
  1412. !     param->next = NULL;
  1413.   }
  1414.   
  1415. ***************
  1416. *** 285,291 ****
  1417.       Declarator *declarator;
  1418.   
  1419. -     p = (Parameter *)xmalloc(sizeof(Parameter));
  1420.       declarator = new_declarator(name, name, 0L);
  1421. !     new_parameter(p, NULL, declarator);
  1422.   
  1423.       to->first = from->first;
  1424. --- 282,287 ----
  1425.       Declarator *declarator;
  1426.   
  1427.       declarator = new_declarator(name, name, 0L);
  1428. !     p = new_parameter(NULL, declarator);
  1429.   
  1430.       to->first = from->first;
  1431. ***************
  1432. *** 387,392 ****
  1433.       p = declarator->params.first;
  1434.       if (is_void_parameter(p)) {
  1435. !     if (p != NULL || ((where == FUNC_PROTO || where == FUNC_DEF) &&
  1436. !      declarator == func_declarator))
  1437.           fputs("void", outf);
  1438.       } else {
  1439. --- 383,387 ----
  1440.       p = declarator->params.first;
  1441.       if (is_void_parameter(p)) {
  1442. !     if (p != NULL)
  1443.           fputs("void", outf);
  1444.       } else {
  1445. ***************
  1446. *** 578,586 ****
  1447.   DeclSpec *decl_spec;
  1448.   {
  1449. !     if (extern_out && (decl_spec->flags & DS_STATIC) == 0) {
  1450. !     if (strstr(decl_spec->text, "extern") == NULL) {
  1451. !         fputs("extern ", outf);
  1452. !     }
  1453. !     }
  1454.       fputs(decl_spec->text, outf);
  1455.       fputc(' ', outf);
  1456. --- 573,579 ----
  1457.   DeclSpec *decl_spec;
  1458.   {
  1459. !     if (extern_out && !(decl_spec->flags & DS_STATIC) &&
  1460. !      strstr(decl_spec->text, "extern") == NULL)
  1461. !     fputs("extern ", outf);
  1462.       fputs(decl_spec->text, outf);
  1463.       fputc(' ', outf);
  1464. ***************
  1465. *** 601,604 ****
  1466. --- 594,598 ----
  1467.       return;
  1468.   
  1469. +     check_untagged(decl_spec);
  1470.       func_declarator = NULL;
  1471.       where = FUNC_OTHER;
  1472. ***************
  1473. *** 605,609 ****
  1474.       format = FMT_OTHER;
  1475.       for (d = decl_list->first; d != NULL; d = d->next) {
  1476. !     if (d->func_def == FUNC_NONE) {
  1477.           fputs(fmt[FMT_PROTO].decl_spec_prefix, stdout);
  1478.           put_decl_spec(stdout, decl_spec);
  1479. --- 599,603 ----
  1480.       format = FMT_OTHER;
  1481.       for (d = decl_list->first; d != NULL; d = d->next) {
  1482. !     if (d->func_def == FUNC_NONE || d->head->func_stack->pointer) {
  1483.           fputs(fmt[FMT_PROTO].decl_spec_prefix, stdout);
  1484.           put_decl_spec(stdout, decl_spec);
  1485. ***************
  1486. *** 614,617 ****
  1487. --- 608,644 ----
  1488.   }
  1489.   
  1490. + /* Generate a prototype for a function that uses varargs by replacing the
  1491. +  * "va_alist" parameter with an empty parameter list.
  1492. +  */
  1493. + static void
  1494. + check_varargs (declarator)
  1495. + Declarator *declarator;
  1496. + {
  1497. +     Parameter *p;
  1498. + 
  1499. +     if ((p = declarator->params.first) != NULL && p->next == NULL &&
  1500. +     strcmp(p->declarator->name, "va_alist") == 0)
  1501. +     {
  1502. +     free_param_list(&declarator->params);
  1503. +     declarator->params.first = NULL;
  1504. +     }
  1505. + }
  1506. + 
  1507. + /* If the parameter list is empty, then replace it with "void".
  1508. +  */
  1509. + static void
  1510. + check_void_param (declarator)
  1511. + Declarator *declarator;
  1512. + {
  1513. +     DeclSpec decl_spec;
  1514. +     Parameter *p;
  1515. + 
  1516. +     if (declarator->params.first == NULL) {
  1517. +     new_decl_spec(&decl_spec, "void", 0L, DS_NONE);
  1518. +     p = new_parameter(&decl_spec, NULL);
  1519. +     new_param_list(&declarator->params, p);
  1520. +     }
  1521. + }
  1522. + 
  1523.   /* If a parameter name appears in the parameter list of a traditional style
  1524.    * function definition but is not declared in the parameter declarations,
  1525. ***************
  1526. *** 646,649 ****
  1527. --- 673,678 ----
  1528.   
  1529.       func_declarator = declarator->head;
  1530. +     check_void_param(func_declarator);
  1531. +     check_varargs(func_declarator);
  1532.       set_param_decl_spec(func_declarator);
  1533.   
  1534. ***************
  1535. *** 673,676 ****
  1536. --- 702,728 ----
  1537.   }
  1538.   
  1539. + /* Output parameter declarations for old style function definition.
  1540. +  */
  1541. + static void
  1542. + put_param_decl (declarator)
  1543. + Declarator *declarator;
  1544. + {
  1545. +     Parameter *p;
  1546. + 
  1547. +     p = declarator->params.first;
  1548. +     if (!is_void_parameter(p)) {
  1549. +     fputc('\n', cur_tmp_file());
  1550. +     put_parameter(cur_tmp_file(), p);
  1551. +     fputc(';', cur_tmp_file());
  1552. +     p = p->next;
  1553. +     while (p != NULL && strcmp(p->declarator->text, "...") != 0) {
  1554. +         fputc('\n', cur_tmp_file());
  1555. +         put_parameter(cur_tmp_file(), p);
  1556. +         fputc(';', cur_tmp_file());
  1557. +         p = p->next;
  1558. +     }
  1559. +     }
  1560. + }
  1561. + 
  1562.   /* Generate a function definition head.
  1563.    */
  1564. ***************
  1565. *** 685,690 ****
  1566.       int comment_len, n;
  1567.   
  1568. !     /* Return if the function is already defined in the desired style. */
  1569. !     if (declarator->func_def == func_style)
  1570.       return;
  1571.   
  1572. --- 737,743 ----
  1573.       int comment_len, n;
  1574.   
  1575. !     /* Do nothing if the function is already defined in the desired style. */
  1576. !     func_declarator = declarator->head;
  1577. !     if (func_declarator->func_def == func_style)
  1578.       return;
  1579.   
  1580. ***************
  1581. *** 698,706 ****
  1582.       fread(comment, sizeof(char), comment_len, cur_tmp_file());
  1583.   
  1584. -     func_declarator = declarator->head;
  1585.       format = FMT_FUNC;
  1586. ! 
  1587. !     /* Save the text before the parameter declarations. */
  1588. !     if (func_style == FUNC_ANSI) {
  1589.       params = &func_declarator->params;
  1590.       n = (int)(params->end_comment - params->begin_comment);
  1591. --- 751,757 ----
  1592.       fread(comment, sizeof(char), comment_len, cur_tmp_file());
  1593.   
  1594.       format = FMT_FUNC;
  1595. !     if (func_declarator->func_def == FUNC_TRADITIONAL) {
  1596. !     /* Save the text before the parameter declarations. */
  1597.       params = &func_declarator->params;
  1598.       n = (int)(params->end_comment - params->begin_comment);
  1599. ***************
  1600. *** 712,729 ****
  1601.           format = FMT_FUNC_COMMENT;
  1602.       }
  1603. -     }
  1604.   
  1605. !     /* Get the parameter comments. */
  1606. !     for (p = func_declarator->params.first; p != NULL; p = p->next) {
  1607. !     n = (int)(p->declarator->end_comment - p->declarator->begin_comment);
  1608. !     if (n > 0) {
  1609. !         p->comment = xmalloc(n+1);
  1610. !         fseek(cur_tmp_file(), p->declarator->begin_comment, 0);
  1611. !         fread(p->comment, sizeof(char), n, cur_tmp_file());
  1612. !         p->comment[n] = '\0';
  1613. !         format = FMT_FUNC_COMMENT;
  1614.       }
  1615.       }
  1616.   
  1617.       set_param_decl_spec(func_declarator);
  1618.   
  1619. --- 763,781 ----
  1620.           format = FMT_FUNC_COMMENT;
  1621.       }
  1622.   
  1623. !     /* Get the parameter comments. */
  1624. !     for (p = func_declarator->params.first; p != NULL; p = p->next) {
  1625. !         n = (int)(p->declarator->end_comment - p->declarator->begin_comment);
  1626. !         if (n > 0) {
  1627. !             p->comment = xmalloc(n+1);
  1628. !             fseek(cur_tmp_file(), p->declarator->begin_comment, 0);
  1629. !             fread(p->comment, sizeof(char), n, cur_tmp_file());
  1630. !             p->comment[n] = '\0';
  1631. !             format = FMT_FUNC_COMMENT;
  1632. !         }
  1633.       }
  1634.       }
  1635.   
  1636. +     check_void_param(func_declarator);
  1637.       set_param_decl_spec(func_declarator);
  1638.   
  1639. ***************
  1640. *** 731,760 ****
  1641.        * and overwrite it with the converted function head.
  1642.        */
  1643.       fseek(cur_tmp_file(), decl_spec->begin, 0);
  1644.   
  1645. !     /* Output declarator specifiers. */
  1646. !     fputs(fmt[format].decl_spec_prefix, cur_tmp_file());
  1647. !     fputs(decl_spec->text, cur_tmp_file());
  1648. !     fputc(' ', cur_tmp_file());
  1649. ! 
  1650. !     /* Output function declarator. */
  1651. !     where = FUNC_DEF;
  1652. !     put_func_declarator(cur_tmp_file(), declarator);
  1653.   
  1654. !     if (func_style == FUNC_TRADITIONAL) {
  1655. !     /* Output traditional style parameter declarations. */
  1656. !     p = func_declarator->params.first;
  1657. !     if (!is_void_parameter(p)) {
  1658.           fputc('\n', cur_tmp_file());
  1659. !         put_parameter(cur_tmp_file(), p);
  1660. !         fputc(';', cur_tmp_file());
  1661. !         p = p->next;
  1662. !         while (p != NULL && strcmp(p->declarator->text, "...") != 0) {
  1663. !         fputc('\n', cur_tmp_file());
  1664. !         put_parameter(cur_tmp_file(), p);
  1665. !         fputc(';', cur_tmp_file());
  1666. !         p = p->next;
  1667. !         }
  1668. !     }
  1669.       }
  1670.   
  1671. --- 783,844 ----
  1672.        * and overwrite it with the converted function head.
  1673.        */
  1674. +     where = FUNC_DEF;
  1675.       fseek(cur_tmp_file(), decl_spec->begin, 0);
  1676.   
  1677. !     if (func_style == FUNC_BOTH) {
  1678. !     char *cur_func;
  1679. !     int func_len;
  1680. ! 
  1681. !     /* Save the current function definition head. */
  1682. !     func_len = (int)(cur_begin_comment() - decl_spec->begin);
  1683. !     cur_func = xmalloc(func_len);
  1684. !     fread(cur_func, sizeof(char), func_len, cur_tmp_file());
  1685. ! 
  1686. !     fseek(cur_tmp_file(), decl_spec->begin, 0);
  1687. !     fprintf(cur_tmp_file(), "%s\n\n", func_directive);
  1688. ! 
  1689. !     /* Output new style function definition head. */
  1690. !     if (func_declarator->func_def == FUNC_ANSI) {
  1691. !         fwrite(cur_func, sizeof(char), func_len, cur_tmp_file());
  1692. !     } else {
  1693. !         fputs(fmt[format].decl_spec_prefix, cur_tmp_file());
  1694. !         fputs(decl_spec->text, cur_tmp_file());
  1695. !         fputc(' ', cur_tmp_file());
  1696. ! 
  1697. !         func_style = FUNC_ANSI;
  1698. !         put_func_declarator(cur_tmp_file(), declarator);
  1699. !     }
  1700. !     fputs("\n#else\n\n", cur_tmp_file());
  1701. ! 
  1702. !     /* Output old style function definition head. */
  1703. !     if (func_declarator->func_def == FUNC_TRADITIONAL) {
  1704. !         fwrite(cur_func, sizeof(char), func_len, cur_tmp_file());
  1705. !     } else {
  1706. !         fputs(fmt[format].decl_spec_prefix, cur_tmp_file());
  1707. !         fputs(decl_spec->text, cur_tmp_file());
  1708. !         fputc(' ', cur_tmp_file());
  1709. ! 
  1710. !          format = FMT_FUNC;
  1711. !         func_style = FUNC_TRADITIONAL;
  1712. !         put_func_declarator(cur_tmp_file(), declarator);
  1713. !         put_param_decl(func_declarator);
  1714. !     }
  1715.   
  1716. !     fputs("\n#endif", cur_tmp_file());
  1717. !     if (*comment != '\n')
  1718.           fputc('\n', cur_tmp_file());
  1719. !     func_style = FUNC_BOTH;
  1720. !     free(cur_func);
  1721. ! 
  1722. !     } else {
  1723. !     /* Output declarator specifiers. */
  1724. !     fputs(fmt[format].decl_spec_prefix, cur_tmp_file());
  1725. !     fputs(decl_spec->text, cur_tmp_file());
  1726. !     fputc(' ', cur_tmp_file());
  1727. ! 
  1728. !     /* Output function declarator. */
  1729. !     put_func_declarator(cur_tmp_file(), declarator);
  1730. !     if (func_style == FUNC_TRADITIONAL)
  1731. !         put_param_decl(func_declarator);
  1732.       }
  1733.   
  1734. diff  -c2 old/semantic.h new/semantic.h
  1735. *** old/semantic.h    Wed Jun 10 21:03:08 1992
  1736. --- new/semantic.h    Sat Nov 28 23:27:48 1992
  1737. ***************
  1738. *** 1,3 ****
  1739. ! /* $Id: semantic.h 3.3 92/06/10 20:56:19 cthuang Exp $
  1740.    *
  1741.    * Declarations of semantic action routines
  1742. --- 1,3 ----
  1743. ! /* $Id: semantic.h 3.4 1992/11/29 04:27:30 cthuang Exp $
  1744.    *
  1745.    * Declarations of semantic action routines
  1746. ***************
  1747. *** 22,27 ****
  1748.   extern void add_decl_list(/*
  1749.       DeclaratorList *to, DeclaratorList *from, Declarator *declarator*/);
  1750. ! extern void new_parameter(/*
  1751. !     Parameter *param, DeclSpec *decl_spec, Declarator *declarator*/);
  1752.   extern void free_parameter(/*
  1753.       Parameter *param*/);
  1754. --- 22,27 ----
  1755.   extern void add_decl_list(/*
  1756.       DeclaratorList *to, DeclaratorList *from, Declarator *declarator*/);
  1757. ! extern Parameter *new_parameter(/*
  1758. !     DeclSpec *decl_spec, Declarator *declarator*/);
  1759.   extern void free_parameter(/*
  1760.       Parameter *param*/);
  1761. diff  -c2 old/strstr.c new/strstr.c
  1762. *** old/strstr.c    Wed Jun 10 21:03:08 1992
  1763. --- new/strstr.c    Sat Nov 28 23:27:58 1992
  1764. ***************
  1765. *** 1,3 ****
  1766. ! /* $Id: strstr.c 3.2 92/03/06 00:51:10 cthuang Exp $
  1767.    *
  1768.    * Simple implementation of the ANSI strstr() function
  1769. --- 1,3 ----
  1770. ! /* $Id: strstr.c 3.3 1992/11/29 04:27:49 cthuang Exp $
  1771.    *
  1772.    * Simple implementation of the ANSI strstr() function
  1773. ***************
  1774. *** 17,21 ****
  1775.       int keylen;
  1776.   
  1777. !     keylen = strlen(key);
  1778.       s = strchr(src, *key);
  1779.       while (s != NULL) {
  1780. --- 17,23 ----
  1781.       int keylen;
  1782.   
  1783. !     if ((keylen = strlen(key)) == 0)
  1784. !     return src;
  1785. ! 
  1786.       s = strchr(src, *key);
  1787.       while (s != NULL) {
  1788. diff  -c2 old/symbol.c new/symbol.c
  1789. *** old/symbol.c    Wed Jun 10 21:03:08 1992
  1790. --- new/symbol.c    Sat Nov 28 23:28:00 1992
  1791. ***************
  1792. *** 1,3 ****
  1793. ! /* $Id: symbol.c 3.1 92/03/03 10:43:52 cthuang Exp $
  1794.    *
  1795.    * Implements a symbol table abstract data type.
  1796. --- 1,3 ----
  1797. ! /* $Id: symbol.c 3.2 1992/11/29 04:27:49 cthuang Exp $
  1798.    *
  1799.    * Implements a symbol table abstract data type.
  1800. ***************
  1801. *** 95,99 ****
  1802.   /* If the symbol <name> does not already exist in symbol table <symtab>,
  1803.    * then add the symbol to the symbol table.
  1804. !  * Return a pointer to the symbol or NULL on an error.
  1805.    */
  1806.   Symbol *
  1807. --- 95,99 ----
  1808.   /* If the symbol <name> does not already exist in symbol table <symtab>,
  1809.    * then add the symbol to the symbol table.
  1810. !  * Return a pointer to the symbol.
  1811.    */
  1812.   Symbol *
  1813. ***************
  1814. *** 107,117 ****
  1815.   
  1816.       if ((sym = find_symbol(symtab, name)) == NULL) {
  1817. !     if ((sym = (Symbol *)xmalloc(sizeof(Symbol))) != NULL) {
  1818. !         sym->name = xstrdup(name);
  1819. !         sym->flags = flags;
  1820. !         i = hash(name);
  1821. !         sym->next = symtab->bucket[i];
  1822. !         symtab->bucket[i] = sym;
  1823. !     }
  1824.       }
  1825.       return sym;
  1826. --- 107,116 ----
  1827.   
  1828.       if ((sym = find_symbol(symtab, name)) == NULL) {
  1829. !     sym = (Symbol *)xmalloc(sizeof(Symbol));
  1830. !     sym->name = xstrdup(name);
  1831. !     sym->flags = flags;
  1832. !     i = hash(name);
  1833. !     sym->next = symtab->bucket[i];
  1834. !     symtab->bucket[i] = sym;
  1835.       }
  1836.       return sym;
  1837. diff  -c2 old/symbol.h new/symbol.h
  1838. *** old/symbol.h    Wed Jun 10 21:03:08 1992
  1839. --- new/symbol.h    Sat Nov 28 23:27:48 1992
  1840. ***************
  1841. *** 1,3 ****
  1842. ! /* $Id: symbol.h 3.3 92/03/14 11:57:48 cthuang Exp $
  1843.    *
  1844.    * A symbol table is a collection of string identifiers stored in a
  1845. --- 1,3 ----
  1846. ! /* $Id: symbol.h 3.3 1992/03/14 11:57:48 cthuang Exp $
  1847.    *
  1848.    * A symbol table is a collection of string identifiers stored in a
  1849.