home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cproto.zip / cproto46 / testing / case13.ref < prev    next >
Text File  |  1996-05-30  |  3KB  |  216 lines
  1. /* LINTLIBRARY */
  2.  
  3. /* case13.c */
  4.  
  5. static    x2;
  6.  
  7. typedef    int    x4t;
  8.  
  9. char    x6;
  10. short    x7;
  11. int    x8;
  12. long    x9;
  13. float    x10;
  14. double    x11;
  15. signed    x12;
  16. unsigned x13;
  17.  
  18. struct x14;
  19.  
  20. union x15;
  21.  
  22. enum x16;
  23.  
  24. x4t;
  25.  
  26. x4t    x17;
  27. const    x18 = {0};
  28. volatile x19;
  29.  
  30. typedef    struct    _first    {
  31.     int        a:5;
  32.     struct    {
  33.         int    a,b;
  34.     } b_struct;
  35.     char        b:16, b1:1;    
  36.     long        c:16, c1;
  37.     short        d:16, d1:8, d2;
  38.     unsigned    e:16;
  39.     float        f;
  40.     double        g;
  41.     struct    _first    *link;
  42.     }    _FIRST;
  43.  
  44. _FIRST    first;
  45. _FIRST    last;
  46. _FIRST    first_last[];
  47. struct    _second    {
  48.         enum    {true, false} bool;
  49.         enum    {wrong=1, right=3} values;
  50.     } _SECOND;
  51. int    i[];
  52. float    f[];
  53. int    array[][10][20];
  54.  
  55. int    dots_0(p1)
  56.         int    p1;
  57.         { return(*(int *)0); }
  58.  
  59.     /* VARARGS1 */
  60. int    dots_1(p1)
  61.         int    p1;
  62.         { return(*(int *)0); }
  63.  
  64.     /* VARARGS2 */
  65. int    dots_3(p1, p2)
  66.         int    p1;
  67.         char    p2;
  68.         { return(*(int *)0); }
  69.  
  70. _FIRST    *func1()
  71.         { return(*(_FIRST **)0); }
  72.  
  73. _FIRST    *func2(p1, p2, p)
  74.         _FIRST    *p1;
  75.         int    p2[];
  76.         float    p;
  77.         { return(*(_FIRST **)0); }
  78.  
  79. int    *(func_func)();
  80.  
  81. typedef    int    bool;
  82.  
  83. bool    a1;
  84. static bool a2;
  85.  
  86. struct    ZIP1    { int x1, y1; };
  87.  
  88. struct    zip2    { int x2, y2; } z2;
  89. struct        { int x3, y3; } z3;
  90.  
  91. struct    ZIP4    { int x4, y4; };
  92.  
  93. static struct    zip5    { int x5, y5; } z5;
  94. static struct    zip6    { int x6, y6; } z6;
  95. static struct    zip6    { int x6, y6; } w6;
  96. static struct        { int x7, y7; } z7;
  97. static struct        { int x8, y8; } z8;
  98. static struct        { int x8, y8; } w8;
  99. enum    zap1    { a,b,c,d } what;
  100. enum zap2 what2;
  101. enum        {a9,b9,c9,d9} what3;
  102. static char *zap;
  103.  
  104. typedef    struct    bong    {
  105.     int    (*func)();
  106.     } BONG;
  107.  
  108. typedef    char    *string;
  109.  
  110. void    main(argc, argv)
  111.         int    argc;
  112.         char    **argv;
  113.         { /* void */ }
  114.  
  115.     /* VARARGS */
  116. int    veryfunny(a, b, c)
  117.         char    *a;
  118.         long    b;
  119.         long    c;
  120.         { return(*(int *)0); }
  121.  
  122.     /* VARARGS3 */
  123. int    program(argv, y, zz, z1, z2, z3)
  124.         string    argv[];
  125.         struct    alpha { int x,z; } y;
  126.         int    zz;
  127.         int    z1;
  128.         int    z2;
  129.         int    z3;
  130.         { return(*(int *)0); }
  131.  
  132. void    junk0()
  133.         { /* void */ }
  134.  
  135. int    junk1()
  136.         { return(*(int *)0); }
  137.  
  138. void    junk2()
  139.         { /* void */ }
  140.  
  141. int    junk3()
  142.         { return(*(int *)0); }
  143.  
  144. BONG    *junk4()
  145.         { return(*(BONG **)0); }
  146.  
  147. typedef    int    extern_junk;
  148.  
  149. extern_junk *foo()
  150.         { return(*(extern_junk **)0); }
  151.  
  152. typedef    int    void_junk;
  153.  
  154. void_junk *foo2a()
  155.         { return(*(void_junk **)0); }
  156.  
  157. void_junk *foo2()
  158.         { return(*(void_junk **)0); }
  159.  
  160. void_junk *foo_void(void_int)
  161.         void_junk void_int;
  162.         { return(*(void_junk **)0); }
  163.  
  164. static void_junk *foo_void2()
  165.         { return(*(void_junk **)0); }
  166.  
  167. void    (*Sigdisp(sig, func))()
  168.         int    sig;
  169.         void    (*func)();
  170.         { return(*(void(*)())0); }
  171.  
  172. void    (*sigdisp2(sig, func))()
  173.         int    sig;
  174.         void    (*func)();
  175.         { return(*(void(*)())0); }
  176.  
  177. int    (*K_R_INT_ptr(p1, p2))()
  178.         long    *p1;
  179.         int    p2;
  180.         { return(*(int(*)())0); }
  181.  
  182. void    (*K_R_VOID_ptr(p1, p2))()
  183.         long    *p1;
  184.         int    p2;
  185.         { return(*(void(*)())0); }
  186.  
  187. int    *K_R_int_ptr(p1, p2)
  188.         long    *p1;
  189.         int    p2;
  190.         { return(*(int **)0); }
  191.  
  192. void    *K_R_void_ptr(p1, p2)
  193.         long    *p1;
  194.         int    p2;
  195.         { return(*(void **)0); }
  196.  
  197. int    K_R_int_val(p1, p2)
  198.         long    *p1;
  199.         int    p2;
  200.         { return(*(int *)0); }
  201.  
  202. int    K_R_int_val2(p1, p2)
  203.         long    *p1;
  204.         int    p2;
  205.         { return(*(int *)0); }
  206.  
  207. void    K_R_void_val(p1, p2)
  208.         long    *p1;
  209.         int    p2;
  210.         { /* void */ }
  211.  
  212. void    K_R_void_val2(p1, p2)
  213.         long    *p1;
  214.         int    p2;
  215.         { /* void */ }
  216.