1 /* A lexical scanner generated by flex */ 2 3 /* Scanner skeleton version: 4 * $Header: /tank/opengrok/rsync2/NetBSD/src/sys/external/bsd/acpica/dist/compiler/lex.yy.c,v 1.2 2025/08/24 16:45:58 christos Exp $ 5 */ 6 7 #define FLEX_SCANNER 8 #define YY_FLEX_MAJOR_VERSION 2 9 #define YY_FLEX_MINOR_VERSION 5 10 11 #include <stdio.h> 12 13 14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 15 #ifdef c_plusplus 16 #ifndef __cplusplus 17 #define __cplusplus 18 #endif 19 #endif 20 21 22 #ifdef __cplusplus 23 24 #include <stdlib.h> 25 #include <unistd.h> 26 27 /* Use prototypes in function declarations. */ 28 #define YY_USE_PROTOS 29 30 /* The "const" storage-class-modifier is valid. */ 31 #define YY_USE_CONST 32 33 #else /* ! __cplusplus */ 34 35 #if __STDC__ 36 37 #define YY_USE_PROTOS 38 #define YY_USE_CONST 39 40 #endif /* __STDC__ */ 41 #endif /* ! __cplusplus */ 42 43 #ifdef __TURBOC__ 44 #pragma warn -rch 45 #pragma warn -use 46 #include <io.h> 47 #include <stdlib.h> 48 #define YY_USE_CONST 49 #define YY_USE_PROTOS 50 #endif 51 52 #ifdef YY_USE_CONST 53 #define yyconst const 54 #else 55 #define yyconst 56 #endif 57 58 59 #ifdef YY_USE_PROTOS 60 #define YY_PROTO(proto) proto 61 #else 62 #define YY_PROTO(proto) () 63 #endif 64 65 /* Returned upon end-of-file. */ 66 #define YY_NULL 0 67 68 /* Promotes a possibly negative, possibly signed char to an unsigned 69 * integer for use as an array index. If the signed char is negative, 70 * we want to instead treat it as an 8-bit unsigned char, hence the 71 * double cast. 72 */ 73 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 74 75 /* Enter a start condition. This macro really ought to take a parameter, 76 * but we do it the disgusting crufty way forced on us by the ()-less 77 * definition of BEGIN. 78 */ 79 #define BEGIN yy_start = 1 + 2 * 80 81 /* Translate the current start state into a value that can be later handed 82 * to BEGIN to return to the state. The YYSTATE alias is for lex 83 * compatibility. 84 */ 85 #define YY_START ((yy_start - 1) / 2) 86 #define YYSTATE YY_START 87 88 /* Action number for EOF rule of a given start state. */ 89 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 90 91 /* Special action meaning "start processing a new file". */ 92 #define YY_NEW_FILE yyrestart( yyin ) 93 94 #define YY_END_OF_BUFFER_CHAR 0 95 96 /* Size of default input buffer. */ 97 #define YY_BUF_SIZE 16384 98 99 typedef struct yy_buffer_state *YY_BUFFER_STATE; 100 101 extern int yyleng; 102 extern FILE *yyin, *yyout; 103 104 #define EOB_ACT_CONTINUE_SCAN 0 105 #define EOB_ACT_END_OF_FILE 1 106 #define EOB_ACT_LAST_MATCH 2 107 108 /* The funky do-while in the following #define is used to turn the definition 109 * int a single C statement (which needs a semi-colon terminator). This 110 * avoids problems with code like: 111 * 112 * if ( condition_holds ) 113 * yyless( 5 ); 114 * else 115 * do_something_else(); 116 * 117 * Prior to using the do-while the compiler would get upset at the 118 * "else" because it interpreted the "if" statement as being all 119 * done when it reached the ';' after the yyless() call. 120 */ 121 122 /* Return all but the first 'n' matched characters back to the input stream. */ 123 124 #define yyless(n) \ 125 do \ 126 { \ 127 /* Undo effects of setting up yytext. */ \ 128 *yy_cp = yy_hold_char; \ 129 YY_RESTORE_YY_MORE_OFFSET \ 130 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 131 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 132 } \ 133 while ( 0 ) 134 135 #define unput(c) yyunput( c, yytext_ptr ) 136 137 /* The following is because we cannot portably get our hands on size_t 138 * (without autoconf's help, which isn't available because we want 139 * flex-generated scanners to compile on their own). 140 */ 141 typedef unsigned int yy_size_t; 142 143 144 struct yy_buffer_state 145 { 146 FILE *yy_input_file; 147 148 char *yy_ch_buf; /* input buffer */ 149 char *yy_buf_pos; /* current position in input buffer */ 150 151 /* Size of input buffer in bytes, not including room for EOB 152 * characters. 153 */ 154 yy_size_t yy_buf_size; 155 156 /* Number of characters read into yy_ch_buf, not including EOB 157 * characters. 158 */ 159 int yy_n_chars; 160 161 /* Whether we "own" the buffer - i.e., we know we created it, 162 * and can realloc() it to grow it, and should free() it to 163 * delete it. 164 */ 165 int yy_is_our_buffer; 166 167 /* Whether this is an "interactive" input source; if so, and 168 * if we're using stdio for input, then we want to use getc() 169 * instead of fread(), to make sure we stop fetching input after 170 * each newline. 171 */ 172 int yy_is_interactive; 173 174 /* Whether we're considered to be at the beginning of a line. 175 * If so, '^' rules will be active on the next match, otherwise 176 * not. 177 */ 178 int yy_at_bol; 179 180 /* Whether to try to fill the input buffer when we reach the 181 * end of it. 182 */ 183 int yy_fill_buffer; 184 185 int yy_buffer_status; 186 #define YY_BUFFER_NEW 0 187 #define YY_BUFFER_NORMAL 1 188 /* When an EOF's been seen but there's still some text to process 189 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 190 * shouldn't try reading from the input source any more. We might 191 * still have a bunch of tokens to match, though, because of 192 * possible backing-up. 193 * 194 * When we actually see the EOF, we change the status to "new" 195 * (via yyrestart()), so that the user can continue scanning by 196 * just pointing yyin at a new input file. 197 */ 198 #define YY_BUFFER_EOF_PENDING 2 199 }; 200 201 static YY_BUFFER_STATE yy_current_buffer = 0; 202 203 /* We provide macros for accessing buffer states in case in the 204 * future we want to put the buffer states in a more general 205 * "scanner state". 206 */ 207 #define YY_CURRENT_BUFFER yy_current_buffer 208 209 210 /* yy_hold_char holds the character lost when yytext is formed. */ 211 static char yy_hold_char; 212 213 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 214 215 216 int yyleng; 217 218 /* Points to current character in buffer. */ 219 static char *yy_c_buf_p = (char *) 0; 220 static int yy_init = 1; /* whether we need to initialize */ 221 static int yy_start = 0; /* start state number */ 222 223 /* Flag which is used to allow yywrap()'s to do buffer switches 224 * instead of setting up a fresh yyin. A bit of a hack ... 225 */ 226 static int yy_did_buffer_switch_on_eof; 227 228 void yyrestart YY_PROTO(( FILE *input_file )); 229 230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 231 void yy_load_buffer_state YY_PROTO(( void )); 232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 237 238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 241 242 static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 244 static void yy_flex_free YY_PROTO(( void * )); 245 246 #define yy_new_buffer yy_create_buffer 247 248 #define yy_set_interactive(is_interactive) \ 249 { \ 250 if ( ! yy_current_buffer ) \ 251 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 252 yy_current_buffer->yy_is_interactive = is_interactive; \ 253 } 254 255 #define yy_set_bol(at_bol) \ 256 { \ 257 if ( ! yy_current_buffer ) \ 258 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 259 yy_current_buffer->yy_at_bol = at_bol; \ 260 } 261 262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 263 264 265 #define yywrap() 1 266 #define YY_SKIP_YYWRAP 267 typedef unsigned char YY_CHAR; 268 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 269 typedef int yy_state_type; 270 extern char *yytext; 271 #define yytext_ptr yytext 272 273 static yy_state_type yy_get_previous_state YY_PROTO(( void )); 274 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 275 static int yy_get_next_buffer YY_PROTO(( void )); 276 static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 277 278 /* Done after the current pattern has been matched and before the 279 * corresponding action - sets up yytext. 280 */ 281 #define YY_DO_BEFORE_ACTION \ 282 yytext_ptr = yy_bp; \ 283 yyleng = (int) (yy_cp - yy_bp); \ 284 yy_hold_char = *yy_cp; \ 285 *yy_cp = '\0'; \ 286 yy_c_buf_p = yy_cp; 287 288 #define YY_NUM_RULES 32 289 #define YY_END_OF_BUFFER 33 290 static yyconst short int yy_accept[50] = 291 { 0, 292 0, 0, 33, 31, 30, 29, 6, 9, 20, 3, 293 4, 7, 10, 11, 8, 27, 27, 14, 31, 15, 294 26, 26, 21, 26, 22, 5, 30, 19, 23, 1, 295 2, 27, 0, 13, 16, 18, 17, 12, 26, 26, 296 26, 24, 28, 26, 26, 26, 26, 25, 0 297 } ; 298 299 static yyconst int yy_ec[256] = 300 { 0, 301 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 302 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 303 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 304 1, 2, 4, 1, 1, 1, 5, 6, 1, 7, 305 8, 9, 10, 1, 11, 1, 12, 13, 14, 14, 306 14, 14, 14, 14, 14, 14, 14, 1, 1, 15, 307 16, 17, 1, 1, 18, 18, 18, 18, 18, 18, 308 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 309 19, 19, 19, 19, 19, 19, 19, 20, 19, 19, 310 1, 1, 1, 21, 1, 1, 18, 18, 18, 22, 311 312 23, 24, 19, 19, 25, 19, 19, 19, 19, 26, 313 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 314 19, 19, 1, 27, 1, 28, 1, 1, 1, 1, 315 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 316 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 317 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 318 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 319 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 320 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 321 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 322 323 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 324 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 325 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 326 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 327 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 328 1, 1, 1, 1, 1 329 } ; 330 331 static yyconst int yy_meta[29] = 332 { 0, 333 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 334 1, 1, 2, 2, 1, 1, 1, 2, 3, 4, 335 1, 2, 2, 2, 3, 3, 1, 1 336 } ; 337 338 static yyconst short int yy_base[54] = 339 { 0, 340 0, 0, 72, 73, 69, 73, 54, 73, 63, 73, 341 73, 73, 73, 73, 20, 48, 47, 15, 50, 17, 342 16, 0, 73, 24, 38, 73, 62, 73, 73, 73, 343 73, 43, 0, 73, 73, 73, 73, 73, 39, 0, 344 14, 73, 0, 20, 35, 37, 30, 0, 73, 49, 345 52, 55, 46 346 } ; 347 348 static yyconst short int yy_def[54] = 349 { 0, 350 49, 1, 49, 49, 49, 49, 49, 49, 49, 49, 351 49, 49, 49, 49, 49, 50, 50, 49, 49, 49, 352 51, 52, 49, 51, 49, 49, 49, 49, 49, 49, 353 49, 50, 53, 49, 49, 49, 49, 49, 24, 52, 354 24, 49, 53, 51, 52, 52, 52, 52, 0, 49, 355 49, 49, 49 356 } ; 357 358 static yyconst short int yy_nxt[102] = 359 { 0, 360 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 361 14, 15, 16, 17, 18, 19, 20, 21, 22, 22, 362 23, 24, 21, 21, 22, 22, 25, 26, 30, 34, 363 35, 31, 37, 38, 40, 40, 39, 44, 40, 40, 364 40, 40, 40, 40, 45, 40, 41, 43, 40, 40, 365 32, 48, 32, 39, 39, 39, 40, 40, 40, 47, 366 46, 39, 49, 27, 42, 36, 49, 33, 29, 28, 367 27, 49, 3, 49, 49, 49, 49, 49, 49, 49, 368 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 369 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 370 371 49 372 } ; 373 374 static yyconst short int yy_chk[102] = 375 { 0, 376 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 377 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 378 1, 1, 1, 1, 1, 1, 1, 1, 15, 18, 379 18, 15, 20, 20, 21, 21, 41, 41, 44, 44, 380 21, 21, 24, 24, 44, 44, 24, 53, 24, 24, 381 50, 47, 50, 51, 51, 51, 52, 52, 52, 46, 382 45, 39, 32, 27, 25, 19, 17, 16, 9, 7, 383 5, 3, 49, 49, 49, 49, 49, 49, 49, 49, 384 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 385 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 386 387 49 388 } ; 389 390 static yy_state_type yy_last_accepting_state; 391 static char *yy_last_accepting_cpos; 392 393 /* The intent behind this definition is that it'll catch 394 * any uses of REJECT which flex missed. 395 */ 396 #define REJECT reject_used_but_not_detected 397 #define yymore() yymore_used_but_not_detected 398 #define YY_MORE_ADJ 0 399 #define YY_RESTORE_YY_MORE_OFFSET 400 char *yytext; 401 #line 1 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 402 #define INITIAL 0 403 #line 2 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 404 /****************************************************************************** 405 * 406 * Module Name: prparser.l - Flex input file for preprocessor lexer 407 * 408 *****************************************************************************/ 409 410 /****************************************************************************** 411 * 412 * 1. Copyright Notice 413 * 414 * Some or all of this work - Copyright (c) 1999 - 2025, Intel Corp. 415 * All rights reserved. 416 * 417 * 2. License 418 * 419 * 2.1. This is your license from Intel Corp. under its intellectual property 420 * rights. You may have additional license terms from the party that provided 421 * you this software, covering your right to use that party's intellectual 422 * property rights. 423 * 424 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 425 * copy of the source code appearing in this file ("Covered Code") an 426 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 427 * base code distributed originally by Intel ("Original Intel Code") to copy, 428 * make derivatives, distribute, use and display any portion of the Covered 429 * Code in any form, with the right to sublicense such rights; and 430 * 431 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 432 * license (with the right to sublicense), under only those claims of Intel 433 * patents that are infringed by the Original Intel Code, to make, use, sell, 434 * offer to sell, and import the Covered Code and derivative works thereof 435 * solely to the minimum extent necessary to exercise the above copyright 436 * license, and in no event shall the patent license extend to any additions 437 * to or modifications of the Original Intel Code. No other license or right 438 * is granted directly or by implication, estoppel or otherwise; 439 * 440 * The above copyright and patent license is granted only if the following 441 * conditions are met: 442 * 443 * 3. Conditions 444 * 445 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 446 * Redistribution of source code of any substantial portion of the Covered 447 * Code or modification with rights to further distribute source must include 448 * the above Copyright Notice, the above License, this list of Conditions, 449 * and the following Disclaimer and Export Compliance provision. In addition, 450 * Licensee must cause all Covered Code to which Licensee contributes to 451 * contain a file documenting the changes Licensee made to create that Covered 452 * Code and the date of any change. Licensee must include in that file the 453 * documentation of any changes made by any predecessor Licensee. Licensee 454 * must include a prominent statement that the modification is derived, 455 * directly or indirectly, from Original Intel Code. 456 * 457 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 458 * Redistribution of source code of any substantial portion of the Covered 459 * Code or modification without rights to further distribute source must 460 * include the following Disclaimer and Export Compliance provision in the 461 * documentation and/or other materials provided with distribution. In 462 * addition, Licensee may not authorize further sublicense of source of any 463 * portion of the Covered Code, and must include terms to the effect that the 464 * license from Licensee to its licensee is limited to the intellectual 465 * property embodied in the software Licensee provides to its licensee, and 466 * not to intellectual property embodied in modifications its licensee may 467 * make. 468 * 469 * 3.3. Redistribution of Executable. Redistribution in executable form of any 470 * substantial portion of the Covered Code or modification must reproduce the 471 * above Copyright Notice, and the following Disclaimer and Export Compliance 472 * provision in the documentation and/or other materials provided with the 473 * distribution. 474 * 475 * 3.4. Intel retains all right, title, and interest in and to the Original 476 * Intel Code. 477 * 478 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 479 * Intel shall be used in advertising or otherwise to promote the sale, use or 480 * other dealings in products derived from or relating to the Covered Code 481 * without prior written authorization from Intel. 482 * 483 * 4. Disclaimer and Export Compliance 484 * 485 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 486 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 487 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 488 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 489 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 490 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 491 * PARTICULAR PURPOSE. 492 * 493 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 494 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 495 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 496 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 497 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 498 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 499 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 500 * LIMITED REMEDY. 501 * 502 * 4.3. Licensee shall not export, either directly or indirectly, any of this 503 * software or system incorporating such software without first obtaining any 504 * required license or other approval from the U. S. Department of Commerce or 505 * any other agency or department of the United States Government. In the 506 * event Licensee exports any such software from the United States or 507 * re-exports any such software from a foreign destination, Licensee shall 508 * ensure that the distribution and export/re-export of the software is in 509 * compliance with all laws, regulations, orders, or other restrictions of the 510 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 511 * any of its subsidiaries will export/re-export any technical data, process, 512 * software, or service, directly or indirectly, to any country for which the 513 * United States government or any agency thereof requires an export license, 514 * other governmental approval, or letter of assurance, without first obtaining 515 * such license, approval or letter. 516 * 517 ***************************************************************************** 518 * 519 * Alternatively, you may choose to be licensed under the terms of the 520 * following license: 521 * 522 * Redistribution and use in source and binary forms, with or without 523 * modification, are permitted provided that the following conditions 524 * are met: 525 * 1. Redistributions of source code must retain the above copyright 526 * notice, this list of conditions, and the following disclaimer, 527 * without modification. 528 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 529 * substantially similar to the "NO WARRANTY" disclaimer below 530 * ("Disclaimer") and any redistribution must be conditioned upon 531 * including a substantially similar Disclaimer requirement for further 532 * binary redistribution. 533 * 3. Neither the names of the above-listed copyright holders nor the names 534 * of any contributors may be used to endorse or promote products derived 535 * from this software without specific prior written permission. 536 * 537 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 538 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 539 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 540 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 541 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 542 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 543 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 544 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 545 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 546 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 547 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 548 * 549 * Alternatively, you may choose to be licensed under the terms of the 550 * GNU General Public License ("GPL") version 2 as published by the Free 551 * Software Foundation. 552 * 553 *****************************************************************************/ 554 555 #include "aslcompiler.h" 556 #include "prparser.y.h" 557 558 /* Buffer to pass strings to the parser */ 559 560 #define STRING_SETUP strcpy (AslGbl_StringBuffer, PrParsertext);\ 561 PrParserlval.str = AslGbl_StringBuffer 562 563 #define _COMPONENT ACPI_COMPILER 564 ACPI_MODULE_NAME ("prscanner") 565 566 567 /* Local prototypes */ 568 569 static char 570 PrDoCommentType1 ( 571 void); 572 573 static char 574 PrDoCommentType2 ( 575 void); 576 #line 577 "lex.yy.c" 577 578 /* Macros after this point can all be overridden by user definitions in 579 * section 1. 580 */ 581 582 #ifndef YY_SKIP_YYWRAP 583 #ifdef __cplusplus 584 extern "C" int yywrap YY_PROTO(( void )); 585 #else 586 extern int yywrap YY_PROTO(( void )); 587 #endif 588 #endif 589 590 #ifndef YY_NO_UNPUT 591 static void yyunput YY_PROTO(( int c, char *buf_ptr )); 592 #endif 593 594 #ifndef yytext_ptr 595 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 596 #endif 597 598 #ifdef YY_NEED_STRLEN 599 static int yy_flex_strlen YY_PROTO(( yyconst char * )); 600 #endif 601 602 #ifndef YY_NO_INPUT 603 #ifdef __cplusplus 604 static int yyinput YY_PROTO(( void )); 605 #else 606 static int input YY_PROTO(( void )); 607 #endif 608 #endif 609 610 #if YY_STACK_USED 611 static int yy_start_stack_ptr = 0; 612 static int yy_start_stack_depth = 0; 613 static int *yy_start_stack = 0; 614 #ifndef YY_NO_PUSH_STATE 615 static void yy_push_state YY_PROTO(( int new_state )); 616 #endif 617 #ifndef YY_NO_POP_STATE 618 static void yy_pop_state YY_PROTO(( void )); 619 #endif 620 #ifndef YY_NO_TOP_STATE 621 static int yy_top_state YY_PROTO(( void )); 622 #endif 623 624 #else 625 #define YY_NO_PUSH_STATE 1 626 #define YY_NO_POP_STATE 1 627 #define YY_NO_TOP_STATE 1 628 #endif 629 630 #ifdef YY_MALLOC_DECL 631 YY_MALLOC_DECL 632 #else 633 #if __STDC__ 634 #ifndef __cplusplus 635 #include <stdlib.h> 636 #endif 637 #else 638 /* Just try to get by without declaring the routines. This will fail 639 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 640 * or sizeof(void*) != sizeof(int). 641 */ 642 #endif 643 #endif 644 645 /* Amount of stuff to slurp up with each read. */ 646 #ifndef YY_READ_BUF_SIZE 647 #define YY_READ_BUF_SIZE 8192 648 #endif 649 650 /* Copy whatever the last rule matched to the standard output. */ 651 652 #ifndef ECHO 653 /* This used to be an fputs(), but since the string might contain NUL's, 654 * we now use fwrite(). 655 */ 656 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 657 #endif 658 659 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 660 * is returned in "result". 661 */ 662 #ifndef YY_INPUT 663 #define YY_INPUT(buf,result,max_size) \ 664 if ( yy_current_buffer->yy_is_interactive ) \ 665 { \ 666 int c = '*', n; \ 667 for ( n = 0; n < max_size && \ 668 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 669 buf[n] = (char) c; \ 670 if ( c == '\n' ) \ 671 buf[n++] = (char) c; \ 672 if ( c == EOF && ferror( yyin ) ) \ 673 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 674 result = n; \ 675 } \ 676 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 677 && ferror( yyin ) ) \ 678 YY_FATAL_ERROR( "input in flex scanner failed" ); 679 #endif 680 681 /* No semi-colon after return; correct usage is to write "yyterminate();" - 682 * we don't want an extra ';' after the "return" because that will cause 683 * some compilers to complain about unreachable statements. 684 */ 685 #ifndef yyterminate 686 #define yyterminate() return YY_NULL 687 #endif 688 689 /* Number of entries by which start-condition stack grows. */ 690 #ifndef YY_START_STACK_INCR 691 #define YY_START_STACK_INCR 25 692 #endif 693 694 /* Report a fatal error. */ 695 #ifndef YY_FATAL_ERROR 696 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 697 #endif 698 699 /* Default declaration of generated scanner - a define so the user can 700 * easily add parameters. 701 */ 702 #ifndef YY_DECL 703 #define YY_DECL int yylex YY_PROTO(( void )) 704 #endif 705 706 /* Code executed at the beginning of each rule, after yytext and yyleng 707 * have been set up. 708 */ 709 #ifndef YY_USER_ACTION 710 #define YY_USER_ACTION 711 #endif 712 713 /* Code executed at the end of each rule. */ 714 #ifndef YY_BREAK 715 #define YY_BREAK break; 716 #endif 717 718 #define YY_RULE_SETUP \ 719 YY_USER_ACTION 720 721 YY_DECL 722 { 723 register yy_state_type yy_current_state; 724 register char *yy_cp, *yy_bp; 725 register int yy_act; 726 727 #line 184 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 728 729 #line 730 "lex.yy.c" 730 731 if ( yy_init ) 732 { 733 yy_init = 0; 734 735 #ifdef YY_USER_INIT 736 YY_USER_INIT; 737 #endif 738 739 if ( ! yy_start ) 740 yy_start = 1; /* first start state */ 741 742 if ( ! yyin ) 743 yyin = stdin; 744 745 if ( ! yyout ) 746 yyout = stdout; 747 748 if ( ! yy_current_buffer ) 749 yy_current_buffer = 750 yy_create_buffer( yyin, YY_BUF_SIZE ); 751 752 yy_load_buffer_state(); 753 } 754 755 while ( 1 ) /* loops until end-of-file is reached */ 756 { 757 yy_cp = yy_c_buf_p; 758 759 /* Support of yytext. */ 760 *yy_cp = yy_hold_char; 761 762 /* yy_bp points to the position in yy_ch_buf of the start of 763 * the current run. 764 */ 765 yy_bp = yy_cp; 766 767 yy_current_state = yy_start; 768 yy_match: 769 do 770 { 771 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 772 if ( yy_accept[yy_current_state] ) 773 { 774 yy_last_accepting_state = yy_current_state; 775 yy_last_accepting_cpos = yy_cp; 776 } 777 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 778 { 779 yy_current_state = (int) yy_def[yy_current_state]; 780 if ( yy_current_state >= 50 ) 781 yy_c = yy_meta[(unsigned int) yy_c]; 782 } 783 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 784 ++yy_cp; 785 } 786 while ( yy_base[yy_current_state] != 73 ); 787 788 yy_find_action: 789 yy_act = yy_accept[yy_current_state]; 790 if ( yy_act == 0 ) 791 { /* have to back up */ 792 yy_cp = yy_last_accepting_cpos; 793 yy_current_state = yy_last_accepting_state; 794 yy_act = yy_accept[yy_current_state]; 795 } 796 797 YY_DO_BEFORE_ACTION; 798 799 800 do_action: /* This label is used only to access EOF actions. */ 801 802 803 switch ( yy_act ) 804 { /* beginning of action switch */ 805 case 0: /* must back up */ 806 /* undo the effects of YY_DO_BEFORE_ACTION */ 807 *yy_cp = yy_hold_char; 808 yy_cp = yy_last_accepting_cpos; 809 yy_current_state = yy_last_accepting_state; 810 goto yy_find_action; 811 812 case 1: 813 YY_RULE_SETUP 814 #line 185 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 815 { if (!PrDoCommentType1 ()) {yyterminate ();} } 816 YY_BREAK 817 case 2: 818 YY_RULE_SETUP 819 #line 186 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 820 { if (!PrDoCommentType2 ()) {yyterminate ();} } 821 YY_BREAK 822 case 3: 823 YY_RULE_SETUP 824 #line 188 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 825 return (EXPOP_PAREN_OPEN); 826 YY_BREAK 827 case 4: 828 YY_RULE_SETUP 829 #line 189 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 830 return (EXPOP_PAREN_CLOSE); 831 YY_BREAK 832 case 5: 833 YY_RULE_SETUP 834 #line 190 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 835 return (EXPOP_ONES_COMPLIMENT); 836 YY_BREAK 837 case 6: 838 YY_RULE_SETUP 839 #line 191 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 840 return (EXPOP_LOGICAL_NOT); 841 YY_BREAK 842 case 7: 843 YY_RULE_SETUP 844 #line 192 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 845 return (EXPOP_MULTIPLY); 846 YY_BREAK 847 case 8: 848 YY_RULE_SETUP 849 #line 193 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 850 return (EXPOP_DIVIDE); 851 YY_BREAK 852 case 9: 853 YY_RULE_SETUP 854 #line 194 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 855 return (EXPOP_MODULO); 856 YY_BREAK 857 case 10: 858 YY_RULE_SETUP 859 #line 195 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 860 return (EXPOP_ADD); 861 YY_BREAK 862 case 11: 863 YY_RULE_SETUP 864 #line 196 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 865 return (EXPOP_SUBTRACT); 866 YY_BREAK 867 case 12: 868 YY_RULE_SETUP 869 #line 197 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 870 return (EXPOP_SHIFT_RIGHT); 871 YY_BREAK 872 case 13: 873 YY_RULE_SETUP 874 #line 198 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 875 return (EXPOP_SHIFT_LEFT); 876 YY_BREAK 877 case 14: 878 YY_RULE_SETUP 879 #line 199 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 880 return (EXPOP_LESS); 881 YY_BREAK 882 case 15: 883 YY_RULE_SETUP 884 #line 200 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 885 return (EXPOP_GREATER); 886 YY_BREAK 887 case 16: 888 YY_RULE_SETUP 889 #line 201 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 890 return (EXPOP_LESS_EQUAL); 891 YY_BREAK 892 case 17: 893 YY_RULE_SETUP 894 #line 202 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 895 return (EXPOP_GREATER_EQUAL); 896 YY_BREAK 897 case 18: 898 YY_RULE_SETUP 899 #line 203 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 900 return (EXPOP_EQUAL); 901 YY_BREAK 902 case 19: 903 YY_RULE_SETUP 904 #line 204 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 905 return (EXPOP_NOT_EQUAL); 906 YY_BREAK 907 case 20: 908 YY_RULE_SETUP 909 #line 205 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 910 return (EXPOP_AND); 911 YY_BREAK 912 case 21: 913 YY_RULE_SETUP 914 #line 206 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 915 return (EXPOP_XOR); 916 YY_BREAK 917 case 22: 918 YY_RULE_SETUP 919 #line 207 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 920 return (EXPOP_OR); 921 YY_BREAK 922 case 23: 923 YY_RULE_SETUP 924 #line 208 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 925 return (EXPOP_LOGICAL_AND); 926 YY_BREAK 927 case 24: 928 YY_RULE_SETUP 929 #line 209 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 930 return (EXPOP_LOGICAL_OR); 931 YY_BREAK 932 case 25: 933 YY_RULE_SETUP 934 #line 211 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 935 return (EXPOP_DEFINE); 936 YY_BREAK 937 case 26: 938 YY_RULE_SETUP 939 #line 212 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 940 {STRING_SETUP; return (EXPOP_IDENTIFIER);} 941 YY_BREAK 942 case YY_STATE_EOF(INITIAL): 943 #line 214 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 944 return (EXPOP_EOF); /* null end-of-string */ 945 YY_BREAK 946 case 27: 947 YY_RULE_SETUP 948 #line 216 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 949 return (EXPOP_NUMBER); 950 YY_BREAK 951 case 28: 952 YY_RULE_SETUP 953 #line 217 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 954 return (EXPOP_HEX_NUMBER); 955 YY_BREAK 956 case 29: 957 YY_RULE_SETUP 958 #line 218 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 959 return (EXPOP_NEW_LINE); 960 YY_BREAK 961 case 30: 962 YY_RULE_SETUP 963 #line 219 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 964 /* Ignore */ 965 YY_BREAK 966 case 31: 967 YY_RULE_SETUP 968 #line 221 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 969 return (EXPOP_EOF); 970 YY_BREAK 971 case 32: 972 YY_RULE_SETUP 973 #line 222 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 974 ECHO; 975 YY_BREAK 976 #line 977 "lex.yy.c" 977 978 case YY_END_OF_BUFFER: 979 { 980 /* Amount of text matched not including the EOB char. */ 981 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 982 983 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 984 *yy_cp = yy_hold_char; 985 YY_RESTORE_YY_MORE_OFFSET 986 987 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 988 { 989 /* We're scanning a new file or input source. It's 990 * possible that this happened because the user 991 * just pointed yyin at a new source and called 992 * yylex(). If so, then we have to assure 993 * consistency between yy_current_buffer and our 994 * globals. Here is the right place to do so, because 995 * this is the first action (other than possibly a 996 * back-up) that will match for the new input source. 997 */ 998 yy_n_chars = yy_current_buffer->yy_n_chars; 999 yy_current_buffer->yy_input_file = yyin; 1000 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 1001 } 1002 1003 /* Note that here we test for yy_c_buf_p "<=" to the position 1004 * of the first EOB in the buffer, since yy_c_buf_p will 1005 * already have been incremented past the NUL character 1006 * (since all states make transitions on EOB to the 1007 * end-of-buffer state). Contrast this with the test 1008 * in input(). 1009 */ 1010 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1011 { /* This was really a NUL. */ 1012 yy_state_type yy_next_state; 1013 1014 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 1015 1016 yy_current_state = yy_get_previous_state(); 1017 1018 /* Okay, we're now positioned to make the NUL 1019 * transition. We couldn't have 1020 * yy_get_previous_state() go ahead and do it 1021 * for us because it doesn't know how to deal 1022 * with the possibility of jamming (and we don't 1023 * want to build jamming into it because then it 1024 * will run more slowly). 1025 */ 1026 1027 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1028 1029 yy_bp = yytext_ptr + YY_MORE_ADJ; 1030 1031 if ( yy_next_state ) 1032 { 1033 /* Consume the NUL. */ 1034 yy_cp = ++yy_c_buf_p; 1035 yy_current_state = yy_next_state; 1036 goto yy_match; 1037 } 1038 1039 else 1040 { 1041 yy_cp = yy_c_buf_p; 1042 goto yy_find_action; 1043 } 1044 } 1045 1046 else switch ( yy_get_next_buffer() ) 1047 { 1048 case EOB_ACT_END_OF_FILE: 1049 { 1050 yy_did_buffer_switch_on_eof = 0; 1051 1052 if ( yywrap() ) 1053 { 1054 /* Note: because we've taken care in 1055 * yy_get_next_buffer() to have set up 1056 * yytext, we can now set up 1057 * yy_c_buf_p so that if some total 1058 * hoser (like flex itself) wants to 1059 * call the scanner after we return the 1060 * YY_NULL, it'll still work - another 1061 * YY_NULL will get returned. 1062 */ 1063 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 1064 1065 yy_act = YY_STATE_EOF(YY_START); 1066 goto do_action; 1067 } 1068 1069 else 1070 { 1071 if ( ! yy_did_buffer_switch_on_eof ) 1072 YY_NEW_FILE; 1073 } 1074 break; 1075 } 1076 1077 case EOB_ACT_CONTINUE_SCAN: 1078 yy_c_buf_p = 1079 yytext_ptr + yy_amount_of_matched_text; 1080 1081 yy_current_state = yy_get_previous_state(); 1082 1083 yy_cp = yy_c_buf_p; 1084 yy_bp = yytext_ptr + YY_MORE_ADJ; 1085 goto yy_match; 1086 1087 case EOB_ACT_LAST_MATCH: 1088 yy_c_buf_p = 1089 &yy_current_buffer->yy_ch_buf[yy_n_chars]; 1090 1091 yy_current_state = yy_get_previous_state(); 1092 1093 yy_cp = yy_c_buf_p; 1094 yy_bp = yytext_ptr + YY_MORE_ADJ; 1095 goto yy_find_action; 1096 } 1097 break; 1098 } 1099 1100 default: 1101 YY_FATAL_ERROR( 1102 "fatal flex scanner internal error--no action found" ); 1103 } /* end of action switch */ 1104 } /* end of scanning one token */ 1105 } /* end of yylex */ 1106 1107 1108 /* yy_get_next_buffer - try to read in a new buffer 1109 * 1110 * Returns a code representing an action: 1111 * EOB_ACT_LAST_MATCH - 1112 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1113 * EOB_ACT_END_OF_FILE - end of file 1114 */ 1115 1116 static int yy_get_next_buffer() 1117 { 1118 register char *dest = yy_current_buffer->yy_ch_buf; 1119 register char *source = yytext_ptr; 1120 register int number_to_move, i; 1121 int ret_val; 1122 1123 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 1124 YY_FATAL_ERROR( 1125 "fatal flex scanner internal error--end of buffer missed" ); 1126 1127 if ( yy_current_buffer->yy_fill_buffer == 0 ) 1128 { /* Don't try to fill the buffer, so this is an EOF. */ 1129 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 1130 { 1131 /* We matched a single character, the EOB, so 1132 * treat this as a final EOF. 1133 */ 1134 return EOB_ACT_END_OF_FILE; 1135 } 1136 1137 else 1138 { 1139 /* We matched some text prior to the EOB, first 1140 * process it. 1141 */ 1142 return EOB_ACT_LAST_MATCH; 1143 } 1144 } 1145 1146 /* Try to read more data. */ 1147 1148 /* First move last chars to start of buffer. */ 1149 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 1150 1151 for ( i = 0; i < number_to_move; ++i ) 1152 *(dest++) = *(source++); 1153 1154 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1155 /* don't do the read, it's not guaranteed to return an EOF, 1156 * just force an EOF 1157 */ 1158 yy_current_buffer->yy_n_chars = yy_n_chars = 0; 1159 1160 else 1161 { 1162 int num_to_read = 1163 yy_current_buffer->yy_buf_size - number_to_move - 1; 1164 1165 while ( num_to_read <= 0 ) 1166 { /* Not enough room in the buffer - grow it. */ 1167 #ifdef YY_USES_REJECT 1168 YY_FATAL_ERROR( 1169 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 1170 #else 1171 1172 /* just a shorter name for the current buffer */ 1173 YY_BUFFER_STATE b = yy_current_buffer; 1174 1175 int yy_c_buf_p_offset = 1176 (int) (yy_c_buf_p - b->yy_ch_buf); 1177 1178 if ( b->yy_is_our_buffer ) 1179 { 1180 int new_size = b->yy_buf_size * 2; 1181 1182 if ( new_size <= 0 ) 1183 b->yy_buf_size += b->yy_buf_size / 8; 1184 else 1185 b->yy_buf_size *= 2; 1186 1187 b->yy_ch_buf = (char *) 1188 /* Include room in for 2 EOB chars. */ 1189 yy_flex_realloc( (void *) b->yy_ch_buf, 1190 b->yy_buf_size + 2 ); 1191 } 1192 else 1193 /* Can't grow it, we don't own it. */ 1194 b->yy_ch_buf = 0; 1195 1196 if ( ! b->yy_ch_buf ) 1197 YY_FATAL_ERROR( 1198 "fatal error - scanner input buffer overflow" ); 1199 1200 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1201 1202 num_to_read = yy_current_buffer->yy_buf_size - 1203 number_to_move - 1; 1204 #endif 1205 } 1206 1207 if ( num_to_read > YY_READ_BUF_SIZE ) 1208 num_to_read = YY_READ_BUF_SIZE; 1209 1210 /* Read in more data. */ 1211 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 1212 yy_n_chars, num_to_read ); 1213 1214 yy_current_buffer->yy_n_chars = yy_n_chars; 1215 } 1216 1217 if ( yy_n_chars == 0 ) 1218 { 1219 if ( number_to_move == YY_MORE_ADJ ) 1220 { 1221 ret_val = EOB_ACT_END_OF_FILE; 1222 yyrestart( yyin ); 1223 } 1224 1225 else 1226 { 1227 ret_val = EOB_ACT_LAST_MATCH; 1228 yy_current_buffer->yy_buffer_status = 1229 YY_BUFFER_EOF_PENDING; 1230 } 1231 } 1232 1233 else 1234 ret_val = EOB_ACT_CONTINUE_SCAN; 1235 1236 yy_n_chars += number_to_move; 1237 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1238 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1239 1240 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 1241 1242 return ret_val; 1243 } 1244 1245 1246 /* yy_get_previous_state - get the state just before the EOB char was reached */ 1247 1248 static yy_state_type yy_get_previous_state() 1249 { 1250 register yy_state_type yy_current_state; 1251 register char *yy_cp; 1252 1253 yy_current_state = yy_start; 1254 1255 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 1256 { 1257 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1258 if ( yy_accept[yy_current_state] ) 1259 { 1260 yy_last_accepting_state = yy_current_state; 1261 yy_last_accepting_cpos = yy_cp; 1262 } 1263 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1264 { 1265 yy_current_state = (int) yy_def[yy_current_state]; 1266 if ( yy_current_state >= 50 ) 1267 yy_c = yy_meta[(unsigned int) yy_c]; 1268 } 1269 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1270 } 1271 1272 return yy_current_state; 1273 } 1274 1275 1276 /* yy_try_NUL_trans - try to make a transition on the NUL character 1277 * 1278 * synopsis 1279 * next_state = yy_try_NUL_trans( current_state ); 1280 */ 1281 1282 #ifdef YY_USE_PROTOS 1283 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1284 #else 1285 static yy_state_type yy_try_NUL_trans( yy_current_state ) 1286 yy_state_type yy_current_state; 1287 #endif 1288 { 1289 register int yy_is_jam; 1290 register char *yy_cp = yy_c_buf_p; 1291 1292 register YY_CHAR yy_c = 1; 1293 if ( yy_accept[yy_current_state] ) 1294 { 1295 yy_last_accepting_state = yy_current_state; 1296 yy_last_accepting_cpos = yy_cp; 1297 } 1298 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1299 { 1300 yy_current_state = (int) yy_def[yy_current_state]; 1301 if ( yy_current_state >= 50 ) 1302 yy_c = yy_meta[(unsigned int) yy_c]; 1303 } 1304 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1305 yy_is_jam = (yy_current_state == 49); 1306 1307 return yy_is_jam ? 0 : yy_current_state; 1308 } 1309 1310 1311 #ifndef YY_NO_UNPUT 1312 #ifdef YY_USE_PROTOS 1313 static void yyunput( int c, register char *yy_bp ) 1314 #else 1315 static void yyunput( c, yy_bp ) 1316 int c; 1317 register char *yy_bp; 1318 #endif 1319 { 1320 register char *yy_cp = yy_c_buf_p; 1321 1322 /* undo effects of setting up yytext */ 1323 *yy_cp = yy_hold_char; 1324 1325 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1326 { /* need to shift things up to make room */ 1327 /* +2 for EOB chars. */ 1328 register int number_to_move = yy_n_chars + 2; 1329 register char *dest = &yy_current_buffer->yy_ch_buf[ 1330 yy_current_buffer->yy_buf_size + 2]; 1331 register char *source = 1332 &yy_current_buffer->yy_ch_buf[number_to_move]; 1333 1334 while ( source > yy_current_buffer->yy_ch_buf ) 1335 *--dest = *--source; 1336 1337 yy_cp += (int) (dest - source); 1338 yy_bp += (int) (dest - source); 1339 yy_current_buffer->yy_n_chars = 1340 yy_n_chars = yy_current_buffer->yy_buf_size; 1341 1342 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1343 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1344 } 1345 1346 *--yy_cp = (char) c; 1347 1348 1349 yytext_ptr = yy_bp; 1350 yy_hold_char = *yy_cp; 1351 yy_c_buf_p = yy_cp; 1352 } 1353 #endif /* ifndef YY_NO_UNPUT */ 1354 1355 1356 #ifdef __cplusplus 1357 static int yyinput() 1358 #else 1359 static int input() 1360 #endif 1361 { 1362 int c; 1363 1364 *yy_c_buf_p = yy_hold_char; 1365 1366 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1367 { 1368 /* yy_c_buf_p now points to the character we want to return. 1369 * If this occurs *before* the EOB characters, then it's a 1370 * valid NUL; if not, then we've hit the end of the buffer. 1371 */ 1372 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1373 /* This was really a NUL. */ 1374 *yy_c_buf_p = '\0'; 1375 1376 else 1377 { /* need more input */ 1378 int offset = yy_c_buf_p - yytext_ptr; 1379 ++yy_c_buf_p; 1380 1381 switch ( yy_get_next_buffer() ) 1382 { 1383 case EOB_ACT_LAST_MATCH: 1384 /* This happens because yy_g_n_b() 1385 * sees that we've accumulated a 1386 * token and flags that we need to 1387 * try matching the token before 1388 * proceeding. But for input(), 1389 * there's no matching to consider. 1390 * So convert the EOB_ACT_LAST_MATCH 1391 * to EOB_ACT_END_OF_FILE. 1392 */ 1393 1394 /* Reset buffer status. */ 1395 yyrestart( yyin ); 1396 1397 /* fall through */ 1398 1399 case EOB_ACT_END_OF_FILE: 1400 { 1401 if ( yywrap() ) 1402 return EOF; 1403 1404 if ( ! yy_did_buffer_switch_on_eof ) 1405 YY_NEW_FILE; 1406 #ifdef __cplusplus 1407 return yyinput(); 1408 #else 1409 return input(); 1410 #endif 1411 } 1412 1413 case EOB_ACT_CONTINUE_SCAN: 1414 yy_c_buf_p = yytext_ptr + offset; 1415 break; 1416 } 1417 } 1418 } 1419 1420 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 1421 *yy_c_buf_p = '\0'; /* preserve yytext */ 1422 yy_hold_char = *++yy_c_buf_p; 1423 1424 1425 return c; 1426 } 1427 1428 1429 #ifdef YY_USE_PROTOS 1430 void yyrestart( FILE *input_file ) 1431 #else 1432 void yyrestart( input_file ) 1433 FILE *input_file; 1434 #endif 1435 { 1436 if ( ! yy_current_buffer ) 1437 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1438 1439 yy_init_buffer( yy_current_buffer, input_file ); 1440 yy_load_buffer_state(); 1441 } 1442 1443 1444 #ifdef YY_USE_PROTOS 1445 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1446 #else 1447 void yy_switch_to_buffer( new_buffer ) 1448 YY_BUFFER_STATE new_buffer; 1449 #endif 1450 { 1451 if ( yy_current_buffer == new_buffer ) 1452 return; 1453 1454 if ( yy_current_buffer ) 1455 { 1456 /* Flush out information for old buffer. */ 1457 *yy_c_buf_p = yy_hold_char; 1458 yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1459 yy_current_buffer->yy_n_chars = yy_n_chars; 1460 } 1461 1462 yy_current_buffer = new_buffer; 1463 yy_load_buffer_state(); 1464 1465 /* We don't actually know whether we did this switch during 1466 * EOF (yywrap()) processing, but the only time this flag 1467 * is looked at is after yywrap() is called, so it's safe 1468 * to go ahead and always set it. 1469 */ 1470 yy_did_buffer_switch_on_eof = 1; 1471 } 1472 1473 1474 #ifdef YY_USE_PROTOS 1475 void yy_load_buffer_state( void ) 1476 #else 1477 void yy_load_buffer_state() 1478 #endif 1479 { 1480 yy_n_chars = yy_current_buffer->yy_n_chars; 1481 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 1482 yyin = yy_current_buffer->yy_input_file; 1483 yy_hold_char = *yy_c_buf_p; 1484 } 1485 1486 1487 #ifdef YY_USE_PROTOS 1488 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1489 #else 1490 YY_BUFFER_STATE yy_create_buffer( file, size ) 1491 FILE *file; 1492 int size; 1493 #endif 1494 { 1495 YY_BUFFER_STATE b; 1496 1497 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1498 if ( ! b ) 1499 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1500 1501 b->yy_buf_size = size; 1502 1503 /* yy_ch_buf has to be 2 characters longer than the size given because 1504 * we need to put in 2 end-of-buffer characters. 1505 */ 1506 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 1507 if ( ! b->yy_ch_buf ) 1508 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1509 1510 b->yy_is_our_buffer = 1; 1511 1512 yy_init_buffer( b, file ); 1513 1514 return b; 1515 } 1516 1517 1518 #ifdef YY_USE_PROTOS 1519 void yy_delete_buffer( YY_BUFFER_STATE b ) 1520 #else 1521 void yy_delete_buffer( b ) 1522 YY_BUFFER_STATE b; 1523 #endif 1524 { 1525 if ( ! b ) 1526 return; 1527 1528 if ( b == yy_current_buffer ) 1529 yy_current_buffer = (YY_BUFFER_STATE) 0; 1530 1531 if ( b->yy_is_our_buffer ) 1532 yy_flex_free( (void *) b->yy_ch_buf ); 1533 1534 yy_flex_free( (void *) b ); 1535 } 1536 1537 1538 #ifndef YY_ALWAYS_INTERACTIVE 1539 #ifndef YY_NEVER_INTERACTIVE 1540 extern int isatty YY_PROTO(( int )); 1541 #endif 1542 #endif 1543 1544 #ifdef YY_USE_PROTOS 1545 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 1546 #else 1547 void yy_init_buffer( b, file ) 1548 YY_BUFFER_STATE b; 1549 FILE *file; 1550 #endif 1551 1552 1553 { 1554 yy_flush_buffer( b ); 1555 1556 b->yy_input_file = file; 1557 b->yy_fill_buffer = 1; 1558 1559 #if YY_ALWAYS_INTERACTIVE 1560 b->yy_is_interactive = 1; 1561 #else 1562 #if YY_NEVER_INTERACTIVE 1563 b->yy_is_interactive = 0; 1564 #else 1565 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1566 #endif 1567 #endif 1568 } 1569 1570 1571 #ifdef YY_USE_PROTOS 1572 void yy_flush_buffer( YY_BUFFER_STATE b ) 1573 #else 1574 void yy_flush_buffer( b ) 1575 YY_BUFFER_STATE b; 1576 #endif 1577 1578 { 1579 if ( ! b ) 1580 return; 1581 1582 b->yy_n_chars = 0; 1583 1584 /* We always need two end-of-buffer characters. The first causes 1585 * a transition to the end-of-buffer state. The second causes 1586 * a jam in that state. 1587 */ 1588 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1589 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1590 1591 b->yy_buf_pos = &b->yy_ch_buf[0]; 1592 1593 b->yy_at_bol = 1; 1594 b->yy_buffer_status = YY_BUFFER_NEW; 1595 1596 if ( b == yy_current_buffer ) 1597 yy_load_buffer_state(); 1598 } 1599 1600 1601 #ifndef YY_NO_SCAN_BUFFER 1602 #ifdef YY_USE_PROTOS 1603 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 1604 #else 1605 YY_BUFFER_STATE yy_scan_buffer( base, size ) 1606 char *base; 1607 yy_size_t size; 1608 #endif 1609 { 1610 YY_BUFFER_STATE b; 1611 1612 if ( size < 2 || 1613 base[size-2] != YY_END_OF_BUFFER_CHAR || 1614 base[size-1] != YY_END_OF_BUFFER_CHAR ) 1615 /* They forgot to leave room for the EOB's. */ 1616 return 0; 1617 1618 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1619 if ( ! b ) 1620 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1621 1622 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1623 b->yy_buf_pos = b->yy_ch_buf = base; 1624 b->yy_is_our_buffer = 0; 1625 b->yy_input_file = 0; 1626 b->yy_n_chars = b->yy_buf_size; 1627 b->yy_is_interactive = 0; 1628 b->yy_at_bol = 1; 1629 b->yy_fill_buffer = 0; 1630 b->yy_buffer_status = YY_BUFFER_NEW; 1631 1632 yy_switch_to_buffer( b ); 1633 1634 return b; 1635 } 1636 #endif 1637 1638 1639 #ifndef YY_NO_SCAN_STRING 1640 #ifdef YY_USE_PROTOS 1641 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 1642 #else 1643 YY_BUFFER_STATE yy_scan_string( yy_str ) 1644 yyconst char *yy_str; 1645 #endif 1646 { 1647 int len; 1648 for ( len = 0; yy_str[len]; ++len ) 1649 ; 1650 1651 return yy_scan_bytes( yy_str, len ); 1652 } 1653 #endif 1654 1655 1656 #ifndef YY_NO_SCAN_BYTES 1657 #ifdef YY_USE_PROTOS 1658 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 1659 #else 1660 YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1661 yyconst char *bytes; 1662 int len; 1663 #endif 1664 { 1665 YY_BUFFER_STATE b; 1666 char *buf; 1667 yy_size_t n; 1668 int i; 1669 1670 /* Get memory for full buffer, including space for trailing EOB's. */ 1671 n = len + 2; 1672 buf = (char *) yy_flex_alloc( n ); 1673 if ( ! buf ) 1674 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1675 1676 for ( i = 0; i < len; ++i ) 1677 buf[i] = bytes[i]; 1678 1679 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 1680 1681 b = yy_scan_buffer( buf, n ); 1682 if ( ! b ) 1683 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1684 1685 /* It's okay to grow etc. this buffer, and we should throw it 1686 * away when we're done. 1687 */ 1688 b->yy_is_our_buffer = 1; 1689 1690 return b; 1691 } 1692 #endif 1693 1694 1695 #ifndef YY_NO_PUSH_STATE 1696 #ifdef YY_USE_PROTOS 1697 static void yy_push_state( int new_state ) 1698 #else 1699 static void yy_push_state( new_state ) 1700 int new_state; 1701 #endif 1702 { 1703 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 1704 { 1705 yy_size_t new_size; 1706 1707 yy_start_stack_depth += YY_START_STACK_INCR; 1708 new_size = yy_start_stack_depth * sizeof( int ); 1709 1710 if ( ! yy_start_stack ) 1711 yy_start_stack = (int *) yy_flex_alloc( new_size ); 1712 1713 else 1714 yy_start_stack = (int *) yy_flex_realloc( 1715 (void *) yy_start_stack, new_size ); 1716 1717 if ( ! yy_start_stack ) 1718 YY_FATAL_ERROR( 1719 "out of memory expanding start-condition stack" ); 1720 } 1721 1722 yy_start_stack[yy_start_stack_ptr++] = YY_START; 1723 1724 BEGIN(new_state); 1725 } 1726 #endif 1727 1728 1729 #ifndef YY_NO_POP_STATE 1730 static void yy_pop_state() 1731 { 1732 if ( --yy_start_stack_ptr < 0 ) 1733 YY_FATAL_ERROR( "start-condition stack underflow" ); 1734 1735 BEGIN(yy_start_stack[yy_start_stack_ptr]); 1736 } 1737 #endif 1738 1739 1740 #ifndef YY_NO_TOP_STATE 1741 static int yy_top_state() 1742 { 1743 return yy_start_stack[yy_start_stack_ptr - 1]; 1744 } 1745 #endif 1746 1747 #ifndef YY_EXIT_FAILURE 1748 #define YY_EXIT_FAILURE 2 1749 #endif 1750 1751 #ifdef YY_USE_PROTOS 1752 static void yy_fatal_error( yyconst char msg[] ) 1753 #else 1754 static void yy_fatal_error( msg ) 1755 char msg[]; 1756 #endif 1757 { 1758 (void) fprintf( stderr, "%s\n", msg ); 1759 exit( YY_EXIT_FAILURE ); 1760 } 1761 1762 1763 1764 /* Redefine yyless() so it works in section 3 code. */ 1765 1766 #undef yyless 1767 #define yyless(n) \ 1768 do \ 1769 { \ 1770 /* Undo effects of setting up yytext. */ \ 1771 yytext[yyleng] = yy_hold_char; \ 1772 yy_c_buf_p = yytext + n; \ 1773 yy_hold_char = *yy_c_buf_p; \ 1774 *yy_c_buf_p = '\0'; \ 1775 yyleng = n; \ 1776 } \ 1777 while ( 0 ) 1778 1779 1780 /* Internal utility routines. */ 1781 1782 #ifndef yytext_ptr 1783 #ifdef YY_USE_PROTOS 1784 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 1785 #else 1786 static void yy_flex_strncpy( s1, s2, n ) 1787 char *s1; 1788 yyconst char *s2; 1789 int n; 1790 #endif 1791 { 1792 register int i; 1793 for ( i = 0; i < n; ++i ) 1794 s1[i] = s2[i]; 1795 } 1796 #endif 1797 1798 #ifdef YY_NEED_STRLEN 1799 #ifdef YY_USE_PROTOS 1800 static int yy_flex_strlen( yyconst char *s ) 1801 #else 1802 static int yy_flex_strlen( s ) 1803 yyconst char *s; 1804 #endif 1805 { 1806 register int n; 1807 for ( n = 0; s[n]; ++n ) 1808 ; 1809 1810 return n; 1811 } 1812 #endif 1813 1814 1815 #ifdef YY_USE_PROTOS 1816 static void *yy_flex_alloc( yy_size_t size ) 1817 #else 1818 static void *yy_flex_alloc( size ) 1819 yy_size_t size; 1820 #endif 1821 { 1822 return (void *) malloc( size ); 1823 } 1824 1825 #ifdef YY_USE_PROTOS 1826 static void *yy_flex_realloc( void *ptr, yy_size_t size ) 1827 #else 1828 static void *yy_flex_realloc( ptr, size ) 1829 void *ptr; 1830 yy_size_t size; 1831 #endif 1832 { 1833 /* The cast to (char *) in the following accommodates both 1834 * implementations that use char* generic pointers, and those 1835 * that use void* generic pointers. It works with the latter 1836 * because both ANSI C and C++ allow castless assignment from 1837 * any pointer type to void*, and deal with argument conversions 1838 * as though doing an assignment. 1839 */ 1840 return (void *) realloc( (char *) ptr, size ); 1841 } 1842 1843 #ifdef YY_USE_PROTOS 1844 static void yy_flex_free( void *ptr ) 1845 #else 1846 static void yy_flex_free( ptr ) 1847 void *ptr; 1848 #endif 1849 { 1850 free( ptr ); 1851 } 1852 1853 #if YY_MAIN 1854 int main() 1855 { 1856 yylex(); 1857 return 0; 1858 } 1859 #endif 1860 #line 222 "C:\\Users\\sdumbre\\testclone\\source\\compiler\\prparser.l" 1861 1862 1863 /* 1864 * Local support functions 1865 */ 1866 static YY_BUFFER_STATE LexBuffer; 1867 1868 1869 /****************************************************************************** 1870 * 1871 * FUNCTION: PrInitLexer 1872 * 1873 * PARAMETERS: String - Input string to be parsed 1874 * 1875 * RETURN: TRUE if parser returns NULL. FALSE otherwise. 1876 * 1877 * DESCRIPTION: Initialization routine for lexer. The lexer needs 1878 * a buffer to handle strings instead of a file. 1879 * 1880 *****************************************************************************/ 1881 1882 int 1883 PrInitLexer ( 1884 char *String) 1885 { 1886 1887 LexBuffer = yy_scan_string (String); 1888 return (LexBuffer == NULL); 1889 } 1890 1891 1892 /****************************************************************************** 1893 * 1894 * FUNCTION: PrTerminateLexer 1895 * 1896 * PARAMETERS: None 1897 * 1898 * RETURN: None 1899 * 1900 * DESCRIPTION: Termination routine for thelexer. 1901 * 1902 *****************************************************************************/ 1903 1904 void 1905 PrTerminateLexer ( 1906 void) 1907 { 1908 1909 yy_delete_buffer (LexBuffer); 1910 } 1911 1912 1913 /******************************************************************************** 1914 * 1915 * FUNCTION: PrDoCommentType1 1916 * 1917 * PARAMETERS: none 1918 * 1919 * RETURN: none 1920 * 1921 * DESCRIPTION: Process a new legacy comment. Just toss it. 1922 * 1923 ******************************************************************************/ 1924 1925 static char 1926 PrDoCommentType1 ( 1927 void) 1928 { 1929 int c; 1930 1931 1932 Loop: 1933 while (((c = input ()) != '*') && (c != EOF)) 1934 { 1935 } 1936 if (c == EOF) 1937 { 1938 return (FALSE); 1939 } 1940 1941 if (((c = input ()) != '/') && (c != EOF)) 1942 { 1943 unput (c); 1944 goto Loop; 1945 } 1946 if (c == EOF) 1947 { 1948 return (FALSE); 1949 } 1950 1951 return (TRUE); 1952 } 1953 1954 1955 /******************************************************************************** 1956 * 1957 * FUNCTION: PrDoCommentType2 1958 * 1959 * PARAMETERS: none 1960 * 1961 * RETURN: none 1962 * 1963 * DESCRIPTION: Process a new "//" comment. Just toss it. 1964 * 1965 ******************************************************************************/ 1966 1967 static char 1968 PrDoCommentType2 ( 1969 void) 1970 { 1971 int c; 1972 1973 1974 while (((c = input ()) != '\n') && (c != EOF)) 1975 { 1976 } 1977 if (c == EOF) 1978 { 1979 return (FALSE); 1980 } 1981 1982 return (TRUE); 1983 } 1984
Indexes created Sat Sep 20 22:09:52 GMT 2025