← Back to branch summary

~ubuntu-branches/ubuntu/vivid/cproto/vivid-proposed

« back to all changes in this revision

Viewing changes to testing/case13.ref

  • Committer: Bazaar Package Importer
  • Author(s): Kenneth J. Pronovici
  • Date: 2004-03-30 19:58:33 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040330195833-loh9sgce2as79j67
Tags: 4.7c-1
http://bugs.debian.org/235824
* New upstream release.
  - Includes equivalent of patch as used to close #228801 (see below).
  - Supports -X option to filter out unwanted definitions (closes: #235824).
* Now configure using --enable-llib option, so we don't need lint installed.
* Added gcc to Depends: line since -X option requires GCC to work; I assume
  most users will already have gcc installed anyway, if they are developers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
testing/case13.ref
4
4
 
5
5
static  x2;
6
6
 
7
 
typedef int     x4t;
 
7
typedef int x4t;
8
8
 
9
9
char    x6;
10
10
short   x7;
27
27
const   x18 = {0};
28
28
volatile x19;
29
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;
 
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
43
 
44
44
typedef int badStyle;
45
45
 
50
50
_FIRST  first;
51
51
_FIRST  last;
52
52
_FIRST  first_last[];
53
 
struct  _second {
54
 
                enum    {true, false} bool;
55
 
                enum    {wrong=1, right=3} values;
56
 
        } _SECOND;
 
53
struct _second {
 
54
                enum {true, false} bool;
 
55
                enum {wrong=1, right=3} values;
 
56
        } _SECOND;
57
57
int     i[];
58
58
float   f[];
59
59
int     array[][10][20];
84
84
 
85
85
int     *(func_func)();
86
86
 
87
 
typedef int     bool;
 
87
typedef int bool;
88
88
 
89
89
bool    a1;
90
90
static bool a2;
91
91
 
92
 
struct  ZIP1    { int x1, y1; };
93
 
 
94
 
struct  zip2    { int x2, y2; } z2;
95
 
struct          { int x3, y3; } z3;
96
 
 
97
 
struct  ZIP4    { int x4, y4; };
98
 
 
99
 
static struct   zip5    { int x5, y5; } z5;
100
 
static struct   zip6    { int x6, y6; } z6;
101
 
static struct   zip6    { int x6, y6; } w6;
102
 
static struct           { int x7, y7; } z7;
103
 
static struct           { int x8, y8; } z8;
104
 
static struct           { int x8, y8; } w8;
105
 
enum    zap1    { a,b,c,d } what;
 
92
struct ZIP1 { int x1, y1; };
 
93
 
 
94
struct zip2 { int x2, y2; } z2;
 
95
struct { int x3, y3; } z3;
 
96
 
 
97
struct ZIP4 { int x4, y4; };
 
98
 
 
99
static struct zip5 { int x5, y5; } z5;
 
100
static struct zip6 { int x6, y6; } z6;
 
101
static struct zip6 { int x6, y6; } w6;
 
102
static struct { int x7, y7; } z7;
 
103
static struct { int x8, y8; } z8;
 
104
static struct { int x8, y8; } w8;
 
105
enum zap1 { a,b,c,d } what;
106
106
enum zap2 what2;
107
 
enum            {a9,b9,c9,d9} what3;
 
107
enum {a9,b9,c9,d9} what3;
108
108
static char *zap;
109
109
 
110
 
typedef struct  bong    {
111
 
        int     (*func)();
112
 
        } BONG;
 
110
typedef struct bong {
 
111
        int (*func)();
 
112
        } BONG;
113
113
 
114
 
typedef char    *string;
 
114
typedef char *string;
115
115
 
116
116
void    main(argc, argv)
117
117
                int     argc;
128
128
        /* VARARGS3 */
129
129
int     program(argv, y, zz, z1, z2, z3)
130
130
                string  argv[];
131
 
                struct  alpha { int x,z; } y;
 
131
                struct alpha { int x,z; } y;
132
132
                int     zz;
133
133
                int     z1;
134
134
                int     z2;
150
150
BONG    *junk4()
151
151
                { return(*(BONG **)0); }
152
152
 
153
 
typedef int     extern_junk;
 
153
typedef int extern_junk;
154
154
 
155
155
extern_junk *foo()
156
156
                { return(*(extern_junk **)0); }
157
157
 
158
 
typedef int     void_junk;
 
158
typedef int void_junk;
159
159
 
160
160
void_junk *foo2a()
161
161
                { return(*(void_junk **)0); }