![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gnucpp.cpio CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to gnucpp.cpio CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 ! root 1: 0707070114030104531006660005500000040000010641070426654763700001000000015757COPYING ! 2: GNU CC GENERAL PUBLIC LICENSE ! 3: (Clarified 11 Feb 1988) ! 4: ! 5: Copyright (C) 1988 Richard M. Stallman ! 6: Everyone is permitted to copy and distribute verbatim copies ! 7: of this license, but changing it is not allowed. You can also ! 8: use this wording to make the terms for other programs. ! 9: ! 10: The license agreements of most software companies keep you at the ! 11: mercy of those companies. By contrast, our general public license is ! 12: intended to give everyone the right to share GNU CC. To make sure that ! 13: you get the rights we want you to have, we need to make restrictions ! 14: that forbid anyone to deny you these rights or to ask you to surrender ! 15: the rights. Hence this license agreement. ! 16: ! 17: Specifically, we want to make sure that you have the right to give ! 18: away copies of GNU CC, that you receive source code or else can get it ! 19: if you want it, that you can change GNU CC or use pieces of it in new ! 20: free programs, and that you know you can do these things. ! 21: ! 22: To make sure that everyone has such rights, we have to forbid you to ! 23: deprive anyone else of these rights. For example, if you distribute ! 24: copies of GNU CC, you must give the recipients all the rights that you ! 25: have. You must make sure that they, too, receive or can get the ! 26: source code. And you must tell them their rights. ! 27: ! 28: Also, for our own protection, we must make certain that everyone ! 29: finds out that there is no warranty for GNU CC. If GNU CC is modified by ! 30: someone else and passed on, we want its recipients to know that what ! 31: they have is not what we distributed, so that any problems introduced ! 32: by others will not reflect on our reputation. ! 33: ! 34: Therefore we (Richard Stallman and the Free Software Foundation, ! 35: Inc.) make the following terms which say what you must do to be ! 36: allowed to distribute or change GNU CC. ! 37: ! 38: ! 39: COPYING POLICIES ! 40: ! 41: 1. You may copy and distribute verbatim copies of GNU CC source code ! 42: as you receive it, in any medium, provided that you conspicuously and ! 43: appropriately publish on each copy a valid copyright notice "Copyright ! 44: (C) 1988 Free Software Foundation, Inc." (or with whatever year is ! 45: appropriate); keep intact the notices on all files that refer to this ! 46: License Agreement and to the absence of any warranty; and give any ! 47: other recipients of the GNU CC program a copy of this License ! 48: Agreement along with the program. You may charge a distribution fee ! 49: for the physical act of transferring a copy. ! 50: ! 51: 2. You may modify your copy or copies of GNU CC or any portion of it, ! 52: and copy and distribute such modifications under the terms of ! 53: Paragraph 1 above, provided that you also do the following: ! 54: ! 55: a) cause the modified files to carry prominent notices stating ! 56: that you changed the files and the date of any change; and ! 57: ! 58: b) cause the whole of any work that you distribute or publish, ! 59: that in whole or in part contains or is a derivative of GNU CC or ! 60: any part thereof, to be licensed at no charge to all third ! 61: parties on terms identical to those contained in this License ! 62: Agreement (except that you may choose to grant more extensive ! 63: warranty protection to some or all third parties, at your option). ! 64: ! 65: c) You may charge a distribution fee for the physical act of ! 66: transferring a copy, and you may at your option offer warranty ! 67: protection in exchange for a fee. ! 68: ! 69: Mere aggregation of another unrelated program with this program (or its ! 70: derivative) on a volume of a storage or distribution medium does not bring ! 71: the other program under the scope of these terms. ! 72: ! 73: 3. You may copy and distribute GNU CC (or a portion or derivative of it, ! 74: under Paragraph 2) in object code or executable form under the terms of ! 75: Paragraphs 1 and 2 above provided that you also do one of the following: ! 76: ! 77: a) accompany it with the complete corresponding machine-readable ! 78: source code, which must be distributed under the terms of ! 79: Paragraphs 1 and 2 above; or, ! 80: ! 81: b) accompany it with a written offer, valid for at least three ! 82: years, to give any third party free (except for a nominal ! 83: shipping charge) a complete machine-readable copy of the ! 84: corresponding source code, to be distributed under the terms of ! 85: Paragraphs 1 and 2 above; or, ! 86: ! 87: c) accompany it with the information you received as to where the ! 88: corresponding source code may be obtained. (This alternative is ! 89: allowed only for noncommercial distribution and only if you ! 90: received the program in object code or executable form alone.) ! 91: ! 92: For an executable file, complete source code means all the source code for ! 93: all modules it contains; but, as a special exception, it need not include ! 94: source code for modules which are standard libraries that accompany the ! 95: operating system on which the executable file runs. ! 96: ! 97: 4. You may not copy, sublicense, distribute or transfer GNU CC ! 98: except as expressly provided under this License Agreement. Any attempt ! 99: otherwise to copy, sublicense, distribute or transfer GNU CC is void and ! 100: your rights to use the program under this License agreement shall be ! 101: automatically terminated. However, parties who have received computer ! 102: software programs from you with this License Agreement will not have ! 103: their licenses terminated so long as such parties remain in full compliance. ! 104: ! 105: 5. If you wish to incorporate parts of GNU CC into other free programs ! 106: whose distribution conditions are different, write to the Free Software ! 107: Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet worked ! 108: out a simple rule that can be stated here, but we will often permit this. ! 109: We will be guided by the two goals of preserving the free status of all ! 110: derivatives of our free software and of promoting the sharing and reuse of ! 111: software. ! 112: ! 113: Your comments and suggestions about our licensing policies and our ! 114: software are welcome! Please contact the Free Software Foundation, Inc., ! 115: 675 Mass Ave, Cambridge, MA 02139, or call (617) 876-3296. ! 116: ! 117: NO WARRANTY ! 118: ! 119: BECAUSE GNU CC IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO ! 120: WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT ! 121: WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, ! 122: RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GNU CC "AS IS" WITHOUT ! 123: WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT ! 124: LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ! 125: A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND ! 126: PERFORMANCE OF GNU CC IS WITH YOU. SHOULD GNU CC PROVE DEFECTIVE, YOU ! 127: ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. ! 128: ! 129: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M. ! 130: STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY ! 131: WHO MAY MODIFY AND REDISTRIBUTE GNU CC AS PERMITTED ABOVE, BE LIABLE TO ! 132: YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER ! 133: SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR ! 134: INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA ! 135: BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A ! 136: FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GNU CC, EVEN ! 137: IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR ! 138: ANY CLAIM BY ANY OTHER PARTY. ! 139: 0707070114030170161006660005500000040000010614560426655020300001100000011751alloca.c /* ! 140: alloca -- (mostly) portable public-domain implementation ! 141: ! 142: last edit: 86/01/26 D A Gwyn ! 143: ! 144: This implementation of the PWB library alloca() function, ! 145: which is used to allocate space off the run-time stack so ! 146: that it is automatically reclaimed upon procedure exit, ! 147: was inspired by discussions with J. Q. Johnson of Cornell. ! 148: ! 149: It should work under any C implementation that uses an ! 150: actual procedure stack (as opposed to a linked list of ! 151: frames). There are some preprocessor constants that can ! 152: be defined when compiling for your specific system, for ! 153: improved efficiency; however, the defaults should be okay. ! 154: ! 155: The general concept of this implementation is to keep ! 156: track of all alloca()-allocated blocks, and reclaim any ! 157: that are found to be deeper in the stack than the current ! 158: invocation. This heuristic does not reclaim storage as ! 159: soon as it becomes invalid, but it will do so eventually. ! 160: ! 161: As a special case, alloca(0) reclaims storage without ! 162: allocating any. It is a good idea to use alloca(0) in ! 163: your main control loop, etc. to force garbage collection. ! 164: */ ! 165: #ifndef lint ! 166: static char SCCSid[] = "@(#)alloca.c 1.1"; /* for the "what" utility */ ! 167: #endif ! 168: ! 169: #ifdef X3J11 ! 170: typedef void *pointer; /* generic pointer type */ ! 171: #else ! 172: typedef char *pointer; /* generic pointer type */ ! 173: #endif ! 174: ! 175: #define NULL 0 /* null pointer constant */ ! 176: ! 177: extern void free(); ! 178: extern pointer xmalloc(); ! 179: ! 180: /* ! 181: Define STACK_DIRECTION if you know the direction of stack ! 182: growth for your system; otherwise it will be automatically ! 183: deduced at run-time. ! 184: ! 185: STACK_DIRECTION > 0 => grows toward higher addresses ! 186: STACK_DIRECTION < 0 => grows toward lower addresses ! 187: STACK_DIRECTION = 0 => direction of growth unknown ! 188: */ ! 189: ! 190: #ifndef STACK_DIRECTION ! 191: #define STACK_DIRECTION 0 /* direction unknown */ ! 192: #endif ! 193: ! 194: #if STACK_DIRECTION != 0 ! 195: ! 196: #define STACK_DIR STACK_DIRECTION /* known at compile-time */ ! 197: ! 198: #else /* STACK_DIRECTION == 0; need run-time code */ ! 199: ! 200: static int stack_dir; /* 1 or -1 once known */ ! 201: #define STACK_DIR stack_dir ! 202: ! 203: static void ! 204: find_stack_direction (/* void */) ! 205: { ! 206: static char *addr = NULL; /* address of first ! 207: `dummy', once known */ ! 208: auto char dummy; /* to get stack address */ ! 209: ! 210: if (addr == NULL) ! 211: { /* initial entry */ ! 212: addr = &dummy; ! 213: ! 214: find_stack_direction (); /* recurse once */ ! 215: } ! 216: else /* second entry */ ! 217: if (&dummy > addr) ! 218: stack_dir = 1; /* stack grew upward */ ! 219: else ! 220: stack_dir = -1; /* stack grew downward */ ! 221: } ! 222: ! 223: #endif /* STACK_DIRECTION == 0 */ ! 224: ! 225: /* ! 226: An "alloca header" is used to: ! 227: (a) chain together all alloca()ed blocks; ! 228: (b) keep track of stack depth. ! 229: ! 230: It is very important that sizeof(header) agree with malloc() ! 231: alignment chunk size. The following default should work okay. ! 232: */ ! 233: ! 234: #ifndef ALIGN_SIZE ! 235: #define ALIGN_SIZE sizeof(double) ! 236: #endif ! 237: ! 238: typedef union hdr ! 239: { ! 240: char align[ALIGN_SIZE]; /* to force sizeof(header) */ ! 241: struct ! 242: { ! 243: union hdr *next; /* for chaining headers */ ! 244: char *deep; /* for stack depth measure */ ! 245: } h; ! 246: } header; ! 247: ! 248: /* ! 249: alloca( size ) returns a pointer to at least `size' bytes of ! 250: storage which will be automatically reclaimed upon exit from ! 251: the procedure that called alloca(). Originally, this space ! 252: was supposed to be taken from the current stack frame of the ! 253: caller, but that method cannot be made to work for some ! 254: implementations of C, for example under Gould's UTX/32. ! 255: */ ! 256: ! 257: pointer ! 258: alloca (size) /* returns pointer to storage */ ! 259: unsigned size; /* # bytes to allocate */ ! 260: { ! 261: static header *last = NULL; /* -> last alloca header */ ! 262: auto char probe; /* probes stack depth: */ ! 263: register char *depth = &probe; ! 264: ! 265: #if STACK_DIRECTION == 0 ! 266: if (STACK_DIR == 0) /* unknown growth direction */ ! 267: find_stack_direction (); ! 268: #endif ! 269: ! 270: /* Reclaim garbage, defined as all alloca()ed storage that ! 271: was allocated from deeper in the stack than currently. */ ! 272: ! 273: { ! 274: register header *hp; /* traverses linked list */ ! 275: ! 276: for (hp = last; hp != NULL;) ! 277: if (STACK_DIR > 0 && hp->h.deep > depth ! 278: || STACK_DIR < 0 && hp->h.deep < depth) ! 279: { ! 280: register header *np = hp->h.next; ! 281: ! 282: free ((pointer) hp); /* collect garbage */ ! 283: ! 284: hp = np; /* -> next header */ ! 285: } ! 286: else ! 287: break; /* rest are not deeper */ ! 288: ! 289: last = hp; /* -> last valid storage */ ! 290: } ! 291: ! 292: if (size == 0) ! 293: return NULL; /* no allocation required */ ! 294: ! 295: /* Allocate combined header + user data storage. */ ! 296: ! 297: { ! 298: register pointer new = xmalloc (sizeof (header) + size); ! 299: /* address of header */ ! 300: ! 301: ((header *)new)->h.next = last; ! 302: ((header *)new)->h.deep = depth; ! 303: ! 304: last = (header *)new; ! 305: ! 306: /* User storage begins just after header. */ ! 307: ! 308: return (pointer)((char *)new + sizeof(header)); ! 309: } ! 310: } ! 311: ! 312: /* like malloc and realloc but check for no memory left */ ! 313: /* ! 314: pointer ! 315: xmalloc (size) ! 316: int size; ! 317: { ! 318: pointer val = (pointer) malloc (size); ! 319: if (!val) memory_full (); ! 320: return val; ! 321: } ! 322: ! 323: pointer ! 324: xrealloc (block, size) ! 325: long *block; ! 326: int size; ! 327: { ! 328: pointer val = (pointer) realloc (block, size); ! 329: if (!val) memory_full (); ! 330: return val; ! 331: } ! 332: memory_full () ! 333: { ! 334: error ("Memory exhausted"); ! 335: } ! 336: */ ! 337: 0707070114030157531006660005500000040000010274400426654765600000700000035321cexp.y /* Parse C expressions for CCCP. ! 338: Copyright (C) 1987 Free Software Foundation. ! 339: ! 340: NO WARRANTY ! 341: ! 342: BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY ! 343: NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT ! 344: WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, ! 345: RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS" ! 346: WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, ! 347: BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND ! 348: FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY ! 349: AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE ! 350: DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR ! 351: CORRECTION. ! 352: ! 353: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M. ! 354: STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY ! 355: WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE ! 356: LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR ! 357: OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE ! 358: USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR ! 359: DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR ! 360: A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS ! 361: PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH ! 362: DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. ! 363: ! 364: GENERAL PUBLIC LICENSE TO COPY ! 365: ! 366: 1. You may copy and distribute verbatim copies of this source file ! 367: as you receive it, in any medium, provided that you conspicuously and ! 368: appropriately publish on each copy a valid copyright notice "Copyright ! 369: (C) 1987 Free Software Foundation"; and include following the ! 370: copyright notice a verbatim copy of the above disclaimer of warranty ! 371: and of this License. You may charge a distribution fee for the ! 372: physical act of transferring a copy. ! 373: ! 374: 2. You may modify your copy or copies of this source file or ! 375: any portion of it, and copy and distribute such modifications under ! 376: the terms of Paragraph 1 above, provided that you also do the following: ! 377: ! 378: a) cause the modified files to carry prominent notices stating ! 379: that you changed the files and the date of any change; and ! 380: ! 381: b) cause the whole of any work that you distribute or publish, ! 382: that in whole or in part contains or is a derivative of this ! 383: program or any part thereof, to be licensed at no charge to all ! 384: third parties on terms identical to those contained in this ! 385: License Agreement (except that you may choose to grant more extensive ! 386: warranty protection to some or all third parties, at your option). ! 387: ! 388: c) You may charge a distribution fee for the physical act of ! 389: transferring a copy, and you may at your option offer warranty ! 390: protection in exchange for a fee. ! 391: ! 392: Mere aggregation of another unrelated program with this program (or its ! 393: derivative) on a volume of a storage or distribution medium does not bring ! 394: the other program under the scope of these terms. ! 395: ! 396: 3. You may copy and distribute this program (or a portion or derivative ! 397: of it, under Paragraph 2) in object code or executable form under the terms ! 398: of Paragraphs 1 and 2 above provided that you also do one of the following: ! 399: ! 400: a) accompany it with the complete corresponding machine-readable ! 401: source code, which must be distributed under the terms of ! 402: Paragraphs 1 and 2 above; or, ! 403: ! 404: b) accompany it with a written offer, valid for at least three ! 405: years, to give any third party free (except for a nominal ! 406: shipping charge) a complete machine-readable copy of the ! 407: corresponding source code, to be distributed under the terms of ! 408: Paragraphs 1 and 2 above; or, ! 409: ! 410: c) accompany it with the information you received as to where the ! 411: corresponding source code may be obtained. (This alternative is ! 412: allowed only for noncommercial distribution and only if you ! 413: received the program in object code or executable form alone.) ! 414: ! 415: For an executable file, complete source code means all the source code for ! 416: all modules it contains; but, as a special exception, it need not include ! 417: source code for modules which are standard libraries that accompany the ! 418: operating system on which the executable file runs. ! 419: ! 420: 4. You may not copy, sublicense, distribute or transfer this program ! 421: except as expressly provided under this License Agreement. Any attempt ! 422: otherwise to copy, sublicense, distribute or transfer this program is void and ! 423: your rights to use the program under this License agreement shall be ! 424: automatically terminated. However, parties who have received computer ! 425: software programs from you with this License Agreement will not have ! 426: their licenses terminated so long as such parties remain in full compliance. ! 427: ! 428: 5. If you wish to incorporate parts of this program into other free ! 429: programs whose distribution conditions are different, write to the Free ! 430: Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet ! 431: worked out a simple rule that can be stated here, but we will often permit ! 432: this. We will be guided by the two goals of preserving the free status of ! 433: all derivatives of our free software and of promoting the sharing and reuse of ! 434: software. ! 435: ! 436: ! 437: In other words, you are welcome to use, share and improve this program. ! 438: You are forbidden to forbid anyone else to use, share and improve ! 439: what you give them. Help stamp out software-hoarding! ! 440: ! 441: Adapted from expread.y of GDB by Paul Rubin, July 1986. ! 442: ! 443: /* Parse a C expression from text in a string */ ! 444: ! 445: %{ ! 446: #include "config.h" ! 447: #include <setjmp.h> ! 448: /* #define YYDEBUG 1 */ ! 449: ! 450: static int yylex (); ! 451: static yyerror (); ! 452: int expression_value; ! 453: ! 454: static jmp_buf parse_return_error; ! 455: ! 456: /* some external tables of character types */ ! 457: extern unsigned char is_idstart[], is_idchar[]; ! 458: ! 459: %} ! 460: ! 461: %union { ! 462: long lval; ! 463: int voidval; ! 464: char *sval; ! 465: } ! 466: ! 467: %type <lval> exp exp1 start ! 468: %token <lval> INT CHAR ! 469: %token <sval> NAME ! 470: %token <lval> ERROR ! 471: ! 472: %right '?' ':' ! 473: %left ',' ! 474: %left OR ! 475: %left AND ! 476: %left '|' ! 477: %left '^' ! 478: %left '&' ! 479: %left EQUAL NOTEQUAL ! 480: %left '<' '>' LEQ GEQ ! 481: %left LSH RSH ! 482: %left '+' '-' ! 483: %left '*' '/' '%' ! 484: %right UNARY ! 485: ! 486: /* %expect 40 */ ! 487: ! 488: %% ! 489: ! 490: start : exp1 ! 491: { expression_value = $1; } ! 492: ; ! 493: ! 494: /* Expressions, including the comma operator. */ ! 495: exp1 : exp ! 496: | exp1 ',' exp ! 497: { $$ = $3; } ! 498: ; ! 499: ! 500: /* Expressions, not including the comma operator. */ ! 501: exp : '-' exp %prec UNARY ! 502: { $$ = - $2; } ! 503: | '!' exp %prec UNARY ! 504: { $$ = ! $2; } ! 505: | '~' exp %prec UNARY ! 506: { $$ = ~ $2; } ! 507: | '(' exp1 ')' ! 508: { $$ = $2; } ! 509: ; ! 510: ! 511: /* Binary operators in order of decreasing precedence. */ ! 512: exp : exp '*' exp ! 513: { $$ = $1 * $3; } ! 514: | exp '/' exp ! 515: { $$ = $1 / $3; } ! 516: | exp '%' exp ! 517: { $$ = $1 % $3; } ! 518: | exp '+' exp ! 519: { $$ = $1 + $3; } ! 520: | exp '-' exp ! 521: { $$ = $1 - $3; } ! 522: | exp LSH exp ! 523: { $$ = $1 << $3; } ! 524: | exp RSH exp ! 525: { $$ = $1 >> $3; } ! 526: | exp EQUAL exp ! 527: { $$ = ($1 == $3); } ! 528: | exp NOTEQUAL exp ! 529: { $$ = ($1 != $3); } ! 530: | exp LEQ exp ! 531: { $$ = ($1 <= $3); } ! 532: | exp GEQ exp ! 533: { $$ = ($1 >= $3); } ! 534: | exp '<' exp ! 535: { $$ = ($1 < $3); } ! 536: | exp '>' exp ! 537: { $$ = ($1 > $3); } ! 538: | exp '&' exp ! 539: { $$ = ($1 & $3); } ! 540: | exp '^' exp ! 541: { $$ = ($1 ^ $3); } ! 542: | exp '|' exp ! 543: { $$ = ($1 | $3); } ! 544: | exp AND exp ! 545: { $$ = ($1 && $3); } ! 546: | exp OR exp ! 547: { $$ = ($1 || $3); } ! 548: | exp '?' exp ':' exp ! 549: { $$ = $1 ? $3 : $5; } ! 550: | INT ! 551: { $$ = yylval.lval; } ! 552: | CHAR ! 553: { $$ = yylval.lval; } ! 554: | NAME ! 555: { $$ = 0; } ! 556: ; ! 557: %% ! 558: ! 559: /* During parsing of a C expression, the pointer to the next character ! 560: is in this variable. */ ! 561: ! 562: static char *lexptr; ! 563: ! 564: /* Take care of parsing a number (anything that starts with a digit). ! 565: Set yylval and return the token type; update lexptr. ! 566: LEN is the number of characters in it. */ ! 567: ! 568: /* maybe needs to actually deal with floating point numbers */ ! 569: ! 570: static int ! 571: parse_number (olen) ! 572: int olen; ! 573: { ! 574: register char *p = lexptr; ! 575: register long n = 0; ! 576: register int c; ! 577: register int base = 10; ! 578: register len = olen; ! 579: char *err_copy; ! 580: ! 581: extern double atof (); ! 582: ! 583: for (c = 0; c < len; c++) ! 584: if (p[c] == '.') { ! 585: /* It's a float since it contains a point. */ ! 586: yyerror ("floating point numbers not allowed in #if expressions"); ! 587: return ERROR; ! 588: ! 589: /* **************** ! 590: yylval.dval = atof (p); ! 591: lexptr += len; ! 592: return FLOAT; ! 593: **************** */ ! 594: } ! 595: ! 596: if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) { ! 597: p += 2; ! 598: base = 16; ! 599: len -= 2; ! 600: } ! 601: else if (*p == '0') ! 602: base = 8; ! 603: ! 604: while (len-- > 0) { ! 605: c = *p++; ! 606: n *= base; ! 607: if (c >= '0' && c <= '9') ! 608: n += c - '0'; ! 609: else { ! 610: if (c >= 'A' && c <= 'Z') c += 'a' - 'A'; ! 611: if (base == 16 && c >= 'a' && c <= 'f') ! 612: n += c - 'a' + 10; ! 613: else if (len == 0 && c == 'l') ! 614: ; ! 615: else { ! 616: yyerror ("Invalid number in #if expression"); ! 617: return ERROR; ! 618: } ! 619: } ! 620: } ! 621: ! 622: lexptr = p; ! 623: yylval.lval = n; ! 624: return INT; ! 625: } ! 626: ! 627: struct token { ! 628: char *operator; ! 629: int token; ! 630: }; ! 631: ! 632: #define NULL 0 ! 633: ! 634: static struct token tokentab2[] = { ! 635: {"&&", AND}, ! 636: {"||", OR}, ! 637: {"<<", LSH}, ! 638: {">>", RSH}, ! 639: {"==", EQUAL}, ! 640: {"!=", NOTEQUAL}, ! 641: {"<=", LEQ}, ! 642: {">=", GEQ}, ! 643: {NULL, ERROR} ! 644: }; ! 645: ! 646: /* Read one token, getting characters through lexptr. */ ! 647: ! 648: static int ! 649: yylex () ! 650: { ! 651: register int c; ! 652: register int namelen; ! 653: register char *tokstart; ! 654: register struct token *toktab; ! 655: ! 656: retry: ! 657: ! 658: tokstart = lexptr; ! 659: c = *tokstart; ! 660: /* See if it is a special token of length 2. */ ! 661: for (toktab = tokentab2; toktab->operator != NULL; toktab++) ! 662: if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) { ! 663: lexptr += 2; ! 664: return toktab->token; ! 665: } ! 666: ! 667: switch (c) { ! 668: case 0: ! 669: return 0; ! 670: ! 671: case ' ': ! 672: case '\t': ! 673: case '\n': ! 674: lexptr++; ! 675: goto retry; ! 676: ! 677: case '\'': ! 678: lexptr++; ! 679: c = *lexptr++; ! 680: if (c == '\\') ! 681: c = parse_escape (&lexptr); ! 682: yylval.lval = c; ! 683: c = *lexptr++; ! 684: if (c != '\'') { ! 685: yyerror ("Invalid character constant in #if"); ! 686: return ERROR; ! 687: } ! 688: ! 689: return CHAR; ! 690: ! 691: /* some of these chars are invalid in constant expressions; ! 692: maybe do something about them later */ ! 693: case '/': ! 694: case '+': ! 695: case '-': ! 696: case '*': ! 697: case '%': ! 698: case '|': ! 699: case '&': ! 700: case '^': ! 701: case '~': ! 702: case '!': ! 703: case '@': ! 704: case '<': ! 705: case '>': ! 706: case '(': ! 707: case ')': ! 708: case '[': ! 709: case ']': ! 710: case '.': ! 711: case '?': ! 712: case ':': ! 713: case '=': ! 714: case '{': ! 715: case '}': ! 716: case ',': ! 717: lexptr++; ! 718: return c; ! 719: ! 720: case '"': ! 721: yyerror ("double quoted strings not allowed in #if expressions"); ! 722: return ERROR; ! 723: } ! 724: if (c >= '0' && c <= '9') { ! 725: /* It's a number */ ! 726: for (namelen = 0; ! 727: c = tokstart[namelen], is_idchar[c] || c == '.'; ! 728: namelen++) ! 729: ; ! 730: return parse_number (namelen); ! 731: } ! 732: ! 733: if (!is_idstart[c]) { ! 734: yyerror ("Invalid token in expression"); ! 735: return ERROR; ! 736: } ! 737: ! 738: /* It is a name. See how long it is. */ ! 739: ! 740: for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++) ! 741: ; ! 742: ! 743: lexptr += namelen; ! 744: return NAME; ! 745: } ! 746: ! 747: ! 748: /* Parse a C escape sequence. STRING_PTR points to a variable ! 749: containing a pointer to the string to parse. That pointer ! 750: is updated past the characters we use. The value of the ! 751: escape sequence is returned. ! 752: ! 753: A negative value means the sequence \ newline was seen, ! 754: which is supposed to be equivalent to nothing at all. ! 755: ! 756: If \ is followed by a null character, we return a negative ! 757: value and leave the string pointer pointing at the null character. ! 758: ! 759: If \ is followed by 000, we return 0 and leave the string pointer ! 760: after the zeros. A value of 0 does not mean end of string. */ ! 761: ! 762: static int ! 763: parse_escape (string_ptr) ! 764: char **string_ptr; ! 765: { ! 766: register int c = *(*string_ptr)++; ! 767: switch (c) ! 768: { ! 769: case 'a': ! 770: return '\a'; ! 771: case 'b': ! 772: return '\b'; ! 773: case 'e': ! 774: return 033; ! 775: case 'f': ! 776: return '\f'; ! 777: case 'n': ! 778: return '\n'; ! 779: case 'r': ! 780: return '\r'; ! 781: case 't': ! 782: return '\t'; ! 783: case 'v': ! 784: return '\v'; ! 785: case '\n': ! 786: return -2; ! 787: case 0: ! 788: (*string_ptr)--; ! 789: return 0; ! 790: case '^': ! 791: c = *(*string_ptr)++; ! 792: if (c == '\\') ! 793: c = parse_escape (string_ptr); ! 794: if (c == '?') ! 795: return 0177; ! 796: return (c & 0200) | (c & 037); ! 797: ! 798: case '0': ! 799: case '1': ! 800: case '2': ! 801: case '3': ! 802: case '4': ! 803: case '5': ! 804: case '6': ! 805: case '7': ! 806: { ! 807: register int i = c - '0'; ! 808: register int count = 0; ! 809: while (++count < 3) ! 810: { ! 811: if ((c = *(*string_ptr)++) >= '0' && c <= '7') ! 812: { ! 813: i *= 8; ! 814: i += c - '0'; ! 815: } ! 816: else ! 817: { ! 818: (*string_ptr)--; ! 819: break; ! 820: } ! 821: } ! 822: return i; ! 823: } ! 824: default: ! 825: return c; ! 826: } ! 827: } ! 828: ! 829: static ! 830: yyerror (s) ! 831: char *s; ! 832: { ! 833: error (s); ! 834: longjmp (parse_return_error, 1); ! 835: } ! 836: ! 837: /* This page contains the entry point to this file. */ ! 838: ! 839: /* Parse STRING as an expression, and complain if this fails ! 840: to use up all of the contents of STRING. */ ! 841: /* We do not support C comments. They should be removed before ! 842: this function is called. */ ! 843: ! 844: int ! 845: parse_c_expression (string) ! 846: char *string; ! 847: { ! 848: lexptr = string; ! 849: ! 850: if (lexptr == 0 || *lexptr == 0) { ! 851: error ("empty #if expression"); ! 852: return 0; /* don't include the #if group */ ! 853: } ! 854: ! 855: /* if there is some sort of scanning error, just return 0 and assume ! 856: the parsing routine has printed an error message somewhere. ! 857: there is surely a better thing to do than this. */ ! 858: if (setjmp(parse_return_error)) ! 859: return 0; ! 860: ! 861: if (yyparse ()) ! 862: return 0; /* actually this is never reached ! 863: the way things stand. */ ! 864: if (*lexptr) ! 865: error ("Junk after end of expression."); ! 866: ! 867: return expression_value; /* set by yyparse() */ ! 868: } ! 869: ! 870: #ifdef TEST_EXP_READER ! 871: /* main program, for testing purposes. */ ! 872: main() ! 873: { ! 874: int n; ! 875: char buf[1024]; ! 876: extern int yydebug; ! 877: /* ! 878: yydebug = 1; ! 879: */ ! 880: initialize_random_junk (); ! 881: ! 882: for (;;) { ! 883: printf("enter expression: "); ! 884: n = 0; ! 885: while ((buf[n] = getchar()) != '\n') ! 886: n++; ! 887: buf[n] = '\0'; ! 888: printf("parser returned %d\n", parse_c_expression(buf)); ! 889: } ! 890: } ! 891: ! 892: /* table to tell if char can be part of a C identifier. */ ! 893: char is_idchar[256]; ! 894: /* table to tell if char can be first char of a c identifier. */ ! 895: char is_idstart[256]; ! 896: /* table to tell if c is horizontal space. isspace() thinks that ! 897: newline is space; this is not a good idea for this program. */ ! 898: char is_hor_space[256]; ! 899: ! 900: /* ! 901: * initialize random junk in the hash table and maybe other places ! 902: */ ! 903: initialize_random_junk() ! 904: { ! 905: register int i; ! 906: ! 907: /* ! 908: * Set up is_idchar and is_idstart tables. These should be ! 909: * faster than saying (is_alpha(c) || c == '_'), etc. ! 910: * Must do set up these things before calling any routines tthat ! 911: * refer to them. ! 912: */ ! 913: for (i = 'a'; i <= 'z'; i++) { ! 914: ++is_idchar[i - 'a' + 'A']; ! 915: ++is_idchar[i]; ! 916: ++is_idstart[i - 'a' + 'A']; ! 917: ++is_idstart[i]; ! 918: } ! 919: for (i = '0'; i <= '9'; i++) ! 920: ++is_idchar[i]; ! 921: ++is_idchar['_']; ! 922: ++is_idstart['_']; ! 923: #ifdef DOLLARS_IN_IDENTIFIERS ! 924: ++is_idchar['$']; ! 925: ++is_idstart['$']; ! 926: #endif ! 927: ! 928: /* horizontal space table */ ! 929: ++is_hor_space[' ']; ! 930: ++is_hor_space['\t']; ! 931: } ! 932: ! 933: error (msg) ! 934: { ! 935: printf("error: %s\n", msg); ! 936: } ! 937: #endif ! 938: 0707070114030157321006660005500000040000020640560426654766100001100000003137config.h /* Con
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.