home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume28 / unproto / patch01 next >
Encoding:
Text File  |  1992-02-23  |  26.5 KB  |  911 lines
  1. Newsgroups: comp.sources.misc
  2. From: wietse@wzv.win.tue.nl (Wietse Venema)
  3. Subject:  v28i069:  unproto - ANSI C with traditional UNIX C compiler, Patch01
  4. Message-ID: <1992Feb24.034828.14131@sparky.imd.sterling.com>
  5. X-Md4-Signature: fe20b2b822b503a511192d1a2661cf82
  6. Date: Mon, 24 Feb 1992 03:48:28 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: wietse@wzv.win.tue.nl (Wietse Venema)
  10. Posting-number: Volume 28, Issue 69
  11. Archive-name: unproto/patch01
  12. Environment: UNIX, PCC
  13. Patch-To: unproto: Volume 27, Issue 85-86
  14.  
  15. This is a patch to the unproto release that appeared a month ago in
  16. this news group (volume 27, issues 85 and 86). It fixes an omission
  17. that was found by Byron Rakitzis when he let the unprototyper loose 
  18. on his re-implementation of the plan 9 rc shell.
  19.  
  20. Changes with respect to the previous release: declarations/definitions
  21. of functions returning pointer to function are now rewritten to old
  22. style; besides a sample stdarg.h, the package now also provides sample
  23. versions of the stddef.h and stdlib.h include files; more hints are
  24. given on how to integrate the unprototyper with the native C compiler;
  25. "asm" has been added to the list of reserved words.
  26.  
  27. A fully patched version of the unproto source can be obtained from
  28. ftp.win.tue.nl, file /pub/unix/unproto4.shar.Z
  29.  
  30.     Wietse Venema
  31.     wietse@wzv.win.tue.nl
  32.     Mathematics and Computing Science
  33.     Eindhoven University of Technology
  34.     The Netherlands
  35.  
  36. Prereq: 1.3
  37. *** ./example.c.old    Wed Jan 15 21:53:27 1992
  38. --- ./example.c    Sat Feb 15 17:17:06 1992
  39. ***************
  40. *** 1,5 ****
  41.    /*
  42. !   * @(#) example.c 1.3 92/01/15 21:53:26
  43.     * 
  44.     * Examples of things that can be done with the unproto package
  45.     */
  46. --- 1,5 ----
  47.    /*
  48. !   * @(#) example.c 1.4 92/02/15 17:17:05
  49.     * 
  50.     * Examples of things that can be done with the unproto package
  51.     */
  52. ***************
  53. *** 187,189 ****
  54. --- 187,216 ----
  55.   
  56.   int (*(*test18[bar])(charstar))(charstar) = \
  57.       (int (*(*[bar])(charstar))(charstar)) 0;
  58. + 
  59. + /* Function returning pointer to function */
  60. + 
  61. + int (*(*test19(long))(int))(double);
  62. + 
  63. + /* GCC accepts the following stuff, K&R C does not... */
  64. + 
  65. + void test20(int test21(double)) {}
  66. + 
  67. + void test22(struct { int foo; } test23(short)) {}
  68. + 
  69. + /* Do not blindly rewrite (*name(stuff))(otherstuff) */
  70. + 
  71. + void    test23()
  72. + {
  73. +     int     (*test24(int)) (int),
  74. +             y = (*test24(2)) (3),
  75. +             z = ((*test24(2)) (3));
  76. + }
  77. + 
  78. + /* Function returning pointer to function */
  79. + 
  80. + int (*(*test25(long foo))(int bar))(double baz){ /* body */ }
  81. + 
  82. + int (*(*test26(foo))())()
  83. + long foo;
  84. + { /* body */ }
  85. Prereq: 1.4
  86. *** ./unproto.c.old    Wed Jan 15 21:52:59 1992
  87. --- ./unproto.c    Sat Feb 15 17:17:12 1992
  88. ***************
  89. *** 7,12 ****
  90. --- 7,14 ----
  91.   /*    unproto
  92.   /* SYNOPSIS
  93.   /*    /somewhere/cpp ...
  94. + /*
  95. + /*    cc cflags -E file.c | unproto >file.i; cc cflags -c file.i
  96.   /* DESCRIPTION
  97.   /*    This document describes a filter that sits in between the UNIX
  98.   /*    C preprocessor and the next UNIX C compiler stage, on the fly rewriting
  99. ***************
  100. *** 123,134 ****
  101.   /*    Department of Mathematics and Computer Science
  102.   /*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  103.   /* LAST MODIFICATION
  104. ! /*    92/01/15 21:52:56
  105.   /* VERSION/RELEASE
  106. ! /*    1.4
  107.   /*--*/
  108.   
  109. ! static char unproto_sccsid[] = "@(#) unproto.c 1.4 92/01/15 21:52:56";
  110.   
  111.   /* C library */
  112.   
  113. --- 125,136 ----
  114.   /*    Department of Mathematics and Computer Science
  115.   /*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  116.   /* LAST MODIFICATION
  117. ! /*    92/02/15 17:17:09
  118.   /* VERSION/RELEASE
  119. ! /*    1.5
  120.   /*--*/
  121.   
  122. ! static char unproto_sccsid[] = "@(#) unproto.c 1.5 92/02/15 17:17:09";
  123.   
  124.   /* C library */
  125.   
  126. ***************
  127. *** 331,339 ****
  128.   
  129.   #endif
  130.   
  131. ! /* header_flush - rewrite new-style function header to old style */
  132.   
  133. ! static void header_flush(t)
  134.   register struct token *t;
  135.   {
  136.       register struct token *s;
  137. --- 333,341 ----
  138.   
  139.   #endif
  140.   
  141. ! /* show_arg_names - display function argument names */
  142.   
  143. ! static void show_arg_names(t)
  144.   register struct token *t;
  145.   {
  146.       register struct token *s;
  147. ***************
  148. *** 355,362 ****
  149.           }
  150.       }
  151.       }
  152. !     put_nl();                    /* make output look nicer */
  153.   
  154.       /* Do argument types, but suppress void and trailing ... */
  155.   
  156.       if (!LAST_ARG_AND_EQUAL(t->head, VOID_ARG)) {
  157. --- 357,371 ----
  158.           }
  159.       }
  160.       }
  161. ! }
  162.   
  163. + /* show_arg_types - display function argument types */
  164. + 
  165. + static void show_arg_types(t)
  166. + register struct token *t;
  167. + {
  168. +     register struct token *s;
  169. + 
  170.       /* Do argument types, but suppress void and trailing ... */
  171.   
  172.       if (!LAST_ARG_AND_EQUAL(t->head, VOID_ARG)) {
  173. ***************
  174. *** 370,378 ****
  175.           }
  176.       }
  177.       }
  178. -     tok_free(t);
  179.   }
  180.   
  181.   /* show_arg_name - extract argument name from argument type info */
  182.   
  183.   static void show_arg_name(s)
  184. --- 379,468 ----
  185.           }
  186.       }
  187.       }
  188.   }
  189.   
  190. + /* header_flush - rewrite new-style function heading to old style */
  191. + 
  192. + static void header_flush(t)
  193. + register struct token *t;
  194. + {
  195. +     show_arg_names(t);                /* show argument names */
  196. +     put_nl();                    /* make output look nicer */
  197. +     show_arg_types(t);                /* show argument types */
  198. +     tok_free(t);                /* discard token */
  199. + }
  200. + 
  201. + /* fpf_header_names - define func returning ptr to func, no argument types */
  202. + 
  203. + static void fpf_header_names(list)
  204. + struct token *list;
  205. + {
  206. +     register struct token *s;
  207. +     register struct token *p;
  208. + 
  209. +     /*
  210. +      * Recurse until we find the argument list. Account for the rare case
  211. +      * that list is a comma-separated list (which should be a syntax error).
  212. +      * Display old-style fuction argument names.
  213. +      */
  214. + 
  215. +     for (s = list->head; s; s = s->next) {
  216. +     tok_show_ch(s);                /* '(' or ',' or ')' */
  217. +     for (p = s->head; p; p = p->next) {
  218. +         if (p->tokno == TOK_LIST) {
  219. +         if (IS_FUNC_PTR_TYPE(p)) {    /* recurse */
  220. +             fpf_header_names(p);
  221. +             show_empty_list(p = p->next);
  222. +         } else {            /* display argument names */
  223. +             show_arg_names(p);
  224. +         }
  225. +         } else {                /* pass through other stuff */
  226. +         tok_show(p);
  227. +         }
  228. +     }
  229. +     }
  230. + }
  231. + 
  232. + /* fpf_header_types - define func returning ptr to func, argument types only */
  233. + 
  234. + static void fpf_header_types(list)
  235. + struct token *list;
  236. + {
  237. +     register struct token *s;
  238. +     register struct token *p;
  239. + 
  240. +     /*
  241. +      * Recurse until we find the argument list. Account for the rare case
  242. +      * that list is a comma-separated list (which should be a syntax error).
  243. +      * Display old-style function argument types.
  244. +      */
  245. + 
  246. +     for (s = list->head; s; s = s->next) {
  247. +     for (p = s->head; p; p = p->next) {
  248. +         if (p->tokno == TOK_LIST) {
  249. +         if (IS_FUNC_PTR_TYPE(p)) {    /* recurse */
  250. +             fpf_header_types(p);
  251. +             p = p->next;
  252. +         } else {            /* display argument types */
  253. +             show_arg_types(p);
  254. +         }
  255. +         }
  256. +     }
  257. +     }
  258. + }
  259. + 
  260. + /* fpf_header - define function returning pointer to function */
  261. + 
  262. + static void fpf_header(l1, l2)
  263. + struct token *l1;
  264. + struct token *l2;
  265. + {
  266. +     fpf_header_names(l1);            /* strip argument types */
  267. +     show_empty_list(l2);            /* strip prototype */
  268. +     put_nl();                    /* nicer output */
  269. +     fpf_header_types(l1);            /* show argument types */
  270. + }
  271. + 
  272.   /* show_arg_name - extract argument name from argument type info */
  273.   
  274.   static void show_arg_name(s)
  275. ***************
  276. *** 413,423 ****
  277. --- 503,528 ----
  278.   {
  279.       register struct token *p;
  280.   
  281. +     /*
  282. +      * Rewrite (*stuff)(args) to (*stuff)(). Rewrite word(args) to word(),
  283. +      * but only if the word was preceded by a word, '*' or '}'. Leave
  284. +      * anything else alone.
  285. +      */
  286. + 
  287.       for (p = s->head; p; p = p->next) {
  288.       if (IS_FUNC_PTR_TYPE(p)) {
  289.           p = show_func_ptr_type(p, p->next);    /* function pointer type */
  290.       } else {
  291. +         register struct token *q;
  292. +         register struct token *r;
  293. + 
  294.           tok_show(p);            /* other */
  295. +         if ((p->tokno == TOK_WORD || p->tokno == '*' || p->tokno == '}')
  296. +         && (q = p->next) && q->tokno == TOK_WORD
  297. +         && (r = q->next) && r->tokno == TOK_LIST) {
  298. +         tok_show(q);            /* show name */
  299. +         show_empty_list(p = r);        /* strip args */
  300. +         }
  301.       }
  302.       }
  303.   }
  304. ***************
  305. *** 676,687 ****
  306.       }
  307.   }
  308.   
  309. ! /* func_ptr_dcl_flush - rewrite function pointer declaration */
  310.   
  311.   static struct token *func_ptr_dcl_flush(list)
  312.   register struct token *list;
  313.   {
  314.       register struct token *t;
  315.   
  316.       /*
  317.        * Ignore blanks and newlines because we are too lazy to maintain more
  318. --- 781,793 ----
  319.       }
  320.   }
  321.   
  322. ! /* func_ptr_dcl_flush - rewrite function pointer stuff */
  323.   
  324.   static struct token *func_ptr_dcl_flush(list)
  325.   register struct token *list;
  326.   {
  327.       register struct token *t;
  328. +     register struct token *t2;
  329.   
  330.       /*
  331.        * Ignore blanks and newlines because we are too lazy to maintain more
  332. ***************
  333. *** 696,705 ****
  334.           tok_free(t);
  335.           break;
  336.       case TOK_LIST:
  337. !         /* Function pointer type: (list1) (list2) -> (list1) () */
  338. !         (void) show_func_ptr_type(list, t);    /* may be recursive */
  339.           tok_free(list);
  340.           tok_free(t);
  341.           return (0);
  342.       default:                /* not a declaration */
  343.           tok_unget(t);
  344. --- 802,827 ----
  345.           tok_free(t);
  346.           break;
  347.       case TOK_LIST:
  348. !         /* Function pointer or function returning pointer to function. */
  349. !         while ((t2 = tok_class())        /* skip blanks etc. */
  350. !            &&(t2->tokno == TOK_WSPACE || t2->tokno == '\n'))
  351. !         tok_free(t2);
  352. !         switch (t2 ? t2->tokno : 0) {
  353. !         case '{':                /* function heading (new) */
  354. !         fpf_header(list, t);
  355. !         break;
  356. !         case TOK_WORD:            /* function heading (old) */
  357. !         tok_show(list);
  358. !         tok_show(t);
  359. !         break;
  360. !         default:                /* func pointer type */
  361. !         (void) show_func_ptr_type(list, t);
  362. !         break;
  363. !         }
  364.           tok_free(list);
  365.           tok_free(t);
  366. +         if (t2)
  367. +         tok_unget(t2);
  368.           return (0);
  369.       default:                /* not a declaration */
  370.           tok_unget(t);
  371. Prereq: 1.4
  372. *** ./README.old    Wed Jan 15 21:52:56 1992
  373. --- ./README    Sat Feb 15 17:17:02 1992
  374. ***************
  375. *** 1,4 ****
  376. ! @(#) README 1.4 92/01/15 21:52:54
  377.   
  378.   unproto - Compile ANSI C with traditional UNIX C compiler
  379.   
  380. --- 1,4 ----
  381. ! @(#) README 1.5 92/02/15 17:17:00
  382.   
  383.   unproto - Compile ANSI C with traditional UNIX C compiler
  384.   
  385. ***************
  386. *** 7,14 ****
  387.   
  388.   This is a filter that sits in between the UNIX C preprocessor and the
  389.   next UNIX C compiler stage, on the fly transforming ANSI C syntax to
  390. ! old C syntax.  It runs at roughly the same speed as /lib/cpp, so it 
  391. ! has negligible impact on compilation time.
  392.   
  393.   Typically, the program is invoked by the native UNIX C compiler as an
  394.   alternate preprocessor. The unprototyper in turn invokes the native C
  395. --- 7,15 ----
  396.   
  397.   This is a filter that sits in between the UNIX C preprocessor and the
  398.   next UNIX C compiler stage, on the fly transforming ANSI C syntax to
  399. ! old C syntax.  Line number information is preserved so that compiler
  400. ! diagnostics still make sense.  It runs at roughly the same speed as
  401. ! /lib/cpp, so it has negligible impact on compilation time.
  402.   
  403.   Typically, the program is invoked by the native UNIX C compiler as an
  404.   alternate preprocessor. The unprototyper in turn invokes the native C
  405. ***************
  406. *** 20,30 ****
  407.   Unlike some other unprototypers, this one is fully recursive and does
  408.   not depend on source file layout (see the example.c file).
  409.   
  410. ! New and improved functionality provided by the present version: string
  411. ! concatenation, conversion of \a and \x escape sequences to their octal
  412. ! equivalents, translation of __TIME__ and __DATE__, optional mapping of
  413. ! `void *' to `char *', optional mapping of plain `void' to `int', faster
  414. ! execution, and better conservation of program layout.
  415.   
  416.   The unprototyper provides hooks for compilers that require special
  417.   tricks for variadic functions (fortunately, many don't). <stdarg.h>
  418. --- 21,31 ----
  419.   Unlike some other unprototypers, this one is fully recursive and does
  420.   not depend on source file layout (see the example.c file).
  421.   
  422. ! Besides the rewriting of argument lists, the program does the following
  423. ! transformations:  string concatenation, conversion of \a and \x escape
  424. ! sequences to their octal equivalents, translation of the __TIME__ and
  425. ! __DATE__ macros, optional mapping of `void *' to `char *', and optional
  426. ! mapping of plain `void' to `int'. 
  427.   
  428.   The unprototyper provides hooks for compilers that require special
  429.   tricks for variadic functions (fortunately, many don't). <stdarg.h>
  430. ***************
  431. *** 43,67 ****
  432.   Problems fixed with this release:
  433.   ---------------------------------
  434.   
  435. ! Some multi-line statements could end up on a single output line, so
  436. ! that compiler diagnostics with respect to those statements could point
  437. ! to the wrong source-file position (other compiler diagnostics would not
  438. ! have this problem).  The token input/output routines were completely
  439. ! rewritten to eliminate these inconsistencies.
  440.   
  441. - Backslashes within comments were not given special treatment.  Since
  442. - the C preprocessor by default removes all comments this would almost
  443. - never have caused a problem.
  444. - 
  445. - A backslash in front of any token except newline was not given special
  446. - treatment. I have never seen any C code where this would have caused a
  447. - problem.
  448. - 
  449. - The program now returns a non-zero status if it detected any problems.
  450. - 
  451. - A couple of simple heuristics have been added so that the program may
  452. - now even be useful for the conversion of unpreprocessed source.
  453. - 
  454.   Operation:
  455.   ----------
  456.   
  457. --- 44,52 ----
  458.   Problems fixed with this release:
  459.   ---------------------------------
  460.   
  461. ! Prototypes and definitions of functions returning pointer to function
  462. ! were not rewritten to old style.
  463.   
  464.   Operation:
  465.   ----------
  466.   
  467. ***************
  468. *** 78,83 ****
  469. --- 63,78 ----
  470.   
  471.   Your C compiler manual page should provide the necessary information.
  472.   
  473. + A more portable, but less efficient, approach relies on the observation
  474. + that almost every UNIX C compiler supports the -E (write preprocessor
  475. + output to stdout) and -P options (preprocess file.c into file.i). Just
  476. + add the following lines to your Makefiles:
  477. + 
  478. +     .c.o:
  479. +         $(CC) $(CFLAGS) -E $*.c | unproto >$*.i # simulate -P option
  480. +         $(CC) $(CFLAGS) -c $*.i
  481. +         rm -f $*.i
  482. + 
  483.   On some systems the lint(1) command is just a shell script, and writing
  484.   a version that uses the unprototyper should not be too hard. With SunOS
  485.   4.x, /usr/bin/lint is not a shell script, but it does accept the same
  486. ***************
  487. *** 92,114 ****
  488.   
  489.   Check the contents of the `stdarg.h' file provided with this package.
  490.   This file serves a dual purpose: (1) on systems that do not provide a
  491. ! stdarg.h file, it should be included by C source files that implement
  492.   ANSI-style variadic functions; (2) it is also used to configure the
  493.   unprototyper so that it emits the proper magic when it sees `...'.
  494.   
  495.   The `stdarg.h' file has support for sparc, mips, and for compilers that
  496. ! pass arguments via the stack (old-style UNIX compilers for 80*86, mc68k
  497. ! and vax). It gives general hints for other compilers.
  498.   
  499.   The `varargs.c' file provided with this package can be used to verify
  500.   that the `stdarg.h' file has been set up correctly.
  501.   
  502. ! For maximal flexibility, the `cpp.sh' shell script can be used to set
  503. ! up the pipe between the native C preprocessor and the unprototyper
  504. ! command.  The script assumes that the unprototyper binary is called
  505. ! `unproto'.  See the Makefile and the `cpp.sh' script for details and
  506. ! for a description of possible problems with this approach.
  507.   
  508.   The overhead and problems of shell-script interpretation can be avoided
  509.   by letting the unprototyper itself pipe its standard input through the
  510.   C preprocessor.  For this mode of operation, the unprototyper binary
  511. --- 87,118 ----
  512.   
  513.   Check the contents of the `stdarg.h' file provided with this package.
  514.   This file serves a dual purpose: (1) on systems that do not provide a
  515. ! stdarg.h file, it should be included by C source files that implements
  516.   ANSI-style variadic functions; (2) it is also used to configure the
  517.   unprototyper so that it emits the proper magic when it sees `...'.
  518.   
  519.   The `stdarg.h' file has support for sparc, mips, and for compilers that
  520. ! pass arguments via the stack (typical for 80*86, mc68k and vax). It
  521. ! gives general hints for other compilers.
  522.   
  523. + The other sample header files (stddef.h and stdlib.h) are not required
  524. + to build the unprototyper.
  525. + 
  526.   The `varargs.c' file provided with this package can be used to verify
  527.   that the `stdarg.h' file has been set up correctly.
  528.   
  529. ! If your C compiler has no hooks for an alternate preprocessor (the
  530. ! unprototyper will be used as: `cc cflags -E file.c | unproto >file.i'),
  531. ! build the `unproto' executable without the `PIPE_THROUGH_CPP' feature.
  532. ! Details are given in the Makefile.
  533.   
  534. + Otherwise, the `cpp.sh' shell script can be used to set up the pipe
  535. + between the native C preprocessor and the unprototyper command.  The
  536. + script assumes that the unprototyper binary is called `unproto', and
  537. + that it was compiled without the `PIPE_THROUGH_CPP' feature.  See the
  538. + Makefile and the `cpp.sh' script for details and for a description of
  539. + possible problems with this approach.
  540. + 
  541.   The overhead and problems of shell-script interpretation can be avoided
  542.   by letting the unprototyper itself pipe its standard input through the
  543.   C preprocessor.  For this mode of operation, the unprototyper binary
  544. ***************
  545. *** 122,128 ****
  546.   
  547.   Install the `unproto.1' manual page in a suitable place. If your system
  548.   does not provide a `stdarg.h' file, find a suitable place for the one
  549. ! provided with the unprototyper and install it there.
  550.   
  551.   If you use the `cpp' shell script to pipe the preprocessor output
  552.   through the unprototyper program, install the `unproto' binary in a
  553. --- 126,142 ----
  554.   
  555.   Install the `unproto.1' manual page in a suitable place. If your system
  556.   does not provide a `stdarg.h' file, find a suitable place for the one
  557. ! provided with the unprototyper and install it there. The same goes for
  558. ! the sample stddef.h and stdlib.h files; make sure that the definitions
  559. ! in there apply to your environment. Most or all of the latter files are
  560. ! already part of Ultrix 4.x and SunOS 4.1.1.
  561. ! 
  562. ! The ANSI float.h and limits.h files can be generated with the config
  563. ! program by Steve Pemberton (comp.sources.misc volume 10, issue 62,
  564. ! available from ftp.uu.net as comp.sources.misc/volume10/config42.Z).
  565. ! 
  566. ! If you run the unprototyper with "cc -E" just install the `unproto'
  567. ! binary; the `cpp' shell script will not be needed.
  568.   
  569.   If you use the `cpp' shell script to pipe the preprocessor output
  570.   through the unprototyper program, install the `unproto' binary in a
  571. *** ./stdlib.h.old    Sat Feb 15 17:23:12 1992
  572. --- ./stdlib.h    Sat Feb 15 17:25:45 1992
  573. ***************
  574. *** 0 ****
  575. --- 1,53 ----
  576. + /* @(#) stdlib.h 1.1 92/02/15 17:25:45 */
  577. + 
  578. + #ifndef _stdlib_h_
  579. + #define _stdlib_h_
  580. + 
  581. + /* NULL is also defined in <stdio.h> */
  582. + 
  583. + #ifndef NULL
  584. + #define NULL    0
  585. + #endif
  586. + 
  587. + /*
  588. +  * Some functions in this file will be missing from the typical pre-ANSI
  589. +  * UNIX library. Some pre-ANSI UNIX library functions have return types
  590. +  * that differ from what ANSI requires.
  591. +  */
  592. + 
  593. + extern double atof();
  594. + extern int atoi();
  595. + extern long atol();
  596. + extern double strtod();
  597. + extern long strtol();
  598. + extern unsigned long strtoul();
  599. + extern int rand();
  600. + extern void srand();
  601. + extern char *calloc();
  602. + extern char *malloc();
  603. + extern char *realloc();
  604. + extern void free();
  605. + extern void abort();
  606. + extern void exit();
  607. + extern int atextit();
  608. + extern int system();
  609. + extern char *getenv();
  610. + extern char *bsearch();
  611. + extern void qsort();
  612. + extern int abs();
  613. + extern long labs();
  614. + 
  615. + typedef struct {
  616. +     int     quot;
  617. +     int     rem;
  618. + } div_t;
  619. + 
  620. + typedef struct {
  621. +     long    quot;
  622. +     long    rem;
  623. + } ldiv_t;
  624. + 
  625. + extern div_t div();
  626. + extern ldiv_t ldiv();
  627. + 
  628. + #endif /* _stdlib_h_ */
  629. Prereq: 1.4
  630. *** ./Makefile.old    Wed Jan 15 21:53:22 1992
  631. --- ./Makefile    Sat Feb 15 17:17:04 1992
  632. ***************
  633. *** 1,19 ****
  634. ! # @(#) Makefile 1.4 92/01/15 21:53:20
  635.   
  636.   ## BEGIN CONFIGURATION STUFF
  637.   
  638. ! # For maximal flexibility, the "/lib/cpp | unproto" pipeline can be
  639. ! # packaged as an executable shell script (see the provided "cpp.sh" script)
  640. ! # that should be installed as "/whatever/cpp". This script should then be
  641. ! # specified to the C compiler as a non-default preprocessor.
  642.   #
  643.   # PROG    = unproto
  644.   # PIPE    =
  645.   
  646. ! # For maximal performance, the overhead of shell script interpretation can
  647. ! # be eliminated by having the unprototyper program itself open the pipe
  648. ! # to the preprocessor.  In that case, define the PIPE_THROUGH_CPP macro
  649. ! # as the path name of the default C preprocessor (usually "/lib/cpp"),
  650.   # install the unprototyper as "/whatever/cpp" and specify that to the C
  651.   # compiler as a non-default preprocessor.
  652.   #
  653. --- 1,24 ----
  654. ! # @(#) Makefile 1.5 92/02/15 17:17:03
  655.   
  656.   ## BEGIN CONFIGURATION STUFF
  657.   
  658. ! # In the unlikely case that your compiler has no hooks for alternate
  659. ! # compiler passes, use a "cc cflags -E file.c | unproto >file.i"
  660. ! # pipeline, then "cc cflags -c file.i" to compile the resulting
  661. ! # intermediate file.
  662. ! # 
  663. ! # Otherwise, the "/lib/cpp | unproto" pipeline can be packaged as an
  664. ! # executable shell script (see the provided "cpp.sh" script) that should
  665. ! # be installed as "/whatever/cpp". This script should then be specified
  666. ! # to the C compiler as a non-default preprocessor.
  667.   #
  668.   # PROG    = unproto
  669.   # PIPE    =
  670.   
  671. ! # The overhead and problems of shell script interpretation can be
  672. ! # eliminated by having the unprototyper program itself open the pipe to
  673. ! # the preprocessor.  In that case, define the PIPE_THROUGH_CPP macro as
  674. ! # the path name of the default C preprocessor (usually "/lib/cpp"),
  675.   # install the unprototyper as "/whatever/cpp" and specify that to the C
  676.   # compiler as a non-default preprocessor.
  677.   #
  678. ***************
  679. *** 70,76 ****
  680.       hash.c strsave.c
  681.   HFILES    = error.h token.h vstring.h symbol.h
  682.   SCRIPTS    = cpp.sh
  683. ! SAMPLES    = stdarg.h varargs.c example.c example.out
  684.   SOURCES    = README $(CFILES) $(HFILES) Makefile $(SCRIPTS) $(SAMPLES)
  685.   FILES    = $(SOURCES) unproto.1
  686.   OBJECTS    = tok_io.o tok_class.o tok_pool.o unproto.o vstring.o symbol.o error.o \
  687. --- 75,81 ----
  688.       hash.c strsave.c
  689.   HFILES    = error.h token.h vstring.h symbol.h
  690.   SCRIPTS    = cpp.sh
  691. ! SAMPLES    = stdarg.h stddef.h stdlib.h varargs.c example.c example.out
  692.   SOURCES    = README $(CFILES) $(HFILES) Makefile $(SCRIPTS) $(SAMPLES)
  693.   FILES    = $(SOURCES) unproto.1
  694.   OBJECTS    = tok_io.o tok_class.o tok_pool.o unproto.o vstring.o symbol.o error.o \
  695. ***************
  696. *** 81,87 ****
  697.   #CFLAGS    = -g $(PIPE) $(SKIP) $(BELL) $(MAP) $(ALIAS) -DDEBUG
  698.   
  699.   $(PROG): $(OBJECTS)
  700. !     cc $(CFLAGS) -o $@ $(OBJECTS) $(MALLOC)
  701.   
  702.   # For linting, enable all bells and whistles.
  703.   
  704. --- 86,92 ----
  705.   #CFLAGS    = -g $(PIPE) $(SKIP) $(BELL) $(MAP) $(ALIAS) -DDEBUG
  706.   
  707.   $(PROG): $(OBJECTS)
  708. !     $(CC) $(CFLAGS) -o $@ $(OBJECTS) $(MALLOC)
  709.   
  710.   # For linting, enable all bells and whistles.
  711.   
  712. *** ./example.out.old    Wed Jan 15 22:04:24 1992
  713. --- ./example.out    Sat Feb 15 17:17:09 1992
  714. ***************
  715. *** 48,58 ****
  716.   # 38 "example.c"
  717.   int (*(*bar)())();
  718.   {/*1*/
  719. !     int     (*baz)() = (int (*)()) 0,
  720.           y = (y * (*baz)(y)),
  721. !         *(*z)() = (int *(*)()) 0;
  722.   
  723. !     struct {/*2*/ int (*foo)(); }/*2*/ *(*s)() = 
  724.       (struct { int (*foo)(); } *(*)()) 0;
  725.   
  726.       /* end dcls */{/*2*/
  727. --- 48,58 ----
  728.   # 38 "example.c"
  729.   int (*(*bar)())();
  730.   {/*1*/
  731. !     int     (*baz)()= (int (*)()) 0,
  732.           y = (y * (*baz)(y)),
  733. !         *(*z)()= (int *(*)()) 0;
  734.   
  735. !     struct {/*2*/ int (*foo)(); }/*2*/ *(*s)()= 
  736.       (struct { int (*foo)(); } *(*)()) 0;
  737.   
  738.       /* end dcls */{/*2*/
  739. ***************
  740. *** 122,128 ****
  741.       struct {/*2*/
  742.       int (*f)(), o;
  743.       }/*2*/ bar;
  744. ! }/*1*/ (*baz2)() = (struct { struct { int (*f)(), o; } bar; } (*)()) 0;
  745.   
  746.   
  747.   
  748. --- 122,128 ----
  749.       struct {/*2*/
  750.       int (*f)(), o;
  751.       }/*2*/ bar;
  752. ! }/*1*/ (*baz2)()= (struct { struct { int (*f)(), o; } bar; } (*)()) 0;
  753.   
  754.   
  755.   
  756. ***************
  757. *** 218,222 ****
  758.   # 186 "example.c"
  759.   {/*1*/}/*1*/
  760.   
  761. ! int (*(*test18[bar])())() =     (int (*(*[bar])())()) 0;
  762.   
  763. --- 218,261 ----
  764.   # 186 "example.c"
  765.   {/*1*/}/*1*/
  766.   
  767. ! int (*(*test18[bar])())()=     (int (*(*[bar])())()) 0;
  768.   
  769. + 
  770. + 
  771. + 
  772. + int (*(*test19())())();
  773. + 
  774. + 
  775. + 
  776. + void test20(test21)
  777. + # 197 "example.c"
  778. + int test21();
  779. + # 197 "example.c"
  780. + {/*1*/}/*1*/
  781. + 
  782. + void test22(test23)
  783. + # 199 "example.c"
  784. + struct { int foo; } test23();
  785. + # 199 "example.c"
  786. + {/*1*/}/*1*/
  787. + 
  788. + 
  789. + 
  790. + void    test23()
  791. + {/*1*/
  792. +     int     (*test24())(),
  793. +             y = (*test24(2)) (3),
  794. +             z = ((*test24(2))(3));
  795. + }/*1*/
  796. + 
  797. + 
  798. + 
  799. + int (*(*test25(foo))())()
  800. + # 212 "example.c"
  801. + long foo;
  802. + # 212 "example.c"
  803. + {/*1*/  }/*1*/
  804. + 
  805. + int (*(*test26(foo))())()
  806. + long foo;
  807. + {/*1*/  }/*1*/
  808. Prereq: 1.4
  809. *** ./unproto.1.old    Wed Jan 15 21:53:22 1992
  810. --- ./unproto.1    Sat Feb 15 17:17:20 1992
  811. ***************
  812. *** 13,18 ****
  813. --- 13,20 ----
  814.   .na
  815.   .nf
  816.   /somewhere/cpp ...
  817. + 
  818. + cc cflags -E file.c | unproto >file.i; cc cflags -c file.i
  819.   .SH DESCRIPTION
  820.   .ad
  821.   .fi
  822. ***************
  823. *** 143,150 ****
  824.   .SH LAST MODIFICATION
  825.   .na
  826.   .nf
  827. ! 92/01/15 21:52:56
  828.   .SH VERSION/RELEASE
  829.   .na
  830.   .nf
  831. ! 1.4
  832. --- 145,152 ----
  833.   .SH LAST MODIFICATION
  834.   .na
  835.   .nf
  836. ! 92/02/15 17:17:09
  837.   .SH VERSION/RELEASE
  838.   .na
  839.   .nf
  840. ! 1.5
  841. *** ./stddef.h.old    Sat Feb 15 17:23:12 1992
  842. --- ./stddef.h    Sat Feb 15 17:25:47 1992
  843. ***************
  844. *** 0 ****
  845. --- 1,23 ----
  846. + /* @(#) stddef.h 1.1 92/02/15 17:25:46 */
  847. + 
  848. + #ifndef _stddef_h_
  849. + #define _stddef_h_
  850. + 
  851. + /* NULL is also defined in <stdio.h> */
  852. + 
  853. + #ifndef NULL
  854. + #define NULL 0
  855. + #endif
  856. + 
  857. + /* Structure member offset - some compilers barf on this. */
  858. + 
  859. + #define offsetof(type, member) ((size_t) &((type *)0)->member)
  860. + 
  861. + /* Some of the following types may already be defined in <sys/types.h>. */
  862. + 
  863. + /* #include <sys/types.h> */
  864. + /* typedef long ptrdiff_t;        /* type of pointer difference */
  865. + /* typedef unsigned short wchar_t;    /* wide character type */
  866. + /* typedef unsigned size_t;        /* type of sizeof */
  867. + 
  868. + #endif /* _stddef_h_ */
  869. Prereq: 1.3
  870. *** symbol.c.old    Wed Jan 15 21:53:09 1992
  871. --- symbol.c    Sat Feb 15 18:59:58 1992
  872. ***************
  873. *** 33,44 ****
  874.   /*    Department of Mathematics and Computer Science
  875.   /*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  876.   /* LAST MODIFICATION
  877. ! /*    92/01/15 21:53:08
  878.   /* VERSION/RELEASE
  879. ! /*    1.3
  880.   /*--*/
  881.   
  882. ! static char symbol_sccsid[] = "@(#) symbol.c 1.3 92/01/15 21:53:08";
  883.   
  884.   /* C library */
  885.   
  886. --- 33,44 ----
  887.   /*    Department of Mathematics and Computer Science
  888.   /*    Den Dolech 2, P.O. Box 513, 5600 MB Eindhoven, The Netherlands
  889.   /* LAST MODIFICATION
  890. ! /*    92/02/15 18:59:56
  891.   /* VERSION/RELEASE
  892. ! /*    1.4
  893.   /*--*/
  894.   
  895. ! static char symbol_sccsid[] = "@(#) symbol.c 1.4 92/02/15 18:59:56";
  896.   
  897.   /* C library */
  898.   
  899. ***************
  900. *** 128,133 ****
  901. --- 128,134 ----
  902.   #if defined(MAP_VOID_STAR) || defined(MAP_VOID)
  903.       "void", TOK_VOID,
  904.   #endif
  905. +     "asm", TOK_OTHER,
  906.       0,
  907.   };
  908.   
  909.  
  910. exit 0 # Just in case...
  911.