| blob | 769b538e542d0ae899665b3617dfda59a4a898ae |
18 };
22 {
24 /* This program performs a series of tests on a C compiler,
25 based on information in the
27 C REFERENCE MANUAL
29 which appears as Appendix A to the book "The C Programming
30 Language" by Brian W. Kernighan and Dennis M. Ritchie
31 (Prentice-Hall, 1978, $10.95). This Appendix is hereafter
32 referred to as "the Manual".
34 The rules followed in writing this program are:
36 1. The entire program is written in legal C, according
37 to the Manual. It should compile with no error messages,
38 although some warning messages may be produced by some
39 compilers. Failure to compile should be interpreted as
40 a compiler error.
42 2. The program is clean, in that it does not make use
43 of any features of the operating system on which it runs,
44 with the sole exceptions of the printf() function, and an
45 internal "options" routine, which is easily excised.
47 3. No global variables are used, except for the spec-
48 ific purpose of testing the global variable facility.
50 The program is divided into modules having names of the
51 form snnn... These modules correspond to those sections of the
52 Manual, as identified by boldface type headings, in which
53 there is something to test. For example, s241() corresponds
54 to section 2.4.1 of the Manual (Integer constants) and tests
55 the facilities described therein. The module numbering
56 scheme is ambiguous, especially when it names modules
57 referring to more than one section; module s7813, for ex-
58 ample, deals with sections 7.8 through 7.13. Nonetheless,
59 it is surprisingly easy to find a section in the Manual
60 corresponding to a section of code, and vice versa.
62 Note also that there seem to be "holes" in the program,
63 at least from the point of view that there exist sections in the
64 Manual for which there is no corresponding code. Such holes
65 arise from three causes: (a) there is nothing in that partic-
66 ular section to test, (b) everything in that section is tested
67 elsewhere, and (c) it was deemed advisable not to check cer-
68 tain features like preprocessor or listing control features.
70 Modules are called by a main program main(). The mod-
71 ules that are called, and the sequence in which they are
72 called, are determined by two lists in main(), in which the
73 module names appear. The first list (an extern statement)
74 declares the module names to be external. The second (a stat-
75 ic int statement) names the modules and defines the sequence
76 in which they are called. There is no need for these lists
77 to be in the same order, but it is probably a good idea to keep
78 them that way in the interest of clarity. Since there are no
79 cross-linkages between modules, new modules may be added,
80 or old ones deleted, simply by editing the lists, with one
81 exception: section s26, which pokes around at the hardware
82 trying to figure out the characteristics of the machine that
83 it is running on, saves information that is subsequently
84 used by sections s626, s72, and s757. If this program is
85 to be broken up into smallish pieces, say for running on
86 a microcomputer, take care to see that s26 is called before
87 calling any of the latter three sections. The size
88 of the lists, i.e., the number of modules to be called, is
89 not explicitly specified as a program parameter, but is
90 determined dynamically using the sizeof operator.
92 Communication between the main program and the modules
93 takes place in two ways. In all cases, a pointer to a structure
94 is passed to the called module. The structure contains flags
95 that will determine the type of information to be published
96 by the module, and fields that may be written in by the
97 module. The former include "flgm" and "flgd", which, if set
98 to a nonzero value, specify that machine dependencies are to
99 be announced or that error messages are to be printed, re-
100 spectively. The called module's name, and the hardware char-
101 acteristics probed in s26() comprise the latter.
104 Also, in all cases, a return code is returned by the called
105 module. A return code of zero indicates that all has gone well;
106 nonzero indicates otherwise. Since more than one type of error
107 may be detected by a module, the return code is a composite
108 of error indicators, which, individually, are given as numbers
109 that are powers of two. Thus, a return code of 10 indicates
110 that two specific errors, 8 and 2, were detected. Whether or
111 not the codes returned by the modules are printed by the main
112 program is determined by setting "flgs" to 1 (resp. 0).
114 The entire logic of the main program is contained in the
115 half-dozen or so lines at the end. The somewhat cryptic
116 statement:
118 d0.rrc = (*sec[j])(pd0);
120 in the for loop calls the modules. The rest of the code is
121 reasonably straightforward.
123 Finally, in each of the modules, there is the following
124 prologue:
126 snnn(pd0)
127 struct defs *pd0;
128 {
129 static char snnner[] = "snnn,er%d\n";
130 static char qsnnn[8] = "snnn ";
131 char *ps, *pt;
132 int rc;
134 rc = 0;
135 ps = qsnnn;
136 pt = pd0->rfs;
137 while(*pt++ = *ps++);
139 used for housekeeping, handshaking and module initialization.
141 */
142 extern
164 ;
168 s22,
169 s241,
170 s243,
171 s244,
172 s25,
173 s26,
174 s4,
175 s61,
176 s626,
177 s71,
178 s72,
179 s757,
180 s7813,
181 s714,
182 s715,
183 s81,
184 s84,
185 s85,
186 s86,
187 s88,
188 s9
189 };
204 }
209 }
212 {
220 /* Initialize */
227 /* An identifier is a sequence of letters and digits;
228 the first character must be a letter. The under-
229 score _ counts as a letter. */
238 }
240 /* Upper and lower case letters are different. */
246 }
249 }
251 2.4.2 Explicit long constants */
253 {
270 /* An integer constant consisting of a sequence of digits is
271 taken to be octal if it begins with 0 (digit zero), decimal
272 otherwise. */
297 }
299 /* A sequence of digits preceded by 0x or 0X (digit zero)
300 is taken to be a hexadecimal integer. The hexadecimal
301 digits include a or A through f or F with values 10
302 through 15. */
312 }
314 /* A decimal constant whose value exceeds the largest signed
315 machine integer is taken to be long; an octal or hex con-
316 stant which exceeds the largest unsigned machine integer
317 is likewise taken to be long. */
325 }
327 /* A decimal, octal, or hexadecimal constant immediately followed
328 by l (letter ell) or L is a long constant. */
339 }
341 /* Finally, we test to see that decimal (d), octal (o),
342 and hexadecimal (x) constants representing the same values
343 agree among themselves, and with computed values, at spec-
344 ified points over an appropriate range. The points select-
345 ed here are those with the greatest potential for caus-
346 ing trouble, i.e., zero, 1-16, and values of 2**n and
347 2**n - 1 where n is some multiple of 4 or 6. Unfortunately,
348 just what happens when a value is too big to fit in a
349 long is undefined; however, it would be nice if what
350 happened were at least consistent... */
357 }
399 /* WHEW! */
407 /* printf(s241er,16); save in case opinions change... */
410 }
411 /* lrc = 1; save... */
412 }
413 }
418 }
422 {
427 }
430 {
442 /* One of the problems that arises when testing character constants
443 is that of definition: What, exactly, is the character set?
444 In order to guarantee a certain amount of machine independence,
445 the character set we will use here is the set of characters writ-
446 able as escape sequences in C, plus those characters used in writ-
447 ing C programs, i.e.,
449 letters:
450 ABCDEFGHIJKLMNOPQRSTUVWXYZ 26
451 abcdefghijklmnopqrstuvwxyz 26
452 numbers:
453 0123456789 10
454 special characters:
455 ~!"#%&()_=-^|{}[]+;*:<>,.?/ 27
456 extra special characters:
457 newline \n
458 horizontal tab \t
459 backspace \b
460 carriage return \r
461 form feed \f
462 backslash \\
463 single quote \' 7
464 blank & NUL 2
465 ---
466 98
468 Any specific implementation of C may of course support additional
469 characters. */
471 /* Since the value of a character constant is the numerical value
472 of the character in the machine's character set, there should
473 be a one-to-one correspondence between characters and values. */
509 }
511 /* Finally, the escape \ddd consists of the backslash followed
512 by 1, 2, or 3 octal digits which are taken to specify the
513 desired character. */
523 }
526 }
529 {
533 }
536 {
545 }
548 {
561 /* Unfortunately, there's not a lot we can do with floating constants.
562 We can check to see that the various representations can be com-
563 piled, that the conversion is such that they yield the same hard-
564 ware representations in all cases, and that all representations
565 thus checked are double precision. */
582 }
595 }
598 }
601 {
613 /* A string is a sequence of characters surrounded by double
614 quotes, as in "...". */
618 /* A string has type "array of characters" and storage class
619 static and is initialized with the given characters. */
626 }
628 /* The compiler places a null byte \0 at the end of each string
629 so the program which scans the string can find its end. */
634 }
636 /* In a string, the double quote character " must be preceded
637 by a \. */
642 }
644 /* In addition, the same escapes described for character constants
645 may be used. */
659 }
661 /* Finally, a \ and an immediately following newline are ignored */
671 }
673 }
676 {
690 /* Here, we shake the machinery a little to see what falls
691 out. First, we find out how many bits are in a char. */
700 }
701 /* That information lets us determine the size of everything else. */
710 /* We have now almost reconstructed the table in section 2.6, the
711 exception being the range of the floating point hardware.
712 Now there are just so many ways to conjure up a floating point
713 representation system that it's damned near impossible to guess
714 what's going on by writing a program to interpret bit patterns.
715 Further, the information isn't all that useful, if we consider
716 the fact that machines that won't handle numbers between 10**30
717 and 10**-30 are very hard to find, and that people playing with
718 numbers outside that range have a lot more to worry about than
719 just the capacity of the characteristic.
721 A much more useful measure is the precision, which can be ex-
722 pressed in terms of the smallest number that can be added to
723 1. without loss of significance. We calculate that here, for
724 float and double. */
732 }
740 }
743 /* Now, if anyone's interested, we publish the results. */
755 }
756 /* Since we are only exploring and perhaps reporting, but not
757 testing any features, we cannot return an error code. */
760 }
764 {
782 /* There are four declarable storage classes: automatic,
783 static, external, and register. Automatic variables have
784 been dealt with extensively thus far, and will not be specif-
785 ically treated in this section. Register variables are treated
786 in section s81.
788 Static variables are local to a block, but retain their
789 values upon reentry to a block, even after control has left
790 the block. */
796 }
797 ;
799 /* External variables exist and retain their values throughout
800 the execution of the entire program, and may be used for comm-
801 unication between functions, even separately compiled functions.
802 */
808 }
809 /*
810 Characters have been tested elsewhere (in s243).
812 Up to three sizes of integer, declared short int, int, and
813 long int, are available. Longer integers provide no less storage
814 than shorter ones, but implementation may make either short
815 integers, or long integers, or both, equivalent to plain
816 integers.
817 */
823 }
825 /* Unsigned integers, declared unsigned, obey the laws of
826 arithmetic modulo 2**n, where n is the number of bits in the
827 implementation */
836 }
842 }
845 }
848 {
861 }
867 }
869 }
876 }
880 }
883 {
906 /* A character or a short integer may be used wherever
907 an integer may be used. In all cases, the value is converted
908 to integer. This principle is extensively used throughout this
909 program, and will not be explicitly tested here. */
911 /* Conversion of a shorter integer to a longer always
912 involves sign extension. */
920 }
922 /* It is guaranteed that a member of the standard char-
923 acter set is nonnegative. */
939 }
941 /* When a longer integer is converted to a shorter or
942 to a char, it is truncated on the left; excess bits are
943 simply discarded. */
953 }
956 }
958 /* 6.3 Floating and integral */
959 /* 6.4 Pointers and integers */
960 /* 6.5 Unsigned */
961 /* 6.6 Arithmetic conversions */
963 {
980 /* Conversions of integral values to floating type are
981 well-behaved. */
990 }
997 }
999 /* Pointer-integer combinations are discussed in s74,
1000 "Additive operators". The unsigned-int combination
1001 appears below. */
1054 }
1055 }
1057 /* When an unsigned integer is converted to long,
1058 the value of the result is the same numerically
1059 as that of the unsigned integer. */
1066 }
1069 }
1072 {
1084 /* Testing of expressions and operators is quite complicated,
1085 because (a) problems are apt to surface in queer combinations
1086 of operators and operands, rather than in isolation,
1087 and (b) the number of expressions needed to provoke a case
1088 of improper behaviour may be quite large. Hence, we take the
1089 following approach: for this section, and for subsequent
1090 sections through 7.15, we will check the primitive operations
1091 in isolation, thus verifying that the primitives work,
1092 after a fashion. The job of testing combinations, we will
1093 leave to a separate, machine-generated program, to be included
1094 in the C test package at some later date.
1095 */
1097 /* A string is a primary expression. The identifier points to
1098 the first character of a string.
1099 */
1104 }
1105 /* A parenthesized expression is a primary expression whose
1106 type and value are the same as those of the unadorned
1107 expression.
1108 */
1112 }
1114 /* A primary expression followed by an expression in square
1115 brackets is a primary expression. The intuitive meaning is
1116 that of a subscript. The expression E1[E2] is identical
1117 (by definition) to *((E1)+(E2)).
1118 */
1124 }
1126 /* If the various flavors of function calls didn't work, we
1127 would never have gotten this far; however, we do need to
1128 show that functions can be recursive...
1129 */
1134 }
1136 /* and that argument passing is strictly by value. */
1147 }
1149 /* Finally, structures and unions are addressed thusly: */
1154 }
1157 }
1160 {
1163 }
1166 {
1169 }
1172 {
1193 /* This section tests the assignment operators.
1195 It is an exhaustive test of all assignment statements
1196 of the form:
1198 vl op vr
1200 where vl and vr are variables from the set
1201 {char,short,int,long,unsigned,float,double} and op is
1202 one of the assignment operators. There are 395 such
1203 statements.
1205 The initial values for the variables have been chosen
1206 so that both the initial values and the results will
1207 "fit" in just about any implementation, and that the re-
1208 sults will be such that they test for the proper form-
1209 ation of composite operators, rather than checking for
1210 the valid operation of those operators' components.
1211 For example, in checking >>=, we want to verify that
1212 a right shift and a move take place, rather than
1213 whether or not there may be some peculiarities about
1214 the right shift. Such tests have been made previously,
1215 and to repeat them here would be to throw out a red
1216 herring.
1218 The table below lists the operators, assignment targets,
1219 initial values for left and right operands, and the
1220 expected values of the results.
1223 = += -= *= /= %= >>= <<= &= ^= |=
1224 char 2 7 3 10 2 1 1 20 8 6 14
1225 short 2 7 3 10 2 1 1 20 8 6 14
1226 int 2 7 3 10 2 1 1 20 8 6 14
1227 long 2 7 3 10 2 1 1 20 8 6 14
1228 unsigned 2 7 3 10 2 1 1 20 8 6 14
1229 float 2 7 3 10 2.5 | |
1230 double 2 7 3 10 2.5 | |
1231 | |
1232 initial (5,2) | (5,2) | (12,10)
1234 The following machine-generated program reflects the
1235 tests described in the table.
1236 */
1243 }
1249 }
1255 }
1261 }
1267 }
1273 }
1279 }
1285 }
1291 }
1297 }
1303 }
1309 }
1315 }
1321 }
1327 }
1333 }
1339 }
1345 }
1351 }
1357 }
1363 }
1369 }
1375 }
1381 }
1387 }
1393 }
1399 }
1405 }
1411 }
1417 }
1423 }
1429 }
1435 }
1441 }
1447 }
1453 }
1459 }
1465 }
1471 }
1477 }
1483 }
1489 }
1495 }
1501 }
1507 }
1513 }
1519 }
1525 }
1531 }
1537 }
1543 }
1549 }
1555 }
1561 }
1567 }
1573 }
1579 }
1585 }
1591 }
1597 }
1603 }
1609 }
1615 }
1621 }
1627 }
1633 }
1639 }
1645 }
1651 }
1657 }
1663 }
1669 }
1675 }
1681 }
1687 }
1693 }
1699 }
1705 }
1711 }
1717 }
1723 }
1729 }
1735 }
1741 }
1747 }
1753 }
1759 }
1765 }
1771 }
1777 }
1783 }
1789 }
1795 }
1801 }
1807 }
1813 }
1819 }
1825 }
1831 }
1837 }
1843 }
1849 }
1855 }
1861 }
1867 }
1873 }
1879 }
1885 }
1891 }
1897 }
1903 }
1909 }
1915 }
1921 }
1927 }
1933 }
1939 }
1945 }
1951 }
1957 }
1963 }
1969 }
1975 }
1981 }
1987 }
1993 }
1999 }
2005 }
2011 }
2017 }
2023 }
2029 }
2035 }
2041 }
2047 }
2053 }
2059 }
2065 }
2071 }
2077 }
2083 }
2089 }
2095 }
2101 }
2107 }
2113 }
2119 }
2125 }
2131 }
2137 }
2143 }
2149 }
2155 }
2161 }
2167 }
2173 }
2179 }
2185 }
2191 }
2197 }
2203 }
2209 }
2215 }
2221 }
2227 }
2233 }
2239 }
2245 }
2251 }
2257 }
2263 }
2269 }
2275 }
2281 }
2287 }
2293 }
2299 }
2305 }
2311 }
2317 }
2323 }
2329 }
2335 }
2341 }
2347 }
2353 }
2359 }
2365 }
2371 }
2377 }
2383 }
2389 }
2395 }
2401 }
2407 }
2413 }
2419 }
2425 }
2431 }
2437 }
2443 }
2449 }
2455 }
2461 }
2467 }
2473 }
2479 }
2485 }
2491 }
2497 }
2503 }
2509 }
2515 }
2521 }
2527 }
2533 }
2539 }
2545 }
2551 }
2557 }
2563 }
2569 }
2575 }
2581 }
2587 }
2593 }
2599 }
2605 }
2611 }
2617 }
2623 }
2629 }
2635 }
2641 }
2647 }
2653 }
2659 }
2665 }
2671 }
2677 }
2683 }
2689 }
2695 }
2701 }
2707 }
2713 }
2719 }
2725 }
2731 }
2737 }
2743 }
2749 }
2755 }
2761 }
2767 }
2773 }
2779 }
2785 }
2791 }
2797 }
2803 }
2809 }
2815 }
2821 }
2827 }
2833 }
2839 }
2845 }
2851 }
2857 }
2863 }
2869 }
2875 }
2881 }
2887 }
2893 }
2899 }
2905 }
2911 }
2917 }
2923 }
2929 }
2935 }
2941 }
2947 }
2953 }
2959 }
2965 }
2971 }
2977 }
2983 }
2989 }
2995 }
3001 }
3007 }
3013 }
3019 }
3025 }
3031 }
3037 }
3043 }
3049 }
3055 }
3061 }
3067 }
3073 }
3079 }
3085 }
3091 }
3097 }
3103 }
3109 }
3115 }
3121 }
3127 }
3133 }
3139 }
3145 }
3151 }
3157 }
3163 }
3169 }
3175 }
3181 }
3187 }
3193 }
3199 }
3205 }
3211 }
3217 }
3223 }
3229 }
3235 }
3241 }
3247 }
3253 }
3259 }
3265 }
3271 }
3277 }
3283 }
3289 }
3295 }
3301 }
3307 }
3313 }
3319 }
3325 }
3331 }
3337 }
3343 }
3349 }
3355 }
3361 }
3367 }
3373 }
3379 }
3385 }
3391 }
3397 }
3403 }
3409 }
3415 }
3421 }
3427 }
3433 }
3439 }
3445 }
3451 }
3457 }
3463 }
3469 }
3475 }
3481 }
3487 }
3493 }
3499 }
3505 }
3511 }
3517 }
3523 }
3529 }
3535 }
3541 }
3547 }
3553 }
3559 }
3565 }
3571 }
3577 }
3583 }
3589 }
3595 }
3601 }
3607 }
3611 }
3613 }
3616 {
3628 /* A pair of expressions separated by a comma is
3629 evaluated left to right and the value of the left
3630 expression is discarded.
3631 */
3636 }
3638 /* In contexts where the comma is given a special mean-
3639 ing, for example in a list of actual arguments to
3640 functions (sic) and lists of initializers, the comma
3641 operator as described in this section can only appear
3642 in parentheses; for example
3644 f( a, (t=3, t+2), c)
3646 has three arguments, the second of which has the
3647 value 5.
3648 */
3653 }
3655 }
3658 {
3660 }
3663 {
3680 /* The *, denoting indirection, and the &, denoting a
3681 pointer, are duals of each other, and ought to behave as
3682 such... */
3688 }
3690 /* The unary minus has the conventional meaning. */
3695 }
3697 /* The negation operator (!) has been thoroughly checked out,
3698 perhaps more thoroughly than any of the others. The ~ oper-
3699 ator gets us a ones complement. */
3706 }
3708 /* Now we look at the ++ and -- operators, which can be
3709 used in either prefix or suffix form. With side
3710 effects they're loaded. */
3719 }
3721 /* An expression preceded by the parenthesised name of a
3722 data type causes conversion of the value of the expression
3723 to the named type. This construction is called a cast.
3724 Here, we check to see that all of the possible casts and
3725 their simple combinations are accepted by the compiler,
3726 and that they all produce a correct result for this sample
3727 of size one. */
3766 }
3768 /* The sizeof operator has been tested previously. */
3771 }
3773 /* 7.6 Relational operators */
3774 /* 7.7 Equality operator */
3776 {
3788 /* The shift operators << and >> group left-to-right.
3789 */
3795 }
3797 /* In the following test, an n-bit unsigned consisting
3798 of all 1s is shifted right (resp. left) k bits, 0<=k<n.
3799 We expect to find k 0s followed by n-k 1s (resp. n-k 1s
3800 followed by k 0s). If not, we complain.
3801 */
3816 }
3817 }
3822 }
3824 /* The relational operators group left-to-right, but this
3825 fact is not very useful; a<b<c does not mean what it
3826 seems to...
3827 */
3836 }
3838 /* In general, we take note of the fact that if we got this
3839 far the relational operators have to be working. We test only
3840 that two pointers may be compared; the result depends on
3841 the relative locations in the address space of the
3842 pointed-to objects.
3843 */
3847 }
3852 /* a<b == c<d whenever a<b and c<d have the same
3853 truth value. */
3874 }
3876 /* A pointer to which zero has been assigned will
3877 appear to be equal to zero.
3878 */
3885 }
3888 }
3890 7.9 Bitwise OR operator
3891 7.10 Bitwise exclusive OR operator
3892 7.11 Logical AND operator
3893 7.12 Logical OR operator
3894 7.13 Conditional operator */
3896 {
3911 /* If bitwise AND, OR, and exclusive OR are to cause
3912 trouble, they will probably do so when they are used in
3913 an unusual context. The number of contexts in which
3914 they can be used is infinite, so to save time we select
3915 a finite subset: the set of all expressions of the form:
3917 item1 op item2
3919 where item1 and item2 are chosen from the set
3920 {char,short,long,unsigned,int} and op is one of {&,|,^}.
3921 We will use 12 and 10 as values for the items, as these
3922 values will fit into all data types on just about any
3923 imaginable machine, and the results after performing the
3924 bitwise operations on them are distinct for each operation,
3925 i.e.,
3927 12 | 10 -> 1100 | 1010 -> 1110 -> 14
3928 12 ^ 10 -> 1100 ^ 1010 -> 0110 -> 6
3929 12 & 10 -> 1100 & 1010 -> 1000 -> 8
3931 There are 75 such combinations:
3932 */
4085 }
4087 /* The && operator groups left to right. It returns 1
4088 if both of the operands are nonzero; 0 otherwise.
4089 It guarantees left to right evaluation; moreover, the
4090 second operand is not evaluated if the value of the
4091 first operand is 0.
4092 */
4117 }
4119 /* The || operator groups left to right. It returns 1
4120 if either of its operands is nonzero; 0 otherwise. It
4121 guarantees left to right evaluation; moreover, the second
4122 operand is not evaluated if the value of the first
4123 operand is nonzero.
4124 */
4148 }
4150 /* Conditional expressions group right to left. */
4159 }
4161 /* The first expression is evaluated and if it is non-
4162 zero, the result is the value of the second expression;
4163 otherwise, that of the third expression.
4164 */
4169 }
4171 }
4174 {
4197 /* The storage class specifiers are:
4199 auto
4200 static
4201 extern
4202 register
4203 typedef
4205 The first three of these were treated earlier, in s4. The last
4206 will be checked in s88. "Register" remains.
4208 There are three flavors of register, viz., char, int and pointer.
4209 We wish first to ascertain that the representations as register
4210 are consistent with the corresponding nonregister representations.
4211 */
4226 }
4231 }
4236 }
4241 }
4243 /* Now we check to see if variables are actually being assigned
4244 to registers. */
4250 }
4256 }
4262 }
4265 }
4267 /* Testing a variable whose storage class has been spec-
4268 ified as "register" is somewhat tricky, but it can be done in a
4269 fairly reliable fashion by taking advantage of our knowledge of the
4270 ways in which compilers operate. If we declare a collection of vari-
4271 ables of the same storage class, we would expect that, when storage
4272 for these variables is actually allocated, the variables will be
4273 bunched together and ordered according to one of the following
4274 criteria:
4276 (a) the order in which they were defined.
4277 (b) the order in which they are used.
4278 (c) alphabetically.
4279 (d) the order in which they appear in the compiler's
4280 symbol table.
4281 (e) some other way.
4283 Hence, if we define a sequence of variables in close alpha-
4284 betical order, and use them in the same order in which we define
4285 them, we would expect the differences between the addresses of
4286 successive variables to be constant, except in case (d) where the
4287 symbol table is a hash table, or in case (e). If a subsequence in
4288 the middle of this sequence is selected, and for this subsequence,
4289 every other variable is specified to be "register", and address
4290 differences are taken between adjacent nonregister variables, we would
4291 still expect to find constant differences if the "register" vari-
4292 ables were actually assigned to registers, and some other diff-
4293 erences if they were not. Specifically, if we had N variables
4294 specified as "register" of which the first n were actually ass-
4295 igned to registers, we would expect the sequence of differences
4296 to consist of a number of occurrences of some number, followed by
4297 N-n occurrences of some other number, followed by several occurr-
4298 ences of the first number. If we get a sequence like this, we can
4299 determine, by simple subtraction, how many (if any) variables are
4300 being assigned to registers. If we get some other sequence, we know
4301 that the test is invalid. */
4408 /* The following FSM analyzes the string of differences. It accepts
4409 strings of the form a+b+a+ and returns 16 minus the number of bs,
4410 which is the number of variables that actually got into registers.
4411 Otherwise it signals rejection by returning -1., indicating that the
4412 test is unreliable. */
4423 }
4428 }
4432 }
4437 }
4438 ;
4442 }
4444 /* Testing a variable whose storage class has been spec-
4445 ified as "register" is somewhat tricky, but it can be done in a
4446 fairly reliable fashion by taking advantage of our knowledge of the
4447 ways in which compilers operate. If we declare a collection of vari-
4448 ables of the same storage class, we would expect that, when storage
4449 for these variables is actually allocated, the variables will be
4450 bunched together and ordered according to one of the following
4451 criteria:
4453 (a) the order in which they were defined.
4454 (b) the order in which they are used.
4455 (c) alphabetically.
4456 (d) the order in which they appear in the compiler's
4457 symbol table.
4458 (e) some other way.
4460 Hence, if we define a sequence of variables in close alpha-
4461 betical order, and use them in the same order in which we define
4462 them, we would expect the differences between the addresses of
4463 successive variables to be constant, except in case (d) where the
4464 symbol table is a hash table, or in case (e). If a subsequence in
4465 the middle of this sequence is selected, and for this subsequence,
4466 every other variable is specified to be "register", and address
4467 differences are taken between adjacent nonregister variables, we would
4468 still expect to find constant differences if the "register" vari-
4469 ables were actually assigned to registers, and some other diff-
4470 erences if they were not. Specifically, if we had N variables
4471 specified as "register" of which the first n were actually ass-
4472 igned to registers, we would expect the sequence of differences
4473 to consist of a number of occurrences of some number, followed by
4474 N-n occurrences of some other number, followed by several occurr-
4475 ences of the first number. If we get a sequence like this, we can
4476 determine, by simple subtraction, how many (if any) variables are
4477 being assigned to registers. If we get some other sequence, we know
4478 that the test is invalid. */
4587 /* The following FSM analyzes the string of differences. It accepts
4588 strings of the form a+b+a+ and returns 16 minus the number of bs,
4589 which is the number of variables that actually got into registers.
4590 Otherwise it signals rejection by returning -1., indicating that the
4591 test is unreliable. */
4602 }
4607 }
4611 }
4616 }
4617 ;
4621 }
4623 /* Testing a variable whose storage class has been spec-
4624 ified as "register" is somewhat tricky, but it can be done in a
4625 fairly reliable fashion by taking advantage of our knowledge of the
4626 ways in which compilers operate. If we declare a collection of vari-
4627 ables of the same storage class, we would expect that, when storage
4628 for these variables is actually allocated, the variables will be
4629 bunched together and ordered according to one of the following
4630 criteria:
4632 (a) the order in which they were defined.
4633 (b) the order in which they are used.
4634 (c) alphabetically.
4635 (d) the order in which they appear in the compiler's
4636 symbol table.
4637 (e) some other way.
4639 Hence, if we define a sequence of variables in close alpha-
4640 betical order, and use them in the same order in which we define
4641 them, we would expect the differences between the addresses of
4642 successive variables to be constant, except in case (d) where the
4643 symbol table is a hash table, or in case (e). If a subsequence in
4644 the middle of this sequence is selected, and for this subsequence,
4645 every other variable is specified to be "register", and address
4646 differences are taken between adjacent nonregister variables, we would
4647 still expect to find constant differences if the "register" vari-
4648 ables were actually assigned to registers, and some other diff-
4649 erences if they were not. Specifically, if we had N variables
4650 specified as "register" of which the first n were actually ass-
4651 igned to registers, we would expect the sequence of differences
4652 to consist of a number of occurrences of some number, followed by
4653 N-n occurrences of some other number, followed by several occurr-
4654 ences of the first number. If we get a sequence like this, we can
4655 determine, by simple subtraction, how many (if any) variables are
4656 being assigned to registers. If we get some other sequence, we know
4657 that the test is invalid. */
4766 /* The following FSM analyzes the string of differences. It accepts
4767 strings of the form a+b+a+ and returns 16 minus the number of bs,
4768 which is the number of variables that actually got into registers.
4769 Otherwise it signals rejection by returning -1., indicating that the
4770 test is unreliable. */
4780 }
4785 }
4789 }
4794 }
4795 ;
4799 }
4802 {
4815 /* The more common varieties of declarators have al-
4816 ready been touched upon, some more than others. It
4817 is useful to compare *fip() and (*pfi)().
4818 */
4824 }
4830 }
4832 /* Float fa[17] declares an array of floating point
4833 numbers, and *afp[17] declares an array of pointers
4834 to floats.
4835 */
4840 }
4847 }
4849 /* static int x3d[3][5][7] declares a static three
4850 dimensional array of integers, with rank 3x5x7.
4851 In complete detail, x3d is an array of three items;
4852 each item is an array of five arrays, and each of
4853 the latter arrays is an array of seven integers.
4854 Any of the expressions x3d, x3d[i], x3d[i][j],
4855 and x3d[i][j][k] may reasonably appear in an express-
4856 ion. The first three have type "array"; the last has
4857 type int.
4858 */
4874 }
4877 }
4880 {
4886 }
4889 {
4893 }
4899 {
4910 };
4958 "double"
4959 };
4985 /* Within a structure, the objects declared have
4986 addresses which increase as their declarations are
4987 read left to right.
4988 */
4995 }
4997 /* Each non-field member of a structure begins on an
4998 addressing boundary appropriate to its type.
4999 */
5013 /* Field specifications are highly implementation de-
5014 pendent. About the only thing we can do here is to
5015 check is that the compiler accepts the field constructs,
5016 and that they seem to work, after a fashion, at
5017 run time...
5018 */
5027 }
5031 }
5032 }
5038 }
5040 /* A union may be thought of as a structure all of whose
5041 members begin at offset 0 and whose size is sufficient
5042 to contain any of its members.
5043 */
5055 }
5067 }
5069 /* Finally, we check that the pointers work. */
5077 }
5079 }
5082 {
5098 };
5102 };
5108 /* The expression in an initializer for a static or
5109 external variable must be a constant expression or
5110 an expression that reduces to the address of a pre-
5111 viously declared variable, possibly offset by a
5112 constant expression.
5113 */
5118 }
5120 /* Automatic and register variables may be initialized
5121 by arbitrary expressions involving constants and previously
5122 declared variables and functions.
5123 */
5128 }
5133 }
5135 /* Static variables that are not initialized are guar-
5136 anteed to start off as zero.
5137 */
5145 }
5147 /* y0, y1, and y2, as declared, should define and
5148 initialize identical arrays.
5149 */
5156 }
5161 }
5163 /* y3 initializes the first column of the array and
5164 leaves the rest zero.
5165 */
5173 }
5175 }
5178 }
5182 {
5188 /* Declarations whose "storage class" is typdef do not
5189 define storage, but instead define identifiers which
5190 can later be used as if they were type keywords naming
5191 fundamental or derived types.
5192 */
5197 MILES distance;
5206 /* Hopefully, all of this stuff will compile. After that,
5207 we can only make some superficial tests.
5209 The type of distance is int,
5210 */
5215 }
5217 /* that of metricp is "pointer to int", */
5226 }
5228 /* and that of z is the specified structure. zp is a
5229 pointer to such a structure.
5230 */
5240 }
5243 }
5246 {
5258 /* One would think that the section on statements would
5259 provide the most variety in the entire sequence of tests.
5260 As it turns out, most of the material in this section has
5261 already been checked in the process of checking out
5262 everything else, and the section at this point is somewhat
5263 anticlimactic. For this reason, we restrict ourselves
5264 to testing two features not already covered.
5266 Compound statements are delimited by braces. They have the
5267 nice property that identifiers of the auto and register
5268 variety are pushed and popped. It is currently legal to
5269 transfer into a block, but we wont...
5270 */
5277 {
5282 }
5284 }
5289 }
5291 /* Goto statements go to labeled statements, we hope. */
5296 nobarf:;
5299 }
5303 }