![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to szal2.1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront|
Return to szal2.1.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront |
1.1 root 1: /*ident "@(#)ctrans:szal.c 1.4.1.2" */
2: /*******************************************************************
3:
4: Copyright (c) 1986 AT&T, Inc. All Rights Reserved
5: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
6:
7: szal.c:
8:
9: C program to run on a machine to write a size/align file for
10: the C++ translator.
11:
12: Most output line are on the form:
13: typeX sizeof(typeX) alignment_requirement_for_typeX
14: assumes
15:
16: - that ``double d0; char c0;'' poses the worst alignment condition
17: - two's complement integer representation
18: - that a word is defined by a :0 field
19:
20: *****************************************************************************/
21:
22: #include <stdio.h>
23:
24: typedef int (*PF)();
25: struct st1 { char a; };
26: struct ss {
27: double a0; char c0;
28: char c1;
29: double a00; char c00;
30: short s1;
31: double a2; char c2;
32: int i1;
33: double a3; char c3;
34: long l1;
35: double a4; char c4;
36: float f1;
37: double a6; char c5;
38: double d1;
39: double a7; char c6;
40: char* p1;
41: double a8; char c7;
42: struct ss * p2;
43: double a9; char c8;
44: struct st1 oo;
45: double a10; char c9;
46: PF pf;
47: } oo;
48: struct st5 { char a; int :0; }; /* by definition: a word */
49: struct st2 { char :2; };
50: struct st3 { int :2; };
51: struct st4 { char :2; char :2; };
52:
53: struct st6 { char v[3]; char : 2; }; /* fits in 4 bytes */
54: struct st7 { char v[3]; int : 2; }; /* might not */
55: struct st8 { char v[3]; char : 2; char : 2; };
56:
57: struct st9 { char v[7]; char : 2; }; /* fits in 8 bytes */
58: struct st10 { char v[7]; int : 2; }; /* might not */
59: struct st11 { char v[7]; char : 2; char : 2; };
60:
61: out(s,a1) char* s; int a1;
62: {
63: printf("%s %d\n",s,a1);
64: }
65:
66: outstr(s,str2) char* s; char* str2;
67: {
68: printf("%s \"%s\"\n",s,str2);
69: }
70:
71: int a123456789 = 1; /* if this does not compile get a better C compiler */
72: int a123456780 = 2;
73:
74:
75: main()
76: {
77: char largest[50];
78: char c = 1;
79: int i1 = 0;
80: int i2 = 0;
81: long i = 1L;
82: unsigned int large;
83:
84: if (a123456789 == a123456780)
85: fprintf(stderr,"Warning: Your C compiler is dangerous.\nIt strips trailing characters off long identifiers without warning.\nGet a new one\n");
86:
87: while (c) { c<<=1; c&=~1; i1++; } /* i1 = #bits in byte */
88:
89: if (sizeof(struct st5) == sizeof(char)) /* i2 = #bits in word */
90: i2 = i1;
91: else if (sizeof(struct st5) == sizeof(short)) {
92: short i = 1;
93: while (i) { i<<=1; i&=~1; i2++; }
94: }
95: else if (sizeof(struct st5) == sizeof(int))
96: while (i) { i<<=1; i&=~1; i2++; }
97: else if (sizeof(struct st5) == sizeof(long)) {
98: long i = 1;
99: while (i) { i<<=1; i&=~1; i2++; }
100: }
101: else {
102: fprintf(stderr,"Warning: Your C compiler probably handles 0 lengths fields wrong\n");
103: i = sizeof(int);
104: }
105:
106: out("#define DBI_IN_WORD",i2);
107: out("#define DBI_IN_BYTE",i1);
108: out("#define DSZ_CHAR",sizeof(char));
109: out("#define DAL_CHAR",(int)&oo.c1-(int)&oo.c0);
110: out("#define DSZ_SHORT",sizeof(short));
111: out("#define DAL_SHORT",(int)&oo.s1-(int)&oo.c00);
112: out("#define DSZ_INT",sizeof(int));
113: out("#define DAL_INT",(int)&oo.i1-(int)&oo.c2);
114: out("#define DSZ_LONG",sizeof(long));
115: out("#define DAL_LONG",(int)&oo.l1-(int)&oo.c3);
116: out("#define DSZ_FLOAT",sizeof(float));
117: out("#define DAL_FLOAT",(int)&oo.f1-(int)&oo.c4);
118: out("#define DSZ_DOUBLE",sizeof(double));
119: out("#define DAL_DOUBLE",(int)&oo.d1-(int)&oo.c5);
120: /* next two should just be repeats of above two */
121: out("#define DSZ_LDOUBLE",sizeof(double));
122: out("#define DAL_LDOUBLE",(int)&oo.d1-(int)&oo.c5);
123: i = 1<<(sizeof(char*)*i1-2);
124: if (i<400*1024L)
125: fprintf(stderr,"Pointers to data too small to handle C++\n");
126:
127: i = 1<<(sizeof(PF)*i1-2);
128: if (i<250*1024L)
129: fprintf(stderr,"Pointers to functions too small to handle C++\n");
130: /* out("fptr",sizeof(PF),(int)&oo.pf-(int)&oo.c9,0); */
131: if (sizeof(PF)!=sizeof(struct ss*))
132: fprintf(stderr,"Cannot handle sizeof(pointer to function) != sizeof(pointer to struct)\n");
133: out("#define DSZ_STRUCT",sizeof(struct st1));
134: out("#define DAL_STRUCT",(int)&oo.oo-(int)&oo.c8);
135: out("#define DSZ_WORD",sizeof(struct st5));
136: out("#define DSZ_WPTR",sizeof(struct ss *));
137: out("#define DAL_WPTR",(int)&oo.p2-(int)&oo.c7);
138: out("#define DSZ_BPTR",sizeof(char*));
139: out("#define DAL_BPTR",(int)&oo.p1-(int)&oo.c6);
140: large = (unsigned)~0;
141: large = large >> 1;
142: sprintf(largest,"%d",large); /* largest integer */
143: outstr("#define DLARGEST_INT",largest);
144: switch (sizeof(struct st1)) {
145: case 1:
146: i1 = sizeof(struct st2)!=sizeof(struct st3);
147: i2 = sizeof(struct st2)==sizeof(struct st4);
148: break;
149: case 2:
150: i1 = sizeof(struct st6)!=sizeof(struct st7);
151: i2 = sizeof(struct st6)==sizeof(struct st8);
152: break;
153: case 4:
154: i1 = sizeof(struct st9)!=sizeof(struct st10);
155: i2 = sizeof(struct st9)==sizeof(struct st11);
156: break;
157: default:
158: fprintf(stderr,"Cannot figure out if field sizes are sensitive to the type of fields\n");
159: }
160: out("#define DF_SENSITIVE",i1); /* sensitive to field type */
161: out("#define DF_OPTIMIZED",i2); /* packs fields */
162: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.