buf_init: 89| 1.55k|{ 90| | buf->elts = NULL; 91| 1.55k| buf->nelts = 0; 92| 1.55k| buf->elt_size = elem_size; 93| 1.55k| buf->nmax = 0; 94| 1.55k|} cclinit: 196| 231|{ 197| 231| if (++lastccl >= current_maxccls) { ------------------ | Branch (197:6): [True: 0, False: 231] ------------------ 198| 0| current_maxccls += MAX_CCLS_INCREMENT; ------------------ | | 200| 0|#define MAX_CCLS_INCREMENT 100 ------------------ 199| | 200| 0| ++num_reallocs; 201| | 202| 0| cclmap = 203| 0| reallocate_integer_array (cclmap, current_maxccls); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 204| 0| ccllen = 205| 0| reallocate_integer_array (ccllen, current_maxccls); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 206| 0| cclng = reallocate_integer_array (cclng, current_maxccls); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 207| 0| ccl_has_nl = reallocate_array(ccl_has_nl, current_maxccls, sizeof(char)); 208| 0| } 209| | 210| 231| if (lastccl == 1) ------------------ | Branch (210:6): [True: 231, False: 0] ------------------ 211| | /* we're making the first ccl */ 212| 231| cclmap[lastccl] = 0; 213| | 214| 0| else 215| | /* The new pointer is just past the end of the last ccl. 216| | * Since the cclmap points to the \first/ character of a 217| | * ccl, adding the length of the ccl to the cclmap pointer 218| | * will produce a cursor to the first free space. 219| | */ 220| 0| cclmap[lastccl] = 221| 0| cclmap[lastccl - 1] + ccllen[lastccl - 1]; 222| | 223| 231| ccllen[lastccl] = 0; 224| 231| cclng[lastccl] = 0; /* ccl's start out life un-negated */ 225| 231| ccl_has_nl[lastccl] = false; 226| | 227| 231| return lastccl; 228| 231|} cclnegate: 234| 231|{ 235| 231| cclng[cclp] = 1; 236| 231| ccl_has_nl[cclp] = !ccl_has_nl[cclp]; 237| 231|} flex_main: 137| 778|{ 138| 778| int i, exit_status, child_status; 139| 778| int did_eof_rule = false; ------------------ | | 82| 778|# define false 0 ------------------ 140| | 141| | /* Set a longjmp target. Yes, I know it's a hack, but it gets worse: The 142| | * return value of setjmp, if non-zero, is the desired exit code PLUS ONE. 143| | * For example, if you want 'main' to return with code '2', then call 144| | * longjmp() with an argument of 3. This is because it is invalid to 145| | * specify a value of 0 to longjmp. FLEX_EXIT(n) should be used instead of 146| | * exit(n); 147| | */ 148| 778| exit_status = setjmp (flex_main_jmp_buf); 149| 778| if (exit_status){ ------------------ | Branch (149:6): [True: 778, False: 0] ------------------ 150| 778| if (stdout && !_stdout_closed && !ferror(stdout)){ ------------------ | Branch (150:7): [True: 778, False: 0] | Branch (150:17): [True: 0, False: 778] | Branch (150:36): [True: 0, False: 0] ------------------ 151| 0| fflush(stdout); 152| 0| fclose(stdout); 153| 0| } 154| 778| return 0; 155| | /* 156| | while (wait(&child_status) > 0){ 157| | if (!WIFEXITED (child_status) 158| | || WEXITSTATUS (child_status) != 0){ 159| | if( exit_status <= 1 ) 160| | exit_status = 2; 161| | 162| | } 163| | } 164| | return exit_status - 1; 165| | */ 166| 778| } 167| | 168| 0| flexinit (argc, argv); 169| | 170| 0| readin (); 171| 0| skelout (true); /* %% [1.0] DFA */ ------------------ | | 83| 0|# define true 1 ------------------ 172| 0| footprint += ntod (); 173| | 174| 0| for (i = 1; i <= num_rules; ++i) ------------------ | Branch (174:14): [True: 0, False: 0] ------------------ 175| 0| if (!rule_useful[i] && i != default_rule) ------------------ | Branch (175:7): [True: 0, False: 0] | Branch (175:26): [True: 0, False: 0] ------------------ 176| 0| line_warning (_("rule cannot be matched"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 177| 0| rule_linenum[i]); 178| | 179| 0| if (ctrl.spprdflt && !reject && rule_useful[default_rule]) ------------------ | Branch (179:6): [True: 0, False: 0] | Branch (179:23): [True: 0, False: 0] | Branch (179:34): [True: 0, False: 0] ------------------ 180| 0| line_warning (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 181| 0| ("-s option given but default rule can be matched"), 182| 0| rule_linenum[default_rule]); 183| | 184| 0| comment("START of m4 controls\n"); 185| | 186| | // mode switches for yy_trans_info specification 187| | // nultrans 188| 0| if (nultrans) ------------------ | Branch (188:6): [True: 0, False: 0] ------------------ 189| 0| visible_define ( "M4_MODE_NULTRANS"); 190| 0| else { 191| 0| visible_define ( "M4_MODE_NO_NULTRANS"); 192| 0| if (ctrl.fulltbl) ------------------ | Branch (192:7): [True: 0, False: 0] ------------------ 193| 0| visible_define ( "M4_MODE_NULTRANS_FULLTBL"); 194| 0| else 195| 0| visible_define ( "M4_MODE_NO_NULTRANS_FULLTBL"); 196| 0| if (ctrl.fullspd) ------------------ | Branch (196:7): [True: 0, False: 0] ------------------ 197| 0| visible_define ( "M4_MODE_NULTRANS_FULLSPD"); 198| 0| else 199| 0| visible_define ( "M4_MODE_NO_NULTRANS_FULLSPD"); 200| 0| } 201| | 202| 0| comment("END of m4 controls\n"); 203| 0| out ("\n"); 204| | 205| 0| comment("START of Flex-generated definitions\n"); 206| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_UINT(%s, %d)", "YY_NUM_RULES", num_rules); 207| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_END_OF_BUFFER", num_rules + 1); 208| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMBASE", jambase); 209| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMSTATE", jamstate); 210| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_BYTE(%s, %d)", "YY_NUL_EC", NUL_ec); 211| | /* Need to define the transet type as a size large 212| | * enough to hold the biggest offset. 213| | */ 214| 0| out_str ("M4_HOOK_SET_OFFSET_TYPE(%s)", optimize_pack(tblend + numecs + 1)->name); 215| 0| comment("END of Flex-generated definitions\n"); 216| | 217| 0| skelout (true); /* %% [2.0] - tables get dumped here */ ------------------ | | 83| 0|# define true 1 ------------------ 218| | 219| | /* Generate the C state transition tables from the DFA. */ 220| 0| make_tables (); 221| | 222| 0| skelout (true); /* %% [3.0] - mode-dependent static declarations get dumped here */ ------------------ | | 83| 0|# define true 1 ------------------ 223| | 224| 0| out (&action_array[defs1_offset]); 225| | 226| 0| line_directive_out (stdout, NULL, linenum); 227| | 228| 0| skelout (true); /* %% [4.0] - various random yylex internals get dumped here */ ------------------ | | 83| 0|# define true 1 ------------------ 229| | 230| | /* Copy prolog to output file. */ 231| 0| out (&action_array[prolog_offset]); 232| | 233| 0| line_directive_out (stdout, NULL, linenum); 234| | 235| 0| skelout (true); /* %% [5.0] - main loop of matching-engine code gets dumped here */ ------------------ | | 83| 0|# define true 1 ------------------ 236| | 237| | /* Copy actions to output file. */ 238| 0| out (&action_array[action_offset]); 239| | 240| 0| line_directive_out (stdout, NULL, linenum); 241| | 242| | /* generate cases for any missing EOF rules */ 243| 0| for (i = 1; i <= lastsc; ++i) ------------------ | Branch (243:14): [True: 0, False: 0] ------------------ 244| 0| if (!sceof[i]) { ------------------ | Branch (244:7): [True: 0, False: 0] ------------------ 245| 0| out_str ("M4_HOOK_EOF_STATE_CASE_ARM(%s)", scname[i]); 246| 0| outc('\n'); 247| 0| out ("M4_HOOK_EOF_STATE_CASE_FALLTHROUGH"); 248| 0| outc('\n'); 249| 0| did_eof_rule = true; ------------------ | | 83| 0|# define true 1 ------------------ 250| 0| } 251| | 252| 0| if (did_eof_rule) { ------------------ | Branch (252:6): [True: 0, False: 0] ------------------ 253| 0| out ("M4_HOOK_EOF_STATE_CASE_TERMINATE"); 254| 0| } 255| | 256| 0| skelout (true); ------------------ | | 83| 0|# define true 1 ------------------ 257| | 258| | /* Copy remainder of input to output. */ 259| | 260| 0| line_directive_out (stdout, infilename, linenum); 261| | 262| 0| if (sectnum == 3) { ------------------ | Branch (262:6): [True: 0, False: 0] ------------------ 263| 0| OUT_BEGIN_CODE (); ------------------ | | 1101| 0|#define OUT_BEGIN_CODE() outn("m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl") ------------------ 264| 0| if (!ctrl.no_section3_escape) ------------------ | Branch (264:21): [True: 0, False: 0] ------------------ 265| 0| fputs("[[", stdout); 266| 0| (void) flexscan (); /* copy remainder of input to output */ 267| 0| if (!ctrl.no_section3_escape) ------------------ | Branch (267:21): [True: 0, False: 0] ------------------ 268| 0| fputs("]]", stdout); 269| 0| OUT_END_CODE (); ------------------ | | 1102| 0|#define OUT_END_CODE() outn("]])") ------------------ 270| 0| } 271| | 272| | /* Note, flexend does not return. It exits with its argument 273| | * as status. 274| | */ 275| 0| flexend (0); 276| | 277| 0| return 0; /* keep compilers/lint happy */ 278| 778|} check_options: 319| 231|{ 320| 231| int i; 321| | 322| 231| if (ctrl.lex_compat) { ------------------ | Branch (322:6): [True: 0, False: 231] ------------------ 323| 0| if (ctrl.C_plus_plus) ------------------ | Branch (323:7): [True: 0, False: 0] ------------------ 324| 0| flexerror (_("Can't use -+ with -l option")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 325| | 326| 0| if (ctrl.fulltbl || ctrl.fullspd) ------------------ | Branch (326:7): [True: 0, False: 0] | Branch (326:23): [True: 0, False: 0] ------------------ 327| 0| flexerror (_("Can't use -f or -F with -l option")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 328| | 329| 0| if (ctrl.reentrant || ctrl.bison_bridge_lval) ------------------ | Branch (329:7): [True: 0, False: 0] | Branch (329:25): [True: 0, False: 0] ------------------ 330| 0| flexerror (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 331| 0| ("Can't use --ctrl.reentrant or --bison-bridge with -l option")); 332| | 333| 0| ctrl.yytext_is_array = true; ------------------ | | 83| 0|# define true 1 ------------------ 334| 0| ctrl.do_yylineno = true; ------------------ | | 83| 0|# define true 1 ------------------ 335| 0| ctrl.use_read = false; ------------------ | | 82| 0|# define false 0 ------------------ 336| 0| } 337| | 338| | 339| |#if 0 340| | /* This makes no sense whatsoever. I'm removing it. */ 341| | if (ctrl.do_yylineno) 342| | /* This should really be "maintain_backup_tables = true" */ 343| | ctrl.reject_really_used = true; 344| |#endif 345| | 346| 231| if (ctrl.csize == trit_unspecified) { ------------------ | Branch (346:6): [True: 231, False: 0] ------------------ 347| 231| if ((ctrl.fulltbl || ctrl.fullspd) && !ctrl.useecs) ------------------ | Branch (347:8): [True: 0, False: 231] | Branch (347:24): [True: 0, False: 231] | Branch (347:41): [True: 0, False: 0] ------------------ 348| 0| ctrl.csize = DEFAULT_CSIZE; ------------------ | | 110| 0|#define DEFAULT_CSIZE 128 ------------------ 349| 231| else 350| 231| ctrl.csize = CSIZE; ------------------ | | 106| 231|#define CSIZE 256 ------------------ 351| 231| } 352| | 353| 231| if (ctrl.interactive == trit_unspecified) { ------------------ | Branch (353:6): [True: 231, False: 0] ------------------ 354| 231| if (ctrl.fulltbl || ctrl.fullspd) ------------------ | Branch (354:7): [True: 0, False: 231] | Branch (354:23): [True: 0, False: 231] ------------------ 355| 0| ctrl.interactive = trit_false; 356| 231| else 357| 231| ctrl.interactive = trit_true; 358| 231| } 359| | 360| 231| if (ctrl.fulltbl || ctrl.fullspd) { ------------------ | Branch (360:6): [True: 0, False: 231] | Branch (360:22): [True: 0, False: 231] ------------------ 361| 0| if (ctrl.usemecs) ------------------ | Branch (361:7): [True: 0, False: 0] ------------------ 362| 0| flexerror (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 363| 0| ("-Cf/-CF and -Cm don't make sense together")); 364| | 365| 0| if (ctrl.interactive != trit_false) ------------------ | Branch (365:7): [True: 0, False: 0] ------------------ 366| 0| flexerror (_("-Cf/-CF and -I are incompatible")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 367| | 368| 0| if (ctrl.lex_compat) ------------------ | Branch (368:7): [True: 0, False: 0] ------------------ 369| 0| flexerror (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 370| 0| ("-Cf/-CF are incompatible with lex-compatibility mode")); 371| | 372| | 373| 0| if (ctrl.fulltbl && ctrl.fullspd) ------------------ | Branch (373:7): [True: 0, False: 0] | Branch (373:23): [True: 0, False: 0] ------------------ 374| 0| flexerror (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 375| 0| ("-Cf and -CF are mutually exclusive")); 376| 0| } 377| | 378| 231| if (ctrl.C_plus_plus && ctrl.fullspd) ------------------ | Branch (378:6): [True: 0, False: 231] | Branch (378:26): [True: 0, False: 0] ------------------ 379| 0| flexerror (_("Can't use -+ with -CF option")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 380| | 381| 231| if (ctrl.C_plus_plus && ctrl.yytext_is_array) { ------------------ | Branch (381:6): [True: 0, False: 231] | Branch (381:26): [True: 0, False: 0] ------------------ 382| 0| lwarn (_("%array incompatible with -+ option")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 383| 0| ctrl.yytext_is_array = false; ------------------ | | 82| 0|# define false 0 ------------------ 384| 0| } 385| | 386| 231| if (ctrl.C_plus_plus && (ctrl.reentrant)) ------------------ | Branch (386:6): [True: 0, False: 231] | Branch (386:26): [True: 0, False: 0] ------------------ 387| 0| flexerror (_("Options -+ and --reentrant are mutually exclusive.")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 388| | 389| 231| if (ctrl.C_plus_plus && ctrl.bison_bridge_lval) ------------------ | Branch (389:6): [True: 0, False: 231] | Branch (389:26): [True: 0, False: 0] ------------------ 390| 0| flexerror (_("bison bridge not supported for the C++ scanner.")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 391| | 392| | 393| 231| if (ctrl.useecs) { /* Set up doubly-linked equivalence classes. */ ------------------ | Branch (393:6): [True: 231, False: 0] ------------------ 394| | 395| | /* We loop all the way up to ctrl.csize, since ecgroup[ctrl.csize] is 396| | * the position used for NUL characters. 397| | */ 398| 231| ecgroup[1] = NIL; ------------------ | | 192| 231|#define NIL 0 ------------------ 399| | 400| 59.1k| for (i = 2; i <= ctrl.csize; ++i) { ------------------ | Branch (400:15): [True: 58.9k, False: 231] ------------------ 401| 58.9k| ecgroup[i] = i - 1; 402| 58.9k| nextecm[i - 1] = i; 403| 58.9k| } 404| | 405| 231| nextecm[ctrl.csize] = NIL; ------------------ | | 192| 231|#define NIL 0 ------------------ 406| 231| } 407| | 408| 0| else { 409| | /* Put everything in its own equivalence class. */ 410| 0| for (i = 1; i <= ctrl.csize; ++i) { ------------------ | Branch (410:15): [True: 0, False: 0] ------------------ 411| 0| ecgroup[i] = i; 412| 0| nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */ ------------------ | | 310| 0|#define BAD_SUBSCRIPT -32767 ------------------ 413| 0| } 414| 0| } 415| | 416| 231| if (!env.use_stdout) { ------------------ | Branch (416:6): [True: 231, False: 0] ------------------ 417| 231| FILE *prev_stdout; 418| | 419| 231| if (!env.did_outfilename) { ------------------ | Branch (419:7): [True: 231, False: 0] ------------------ 420| 231| snprintf (outfile_path, sizeof(outfile_path), outfile_template, 421| 231| ctrl.prefix, suffix()); 422| | 423| 231| env.outfilename = outfile_path; 424| 231| } 425| | 426| 231| prev_stdout = freopen (env.outfilename, "w+", stdout); 427| | 428| 231| if (prev_stdout == NULL) ------------------ | Branch (428:7): [True: 0, False: 231] ------------------ 429| 0| lerr (_("could not create %s"), env.outfilename); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 430| | 431| 231| outfile_created = 1; 432| 231| } 433| 231|} flexend: 442| 778|{ 443| 778| static int called_before = -1; /* prevent infinite recursion. */ 444| 778| int tblsiz; 445| | 446| 778| if (++called_before) ------------------ | Branch (446:6): [True: 777, False: 1] ------------------ 447| 777| FLEX_EXIT (exit_status); ------------------ | | 1107| 777|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 448| | 449| 1| if (ctrl.yyclass != NULL && !ctrl.C_plus_plus) ------------------ | Branch (449:6): [True: 0, False: 1] | Branch (449:30): [True: 0, False: 0] ------------------ 450| 0| flexerror (_("%option yyclass only meaningful for C++ scanners")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 451| | 452| 1| if (skelfile != NULL) { ------------------ | Branch (452:6): [True: 0, False: 1] ------------------ 453| 0| if (ferror (skelfile)) ------------------ | Branch (453:7): [True: 0, False: 0] ------------------ 454| 0| lerr (_("input error reading skeleton file %s"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 455| 0| env.skelname); 456| | 457| 0| else if (fclose (skelfile)) ------------------ | Branch (457:12): [True: 0, False: 0] ------------------ 458| 0| lerr (_("error closing skeleton file %s"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 459| 0| env.skelname); 460| 0| } 461| | 462| 1| if (exit_status != 0 && outfile_created) { ------------------ | Branch (462:6): [True: 1, False: 0] | Branch (462:26): [True: 1, False: 0] ------------------ 463| 1| if (ferror (stdout)) ------------------ | Branch (463:7): [True: 0, False: 1] ------------------ 464| 0| lerr (_("error writing output file %s"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 465| 0| env.outfilename); 466| | 467| 1| else if ((_stdout_closed = 1) && fclose (stdout)) ------------------ | Branch (467:12): [True: 1, False: 0] | Branch (467:36): [True: 0, False: 1] ------------------ 468| 0| lerr (_("error closing output file %s"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 469| 0| env.outfilename); 470| | 471| 1| else if (unlink (env.outfilename)) ------------------ | Branch (471:12): [True: 0, False: 1] ------------------ 472| 0| lerr (_("error deleting output file %s"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 473| 0| env.outfilename); 474| 1| } 475| | 476| | 477| 1| if (env.backing_up_report && ctrl.backing_up_file) { ------------------ | Branch (477:6): [True: 0, False: 1] | Branch (477:31): [True: 0, False: 0] ------------------ 478| 0| if (num_backing_up == 0) ------------------ | Branch (478:7): [True: 0, False: 0] ------------------ 479| 0| fprintf (ctrl.backing_up_file, _("No backing up.\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 480| 0| else if (ctrl.fullspd || ctrl.fulltbl) ------------------ | Branch (480:12): [True: 0, False: 0] | Branch (480:28): [True: 0, False: 0] ------------------ 481| 0| fprintf (ctrl.backing_up_file, 482| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 483| 0| ("%d backing up (non-accepting) states.\n"), 484| 0| num_backing_up); 485| 0| else 486| 0| fprintf (ctrl.backing_up_file, 487| 0| _("Compressed tables always back up.\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 488| | 489| 0| if (ferror (ctrl.backing_up_file)) ------------------ | Branch (489:7): [True: 0, False: 0] ------------------ 490| 0| lerr (_("error writing backup file %s"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 491| 0| backing_name); 492| | 493| 0| else if (fclose (ctrl.backing_up_file)) ------------------ | Branch (493:12): [True: 0, False: 0] ------------------ 494| 0| lerr (_("error closing backup file %s"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 495| 0| backing_name); 496| 0| } 497| | 498| 1| if (env.printstats) { ------------------ | Branch (498:6): [True: 0, False: 1] ------------------ 499| 0| fprintf (stderr, _("%s version %s usage statistics:\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 500| 0| program_name, flex_version); 501| | 502| 0| fprintf (stderr, _(" scanner options: -")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 503| | 504| 0| if (ctrl.C_plus_plus) ------------------ | Branch (504:7): [True: 0, False: 0] ------------------ 505| 0| putc ('+', stderr); 506| 0| if (env.backing_up_report) ------------------ | Branch (506:7): [True: 0, False: 0] ------------------ 507| 0| putc ('b', stderr); 508| 0| if (ctrl.ddebug) ------------------ | Branch (508:7): [True: 0, False: 0] ------------------ 509| 0| putc ('d', stderr); 510| 0| if (sf_case_ins()) ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ 511| 0| putc ('i', stderr); 512| 0| if (ctrl.lex_compat) ------------------ | Branch (512:7): [True: 0, False: 0] ------------------ 513| 0| putc ('l', stderr); 514| 0| if (ctrl.posix_compat) ------------------ | Branch (514:7): [True: 0, False: 0] ------------------ 515| 0| putc ('X', stderr); 516| 0| if (env.performance_hint > 0) ------------------ | Branch (516:7): [True: 0, False: 0] ------------------ 517| 0| putc ('p', stderr); 518| 0| if (env.performance_hint > 1) ------------------ | Branch (518:7): [True: 0, False: 0] ------------------ 519| 0| putc ('p', stderr); 520| 0| if (ctrl.spprdflt) ------------------ | Branch (520:7): [True: 0, False: 0] ------------------ 521| 0| putc ('s', stderr); 522| 0| if (ctrl.reentrant) ------------------ | Branch (522:7): [True: 0, False: 0] ------------------ 523| 0| fputs ("--reentrant", stderr); 524| 0| if (ctrl.bison_bridge_lval) ------------------ | Branch (524:13): [True: 0, False: 0] ------------------ 525| 0| fputs ("--bison-bridge", stderr); 526| 0| if (ctrl.bison_bridge_lloc) ------------------ | Branch (526:13): [True: 0, False: 0] ------------------ 527| 0| fputs ("--bison-locations", stderr); 528| 0| if (env.use_stdout) ------------------ | Branch (528:7): [True: 0, False: 0] ------------------ 529| 0| putc ('t', stderr); 530| 0| if (env.printstats) ------------------ | Branch (530:7): [True: 0, False: 0] ------------------ 531| 0| putc ('v', stderr); /* always true! */ 532| 0| if (env.nowarn) ------------------ | Branch (532:7): [True: 0, False: 0] ------------------ 533| 0| putc ('w', stderr); 534| 0| if (ctrl.interactive == trit_false) ------------------ | Branch (534:7): [True: 0, False: 0] ------------------ 535| 0| putc ('B', stderr); 536| 0| if (ctrl.interactive == trit_true) ------------------ | Branch (536:7): [True: 0, False: 0] ------------------ 537| 0| putc ('I', stderr); 538| 0| if (!ctrl.gen_line_dirs) ------------------ | Branch (538:7): [True: 0, False: 0] ------------------ 539| 0| putc ('L', stderr); 540| 0| if (env.trace) ------------------ | Branch (540:7): [True: 0, False: 0] ------------------ 541| 0| putc ('T', stderr); 542| | 543| 0| if (ctrl.csize == trit_unspecified) ------------------ | Branch (543:7): [True: 0, False: 0] ------------------ 544| | /* We encountered an error fairly early on, so ctrl.csize 545| | * never got specified. Define it now, to prevent 546| | * bogus table sizes being written out below. 547| | */ 548| 0| ctrl.csize = 256; 549| | 550| 0| if (ctrl.csize == 128) ------------------ | Branch (550:7): [True: 0, False: 0] ------------------ 551| 0| putc ('7', stderr); 552| 0| else 553| 0| putc ('8', stderr); 554| | 555| 0| fprintf (stderr, " -C"); 556| | 557| 0| if (ctrl.long_align) ------------------ | Branch (557:7): [True: 0, False: 0] ------------------ 558| 0| putc ('a', stderr); 559| 0| if (ctrl.fulltbl) ------------------ | Branch (559:7): [True: 0, False: 0] ------------------ 560| 0| putc ('f', stderr); 561| 0| if (ctrl.fullspd) ------------------ | Branch (561:7): [True: 0, False: 0] ------------------ 562| 0| putc ('F', stderr); 563| 0| if (ctrl.useecs) ------------------ | Branch (563:7): [True: 0, False: 0] ------------------ 564| 0| putc ('e', stderr); 565| 0| if (ctrl.usemecs) ------------------ | Branch (565:7): [True: 0, False: 0] ------------------ 566| 0| putc ('m', stderr); 567| 0| if (ctrl.use_read) ------------------ | Branch (567:7): [True: 0, False: 0] ------------------ 568| 0| putc ('r', stderr); 569| | 570| 0| if (env.did_outfilename) ------------------ | Branch (570:7): [True: 0, False: 0] ------------------ 571| 0| fprintf (stderr, " -o%s", env.outfilename); 572| | 573| 0| if (env.skelname != NULL) ------------------ | Branch (573:7): [True: 0, False: 0] ------------------ 574| 0| fprintf (stderr, " -S%s", env.skelname); 575| | 576| 0| if (strcmp (ctrl.prefix, "yy")) ------------------ | Branch (576:7): [True: 0, False: 0] ------------------ 577| 0| fprintf (stderr, " -P%s", ctrl.prefix); 578| | 579| 0| putc ('\n', stderr); 580| | 581| 0| fprintf (stderr, _(" %d/%d NFA states\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 582| 0| lastnfa, current_mns); 583| 0| fprintf (stderr, _(" %d/%d DFA states (%d words)\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 584| 0| lastdfa, current_max_dfas, totnst); 585| 0| fprintf (stderr, _(" %d rules\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 586| 0| num_rules + num_eof_rules - 587| 0| 1 /* - 1 for def. rule */ ); 588| | 589| 0| if (num_backing_up == 0) ------------------ | Branch (589:7): [True: 0, False: 0] ------------------ 590| 0| fprintf (stderr, _(" No backing up\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 591| 0| else if (ctrl.fullspd || ctrl.fulltbl) ------------------ | Branch (591:12): [True: 0, False: 0] | Branch (591:28): [True: 0, False: 0] ------------------ 592| 0| fprintf (stderr, 593| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 594| 0| (" %d backing-up (non-accepting) states\n"), 595| 0| num_backing_up); 596| 0| else 597| 0| fprintf (stderr, 598| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 599| 0| (" Compressed tables always back-up\n")); 600| | 601| 0| if (bol_needed) ------------------ | Branch (601:7): [True: 0, False: 0] ------------------ 602| 0| fprintf (stderr, 603| 0| _(" Beginning-of-line patterns used\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 604| | 605| 0| fprintf (stderr, _(" %d/%d start conditions\n"), lastsc, ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 606| 0| current_max_scs); 607| 0| fprintf (stderr, 608| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 609| 0| (" %d epsilon states, %d double epsilon states\n"), 610| 0| numeps, eps2); 611| | 612| 0| if (lastccl == 0) ------------------ | Branch (612:7): [True: 0, False: 0] ------------------ 613| 0| fprintf (stderr, _(" no character classes\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 614| 0| else 615| 0| fprintf (stderr, 616| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 617| 0| (" %d/%d character classes needed %d/%d words of storage, %d reused\n"), 618| 0| lastccl, current_maxccls, 619| 0| cclmap[lastccl] + ccllen[lastccl], 620| 0| current_max_ccl_tbl_size, cclreuse); 621| | 622| 0| fprintf (stderr, _(" %d state/nextstate pairs created\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 623| 0| numsnpairs); 624| 0| fprintf (stderr, 625| 0| _(" %d/%d unique/duplicate transitions\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 626| 0| numuniq, numdup); 627| | 628| 0| if (ctrl.fulltbl) { ------------------ | Branch (628:7): [True: 0, False: 0] ------------------ 629| 0| tblsiz = lastdfa * numecs; 630| 0| fprintf (stderr, _(" %d table entries\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 631| 0| tblsiz); 632| 0| } 633| | 634| 0| else { 635| 0| tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend; 636| | 637| 0| fprintf (stderr, 638| 0| _(" %d/%d base-def entries created\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 639| 0| lastdfa + numtemps, current_max_dfas); 640| 0| fprintf (stderr, 641| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 642| 0| (" %d/%d (peak %d) nxt-chk entries created\n"), 643| 0| tblend, current_max_xpairs, peakpairs); 644| 0| fprintf (stderr, 645| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 646| 0| (" %d/%d (peak %d) template nxt-chk entries created\n"), 647| 0| numtemps * nummecs, 648| 0| current_max_template_xpairs, 649| 0| numtemps * numecs); 650| 0| fprintf (stderr, _(" %d empty table entries\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 651| 0| nummt); 652| 0| fprintf (stderr, _(" %d protos created\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 653| 0| numprots); 654| 0| fprintf (stderr, 655| 0| _(" %d templates created, %d uses\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 656| 0| numtemps, tmpuses); 657| 0| } 658| | 659| 0| if (ctrl.useecs) { ------------------ | Branch (659:7): [True: 0, False: 0] ------------------ 660| 0| tblsiz = tblsiz + ctrl.csize; 661| 0| fprintf (stderr, 662| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 663| 0| (" %d/%d equivalence classes created\n"), 664| 0| numecs, ctrl.csize); 665| 0| } 666| | 667| 0| if (ctrl.usemecs) { ------------------ | Branch (667:7): [True: 0, False: 0] ------------------ 668| 0| tblsiz = tblsiz + numecs; 669| 0| fprintf (stderr, 670| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 671| 0| (" %d/%d meta-equivalence classes created\n"), 672| 0| nummecs, ctrl.csize); 673| 0| } 674| | 675| 0| fprintf (stderr, 676| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 677| 0| (" %d (%d saved) hash collisions, %d DFAs equal\n"), 678| 0| hshcol, hshsave, dfaeql); 679| 0| fprintf (stderr, _(" %d sets of reallocations needed\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 680| 0| num_reallocs); 681| 0| fprintf (stderr, _(" %d total table entries needed\n"), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 682| 0| tblsiz); 683| 0| } 684| | 685| 1| FLEX_EXIT (exit_status); ------------------ | | 1107| 1|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 686| 778|} flexinit: 692| 778|{ 693| 778| int i, sawcmpflag, rv, optind; 694| 778| char *arg; 695| 778| scanopt_t sopt; 696| | 697| 778| memset(&ctrl, '\0', sizeof(ctrl)); 698| 778| syntaxerror = false; ------------------ | | 82| 778|# define false 0 ------------------ 699| 778| yymore_used = continued_action = false; ------------------ | | 82| 778|# define false 0 ------------------ 700| 778| in_rule = reject = false; ------------------ | | 82| 778|# define false 0 ------------------ 701| 778| ctrl.yymore_really_used = ctrl.reject_really_used = trit_unspecified; 702| | 703| 778| ctrl.do_main = trit_unspecified; 704| 778| ctrl.interactive = ctrl.csize = trit_unspecified; 705| 778| ctrl.do_yywrap = ctrl.gen_line_dirs = ctrl.usemecs = ctrl.useecs = true; ------------------ | | 83| 778|# define true 1 ------------------ 706| 778| ctrl.reentrant = ctrl.bison_bridge_lval = ctrl.bison_bridge_lloc = false; ------------------ | | 82| 778|# define false 0 ------------------ 707| 778| env.performance_hint = 0; 708| 778| ctrl.prefix = "yy"; 709| 778| ctrl.rewrite = false; ------------------ | | 82| 778|# define false 0 ------------------ 710| 778| ctrl.yylmax = BUFSIZ; 711| | 712| 778| tablesext = tablesverify = false; ------------------ | | 82| 778|# define false 0 ------------------ 713| 778| gentables = true; ------------------ | | 83| 778|# define true 1 ------------------ 714| 778| tablesfilename = tablesname = NULL; 715| | 716| 778| sawcmpflag = false; ------------------ | | 82| 778|# define false 0 ------------------ 717| | 718| | /* Initialize dynamic array for holding the rule actions. */ 719| 778| action_size = 2048; /* default size of action array in bytes */ 720| 778| action_array = allocate_character_array (action_size); ------------------ | | 743| 778| allocate_array( size, sizeof(char)) ------------------ 721| 778| defs1_offset = prolog_offset = action_offset = action_index = 0; 722| 778| action_array[0] = '\0'; 723| | 724| | /* Initialize any buffers. */ 725| 778| buf_init (&userdef_buf, sizeof (char)); /* one long string */ 726| 778| buf_init (&top_buf, sizeof (char)); /* one long string */ 727| | 728| 778| sf_init (); 729| | 730| | /* Enable C++ if program name ends with '+'. */ 731| 778| program_name = argv[0]; 732| | 733| 778| if (program_name != NULL && ------------------ | Branch (733:6): [True: 778, False: 0] ------------------ 734| 778| program_name[strlen (program_name) - 1] == '+') ------------------ | Branch (734:6): [True: 0, False: 778] ------------------ 735| 0| ctrl.C_plus_plus = true; ------------------ | | 83| 0|# define true 1 ------------------ 736| | 737| | /* read flags */ 738| 778| sopt = scanopt_init (flexopts, argc, argv, 0); 739| 778| if (!sopt) { ------------------ | Branch (739:6): [True: 0, False: 778] ------------------ 740| | /* This will only happen when flexopts array is altered. */ 741| 0| fprintf (stderr, 742| 0| _("Internal error. flexopts are malformed.\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 743| 0| FLEX_EXIT (1); ------------------ | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 744| 0| } 745| | 746| 778| while ((rv = scanopt (sopt, &arg, &optind)) != 0) { ------------------ | Branch (746:9): [True: 0, False: 778] ------------------ 747| | 748| 0| if (rv < 0) { ------------------ | Branch (748:7): [True: 0, False: 0] ------------------ 749| | /* Scanopt has already printed an option-specific error message. */ 750| 0| fprintf (stderr, 751| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 752| 0| ("Try `%s --help' for more information.\n"), 753| 0| program_name); 754| 0| FLEX_EXIT (1); ------------------ | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 755| 0| } 756| | 757| 0| switch ((enum flexopt_flag_t) rv) { ------------------ | Branch (757:11): [True: 0, False: 0] ------------------ 758| 0| case OPT_CPLUSPLUS: ------------------ | Branch (758:7): [True: 0, False: 0] ------------------ 759| 0| ctrl.C_plus_plus = true; ------------------ | | 83| 0|# define true 1 ------------------ 760| 0| break; 761| | 762| 0| case OPT_BATCH: ------------------ | Branch (762:7): [True: 0, False: 0] ------------------ 763| 0| ctrl.interactive = trit_false; 764| 0| break; 765| | 766| 0| case OPT_BACKUP: ------------------ | Branch (766:7): [True: 0, False: 0] ------------------ 767| 0| env.backing_up_report = trit_true; 768| 0| break; 769| | 770| 0| case OPT_BACKUP_FILE: ------------------ | Branch (770:7): [True: 0, False: 0] ------------------ 771| 0| env.backing_up_report = true; ------------------ | | 83| 0|# define true 1 ------------------ 772| 0| backing_name = arg; 773| 0| break; 774| | 775| 0| case OPT_DONOTHING: ------------------ | Branch (775:7): [True: 0, False: 0] ------------------ 776| 0| break; 777| | 778| 0| case OPT_COMPRESSION: ------------------ | Branch (778:7): [True: 0, False: 0] ------------------ 779| 0| if (!sawcmpflag) { ------------------ | Branch (779:8): [True: 0, False: 0] ------------------ 780| 0| ctrl.useecs = false; ------------------ | | 82| 0|# define false 0 ------------------ 781| 0| ctrl.usemecs = false; ------------------ | | 82| 0|# define false 0 ------------------ 782| 0| ctrl.fulltbl = false; ------------------ | | 82| 0|# define false 0 ------------------ 783| 0| sawcmpflag = true; ------------------ | | 83| 0|# define true 1 ------------------ 784| 0| } 785| | 786| 0| for (i = 0; arg && arg[i] != '\0'; i++) ------------------ | Branch (786:16): [True: 0, False: 0] | Branch (786:23): [True: 0, False: 0] ------------------ 787| 0| switch (arg[i]) { 788| 0| case 'a': ------------------ | Branch (788:9): [True: 0, False: 0] ------------------ 789| 0| ctrl.long_align = true; ------------------ | | 83| 0|# define true 1 ------------------ 790| 0| break; 791| | 792| 0| case 'e': ------------------ | Branch (792:9): [True: 0, False: 0] ------------------ 793| 0| ctrl.useecs = true; ------------------ | | 83| 0|# define true 1 ------------------ 794| 0| break; 795| | 796| 0| case 'F': ------------------ | Branch (796:9): [True: 0, False: 0] ------------------ 797| 0| ctrl.fullspd = true; ------------------ | | 83| 0|# define true 1 ------------------ 798| 0| break; 799| | 800| 0| case 'f': ------------------ | Branch (800:9): [True: 0, False: 0] ------------------ 801| 0| ctrl.fulltbl = true; ------------------ | | 83| 0|# define true 1 ------------------ 802| 0| break; 803| | 804| 0| case 'm': ------------------ | Branch (804:9): [True: 0, False: 0] ------------------ 805| 0| ctrl.usemecs = true; ------------------ | | 83| 0|# define true 1 ------------------ 806| 0| break; 807| | 808| 0| case 'r': ------------------ | Branch (808:9): [True: 0, False: 0] ------------------ 809| 0| ctrl.use_read = true; ------------------ | | 83| 0|# define true 1 ------------------ 810| 0| break; 811| | 812| 0| default: ------------------ | Branch (812:9): [True: 0, False: 0] ------------------ 813| 0| lerr (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 814| 0| ("unknown -C option '%c'"), 815| 0| arg[i]); 816| 0| break; 817| 0| } 818| 0| break; 819| | 820| 0| case OPT_DEBUG: ------------------ | Branch (820:7): [True: 0, False: 0] ------------------ 821| 0| ctrl.ddebug = true; ------------------ | | 83| 0|# define true 1 ------------------ 822| 0| break; 823| | 824| 0| case OPT_NO_DEBUG: ------------------ | Branch (824:7): [True: 0, False: 0] ------------------ 825| 0| ctrl.ddebug = false; ------------------ | | 82| 0|# define false 0 ------------------ 826| 0| break; 827| | 828| 0| case OPT_FULL: ------------------ | Branch (828:7): [True: 0, False: 0] ------------------ 829| 0| ctrl.useecs = ctrl.usemecs = false; ------------------ | | 82| 0|# define false 0 ------------------ 830| 0| ctrl.use_read = ctrl.fulltbl = true; ------------------ | | 83| 0|# define true 1 ------------------ 831| 0| break; 832| | 833| 0| case OPT_FAST: ------------------ | Branch (833:7): [True: 0, False: 0] ------------------ 834| 0| ctrl.useecs = ctrl.usemecs = false; ------------------ | | 82| 0|# define false 0 ------------------ 835| 0| ctrl.use_read = ctrl.fullspd = true; ------------------ | | 83| 0|# define true 1 ------------------ 836| 0| break; 837| | 838| 0| case OPT_HELP: ------------------ | Branch (838:7): [True: 0, False: 0] ------------------ 839| 0| usage (); 840| 0| FLEX_EXIT (0); ------------------ | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 841| | 842| 0| case OPT_INTERACTIVE: ------------------ | Branch (842:7): [True: 0, False: 0] ------------------ 843| 0| ctrl.interactive = true; ------------------ | | 83| 0|# define true 1 ------------------ 844| 0| break; 845| | 846| 0| case OPT_CASE_INSENSITIVE: ------------------ | Branch (846:7): [True: 0, False: 0] ------------------ 847| 0| sf_set_case_ins(true); ------------------ | | 1188| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1188:34): [True: 0, Folded] | | ------------------ ------------------ 848| 0| break; 849| | 850| 0| case OPT_LEX_COMPAT: ------------------ | Branch (850:7): [True: 0, False: 0] ------------------ 851| 0| ctrl.lex_compat = true; ------------------ | | 83| 0|# define true 1 ------------------ 852| 0| break; 853| | 854| 0| case OPT_POSIX_COMPAT: ------------------ | Branch (854:7): [True: 0, False: 0] ------------------ 855| 0| ctrl.posix_compat = true; ------------------ | | 83| 0|# define true 1 ------------------ 856| 0| break; 857| | 858| 0| case OPT_PREPROC_LEVEL: ------------------ | Branch (858:7): [True: 0, False: 0] ------------------ 859| 0| preproc_level = (int) strtol(arg,NULL,0); 860| 0| break; 861| | 862| 0| case OPT_MAIN: ------------------ | Branch (862:7): [True: 0, False: 0] ------------------ 863| 0| ctrl.do_yywrap = false; ------------------ | | 82| 0|# define false 0 ------------------ 864| 0| ctrl.do_main = trit_true; 865| 0| break; 866| | 867| 0| case OPT_NO_MAIN: ------------------ | Branch (867:7): [True: 0, False: 0] ------------------ 868| 0| ctrl.do_main = trit_false; 869| 0| break; 870| | 871| 0| case OPT_NO_LINE: ------------------ | Branch (871:7): [True: 0, False: 0] ------------------ 872| 0| ctrl.gen_line_dirs = false; ------------------ | | 82| 0|# define false 0 ------------------ 873| 0| break; 874| | 875| 0| case OPT_OUTFILE: ------------------ | Branch (875:7): [True: 0, False: 0] ------------------ 876| 0| env.outfilename = arg; 877| 0| env.did_outfilename = 1; 878| 0| break; 879| | 880| 0| case OPT_PREFIX: ------------------ | Branch (880:7): [True: 0, False: 0] ------------------ 881| 0| ctrl.prefix = arg; 882| 0| break; 883| | 884| 0| case OPT_PERF_REPORT: ------------------ | Branch (884:7): [True: 0, False: 0] ------------------ 885| 0| ++env.performance_hint; 886| 0| break; 887| | 888| 0| case OPT_BISON_BRIDGE: ------------------ | Branch (888:7): [True: 0, False: 0] ------------------ 889| 0| ctrl.bison_bridge_lval = true; ------------------ | | 83| 0|# define true 1 ------------------ 890| 0| break; 891| | 892| 0| case OPT_BISON_BRIDGE_LOCATIONS: ------------------ | Branch (892:7): [True: 0, False: 0] ------------------ 893| 0| ctrl.bison_bridge_lval = ctrl.bison_bridge_lloc = true; ------------------ | | 83| 0|# define true 1 ------------------ 894| 0| break; 895| | 896| 0| case OPT_REENTRANT: ------------------ | Branch (896:7): [True: 0, False: 0] ------------------ 897| 0| ctrl.reentrant = true; ------------------ | | 83| 0|# define true 1 ------------------ 898| 0| break; 899| | 900| 0| case OPT_NO_REENTRANT: ------------------ | Branch (900:7): [True: 0, False: 0] ------------------ 901| 0| ctrl.reentrant = false; ------------------ | | 82| 0|# define false 0 ------------------ 902| 0| break; 903| | 904| 0| case OPT_SKEL: ------------------ | Branch (904:7): [True: 0, False: 0] ------------------ 905| 0| env.skelname = arg; 906| 0| break; 907| | 908| 0| case OPT_DEFAULT: ------------------ | Branch (908:7): [True: 0, False: 0] ------------------ 909| 0| ctrl.spprdflt = false; ------------------ | | 82| 0|# define false 0 ------------------ 910| 0| break; 911| | 912| 0| case OPT_NO_DEFAULT: ------------------ | Branch (912:7): [True: 0, False: 0] ------------------ 913| 0| ctrl.spprdflt = true; ------------------ | | 83| 0|# define true 1 ------------------ 914| 0| break; 915| | 916| 0| case OPT_STDOUT: ------------------ | Branch (916:7): [True: 0, False: 0] ------------------ 917| 0| env.use_stdout = true; ------------------ | | 83| 0|# define true 1 ------------------ 918| 0| break; 919| | 920| 0| case OPT_NO_UNISTD_H: ------------------ | Branch (920:7): [True: 0, False: 0] ------------------ 921| 0| ctrl.no_unistd = true; ------------------ | | 83| 0|# define true 1 ------------------ 922| 0| break; 923| | 924| 0| case OPT_TABLES_FILE: ------------------ | Branch (924:7): [True: 0, False: 0] ------------------ 925| 0| tablesext = true; ------------------ | | 83| 0|# define true 1 ------------------ 926| 0| tablesfilename = arg; 927| 0| break; 928| | 929| 0| case OPT_TABLES_VERIFY: ------------------ | Branch (929:7): [True: 0, False: 0] ------------------ 930| 0| tablesverify = true; ------------------ | | 83| 0|# define true 1 ------------------ 931| 0| break; 932| | 933| 0| case OPT_TRACE: ------------------ | Branch (933:7): [True: 0, False: 0] ------------------ 934| 0| env.trace = true; ------------------ | | 83| 0|# define true 1 ------------------ 935| 0| break; 936| | 937| 0| case OPT_VERBOSE: ------------------ | Branch (937:7): [True: 0, False: 0] ------------------ 938| 0| env.printstats = true; ------------------ | | 83| 0|# define true 1 ------------------ 939| 0| break; 940| | 941| 0| case OPT_VERSION: ------------------ | Branch (941:7): [True: 0, False: 0] ------------------ 942| 0| printf ("%s %s\n", (ctrl.C_plus_plus ? "flex++" : "flex"), flex_version); ------------------ | Branch (942:24): [True: 0, False: 0] ------------------ 943| 0| FLEX_EXIT (0); ------------------ | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 944| | 945| 0| case OPT_WARN: ------------------ | Branch (945:7): [True: 0, False: 0] ------------------ 946| 0| env.nowarn = false; ------------------ | | 82| 0|# define false 0 ------------------ 947| 0| break; 948| | 949| 0| case OPT_NO_WARN: ------------------ | Branch (949:7): [True: 0, False: 0] ------------------ 950| 0| env.nowarn = true; ------------------ | | 83| 0|# define true 1 ------------------ 951| 0| break; 952| | 953| 0| case OPT_7BIT: ------------------ | Branch (953:7): [True: 0, False: 0] ------------------ 954| 0| ctrl.csize = 128; 955| 0| break; 956| | 957| 0| case OPT_8BIT: ------------------ | Branch (957:7): [True: 0, False: 0] ------------------ 958| 0| ctrl.csize = CSIZE; ------------------ | | 106| 0|#define CSIZE 256 ------------------ 959| 0| break; 960| | 961| 0| case OPT_ALIGN: ------------------ | Branch (961:7): [True: 0, False: 0] ------------------ 962| 0| ctrl.long_align = true; ------------------ | | 83| 0|# define true 1 ------------------ 963| 0| break; 964| | 965| 0| case OPT_NO_ALIGN: ------------------ | Branch (965:7): [True: 0, False: 0] ------------------ 966| 0| ctrl.long_align = false; ------------------ | | 82| 0|# define false 0 ------------------ 967| 0| break; 968| | 969| 0| case OPT_ALWAYS_INTERACTIVE: ------------------ | Branch (969:7): [True: 0, False: 0] ------------------ 970| 0| ctrl.always_interactive = true; ------------------ | | 83| 0|# define true 1 ------------------ 971| 0| break; 972| | 973| 0| case OPT_NEVER_INTERACTIVE: ------------------ | Branch (973:7): [True: 0, False: 0] ------------------ 974| 0| ctrl.never_interactive = true; ------------------ | | 83| 0|# define true 1 ------------------ 975| 0| break; 976| | 977| 0| case OPT_ARRAY: ------------------ | Branch (977:7): [True: 0, False: 0] ------------------ 978| 0| ctrl.yytext_is_array = true; ------------------ | | 83| 0|# define true 1 ------------------ 979| 0| break; 980| | 981| 0| case OPT_POINTER: ------------------ | Branch (981:7): [True: 0, False: 0] ------------------ 982| 0| ctrl.yytext_is_array = false; ------------------ | | 82| 0|# define false 0 ------------------ 983| 0| break; 984| | 985| 0| case OPT_ECS: ------------------ | Branch (985:7): [True: 0, False: 0] ------------------ 986| 0| ctrl.useecs = true; ------------------ | | 83| 0|# define true 1 ------------------ 987| 0| break; 988| | 989| 0| case OPT_NO_ECS: ------------------ | Branch (989:7): [True: 0, False: 0] ------------------ 990| 0| ctrl.useecs = false; ------------------ | | 82| 0|# define false 0 ------------------ 991| 0| break; 992| | 993| 0| case OPT_EMIT: ------------------ | Branch (993:7): [True: 0, False: 0] ------------------ 994| 0| ctrl.emit = arg; 995| 0| break; 996| | 997| 0| case OPT_HEADER_FILE: ------------------ | Branch (997:7): [True: 0, False: 0] ------------------ 998| 0| env.headerfilename = arg; 999| 0| break; 1000| | 1001| 0| case OPT_META_ECS: ------------------ | Branch (1001:7): [True: 0, False: 0] ------------------ 1002| 0| ctrl.usemecs = true; ------------------ | | 83| 0|# define true 1 ------------------ 1003| 0| break; 1004| | 1005| 0| case OPT_NO_META_ECS: ------------------ | Branch (1005:7): [True: 0, False: 0] ------------------ 1006| 0| ctrl.usemecs = false; ------------------ | | 82| 0|# define false 0 ------------------ 1007| 0| break; 1008| | 1009| 0| case OPT_PREPROCDEFINE: ------------------ | Branch (1009:7): [True: 0, False: 0] ------------------ 1010| 0| { 1011| | /* arg is "symbol" or "symbol=definition". */ 1012| 0| char *def; 1013| 0| char buf2[4096]; 1014| | 1015| 0| for (def = arg; 1016| 0| *def != '\0' && *def != '='; ++def) ------------------ | Branch (1016:6): [True: 0, False: 0] | Branch (1016:22): [True: 0, False: 0] ------------------ 1017| 0| continue; 1018| 0| if (*def == '\0') ------------------ | Branch (1018:12): [True: 0, False: 0] ------------------ 1019| 0| def = "1"; 1020| | 1021| 0| snprintf(buf2, sizeof(buf2), "M4_HOOK_CONST_DEFINE_UNKNOWN(%s, %s)", arg, def); 1022| 0| buf_strappend (&userdef_buf, buf2); 1023| 0| } 1024| 0| break; 1025| | 1026| 0| case OPT_READ: ------------------ | Branch (1026:7): [True: 0, False: 0] ------------------ 1027| 0| ctrl.use_read = true; ------------------ | | 83| 0|# define true 1 ------------------ 1028| 0| break; 1029| | 1030| 0| case OPT_STACK: ------------------ | Branch (1030:7): [True: 0, False: 0] ------------------ 1031| 0| ctrl.stack_used = true; ------------------ | | 83| 0|# define true 1 ------------------ 1032| 0| break; 1033| | 1034| 0| case OPT_STDINIT: ------------------ | Branch (1034:7): [True: 0, False: 0] ------------------ 1035| 0| ctrl.do_stdinit = true; ------------------ | | 83| 0|# define true 1 ------------------ 1036| 0| break; 1037| | 1038| 0| case OPT_NO_STDINIT: ------------------ | Branch (1038:7): [True: 0, False: 0] ------------------ 1039| 0| ctrl.do_stdinit = false; ------------------ | | 82| 0|# define false 0 ------------------ 1040| 0| break; 1041| | 1042| 0| case OPT_YYCLASS: ------------------ | Branch (1042:7): [True: 0, False: 0] ------------------ 1043| 0| ctrl.yyclass = arg; 1044| 0| break; 1045| | 1046| 0| case OPT_YYLINENO: ------------------ | Branch (1046:7): [True: 0, False: 0] ------------------ 1047| 0| ctrl.do_yylineno = true; ------------------ | | 83| 0|# define true 1 ------------------ 1048| 0| break; 1049| | 1050| 0| case OPT_NO_YYLINENO: ------------------ | Branch (1050:7): [True: 0, False: 0] ------------------ 1051| 0| ctrl.do_yylineno = false; ------------------ | | 82| 0|# define false 0 ------------------ 1052| 0| break; 1053| | 1054| 0| case OPT_YYWRAP: ------------------ | Branch (1054:7): [True: 0, False: 0] ------------------ 1055| 0| ctrl.do_yywrap = true; ------------------ | | 83| 0|# define true 1 ------------------ 1056| 0| break; 1057| | 1058| 0| case OPT_NO_YYWRAP: ------------------ | Branch (1058:7): [True: 0, False: 0] ------------------ 1059| 0| ctrl.do_yywrap = false; ------------------ | | 82| 0|# define false 0 ------------------ 1060| 0| break; 1061| | 1062| 0| case OPT_YYMORE: ------------------ | Branch (1062:7): [True: 0, False: 0] ------------------ 1063| 0| ctrl.yymore_really_used = true; ------------------ | | 83| 0|# define true 1 ------------------ 1064| 0| break; 1065| | 1066| 0| case OPT_NO_YYMORE: ------------------ | Branch (1066:7): [True: 0, False: 0] ------------------ 1067| 0| ctrl.yymore_really_used = false; ------------------ | | 82| 0|# define false 0 ------------------ 1068| 0| break; 1069| | 1070| 0| case OPT_REJECT: ------------------ | Branch (1070:7): [True: 0, False: 0] ------------------ 1071| 0| ctrl.reject_really_used = true; ------------------ | | 83| 0|# define true 1 ------------------ 1072| 0| break; 1073| | 1074| 0| case OPT_NO_REJECT: ------------------ | Branch (1074:7): [True: 0, False: 0] ------------------ 1075| 0| ctrl.reject_really_used = false; ------------------ | | 82| 0|# define false 0 ------------------ 1076| 0| break; 1077| | 1078| 0| case OPT_NO_YY_PUSH_STATE: ------------------ | Branch (1078:7): [True: 0, False: 0] ------------------ 1079| 0| ctrl.no_yy_push_state = true; ------------------ | | 83| 0|# define true 1 ------------------ 1080| 0| break; 1081| 0| case OPT_NO_YY_POP_STATE: ------------------ | Branch (1081:7): [True: 0, False: 0] ------------------ 1082| 0| ctrl.no_yy_pop_state = true; ------------------ | | 83| 0|# define true 1 ------------------ 1083| 0| break; 1084| 0| case OPT_NO_YY_TOP_STATE: ------------------ | Branch (1084:7): [True: 0, False: 0] ------------------ 1085| 0| ctrl.no_yy_top_state = true; ------------------ | | 83| 0|# define true 1 ------------------ 1086| 0| break; 1087| 0| case OPT_NO_YYINPUT: ------------------ | Branch (1087:7): [True: 0, False: 0] ------------------ 1088| 0| ctrl.no_yyinput = true; ------------------ | | 83| 0|# define true 1 ------------------ 1089| 0| break; 1090| 0| case OPT_NO_YYUNPUT: ------------------ | Branch (1090:7): [True: 0, False: 0] ------------------ 1091| 0| ctrl.no_yyunput = true; ------------------ | | 83| 0|# define true 1 ------------------ 1092| 0| break; 1093| 0| case OPT_NO_YY_SCAN_BUFFER: ------------------ | Branch (1093:7): [True: 0, False: 0] ------------------ 1094| 0| ctrl.no_yy_scan_buffer = true; ------------------ | | 83| 0|# define true 1 ------------------ 1095| 0| break; 1096| 0| case OPT_NO_YY_SCAN_BYTES: ------------------ | Branch (1096:7): [True: 0, False: 0] ------------------ 1097| 0| ctrl.no_yy_scan_bytes = true; ------------------ | | 83| 0|# define true 1 ------------------ 1098| 0| break; 1099| 0| case OPT_NO_YY_SCAN_STRING: ------------------ | Branch (1099:7): [True: 0, False: 0] ------------------ 1100| 0| ctrl.no_yy_scan_string = true; ------------------ | | 83| 0|# define true 1 ------------------ 1101| 0| break; 1102| 0| case OPT_NO_YYGET_EXTRA: ------------------ | Branch (1102:7): [True: 0, False: 0] ------------------ 1103| 0| ctrl.no_yyget_extra = true; ------------------ | | 83| 0|# define true 1 ------------------ 1104| 0| break; 1105| 0| case OPT_NO_YYSET_EXTRA: ------------------ | Branch (1105:7): [True: 0, False: 0] ------------------ 1106| 0| ctrl.no_yyset_extra = true; ------------------ | | 83| 0|# define true 1 ------------------ 1107| 0| break; 1108| 0| case OPT_NO_YYGET_LENG: ------------------ | Branch (1108:7): [True: 0, False: 0] ------------------ 1109| 0| ctrl.no_yyget_leng = true; ------------------ | | 83| 0|# define true 1 ------------------ 1110| 0| break; 1111| 0| case OPT_NO_YYGET_TEXT: ------------------ | Branch (1111:7): [True: 0, False: 0] ------------------ 1112| 0| ctrl.no_yyget_text = true; ------------------ | | 83| 0|# define true 1 ------------------ 1113| 0| break; 1114| 0| case OPT_NO_YYGET_LINENO: ------------------ | Branch (1114:7): [True: 0, False: 0] ------------------ 1115| 0| ctrl.no_yyget_lineno = true; ------------------ | | 83| 0|# define true 1 ------------------ 1116| 0| break; 1117| 0| case OPT_NO_YYSET_LINENO: ------------------ | Branch (1117:7): [True: 0, False: 0] ------------------ 1118| 0| ctrl.no_yyset_lineno = true; ------------------ | | 83| 0|# define true 1 ------------------ 1119| 0| break; 1120| 0| case OPT_NO_YYGET_COLUMN: ------------------ | Branch (1120:7): [True: 0, False: 0] ------------------ 1121| 0| ctrl.no_yyget_column = true; ------------------ | | 83| 0|# define true 1 ------------------ 1122| 0| break; 1123| 0| case OPT_NO_YYSET_COLUMN: ------------------ | Branch (1123:7): [True: 0, False: 0] ------------------ 1124| 0| ctrl.no_yyset_column = true; ------------------ | | 83| 0|# define true 1 ------------------ 1125| 0| break; 1126| 0| case OPT_NO_YYGET_IN: ------------------ | Branch (1126:7): [True: 0, False: 0] ------------------ 1127| 0| ctrl.no_yyget_in = true; ------------------ | | 83| 0|# define true 1 ------------------ 1128| 0| break; 1129| 0| case OPT_NO_YYSET_IN: ------------------ | Branch (1129:7): [True: 0, False: 0] ------------------ 1130| 0| ctrl.no_yyset_in = true; ------------------ | | 83| 0|# define true 1 ------------------ 1131| 0| break; 1132| 0| case OPT_NO_YYGET_OUT: ------------------ | Branch (1132:7): [True: 0, False: 0] ------------------ 1133| 0| ctrl.no_yyget_out = true; ------------------ | | 83| 0|# define true 1 ------------------ 1134| 0| break; 1135| 0| case OPT_NO_YYSET_OUT: ------------------ | Branch (1135:7): [True: 0, False: 0] ------------------ 1136| 0| ctrl.no_yyset_out = true; ------------------ | | 83| 0|# define true 1 ------------------ 1137| 0| break; 1138| 0| case OPT_NO_YYGET_LVAL: ------------------ | Branch (1138:7): [True: 0, False: 0] ------------------ 1139| 0| ctrl.no_yyget_lval = true; ------------------ | | 83| 0|# define true 1 ------------------ 1140| 0| break; 1141| 0| case OPT_NO_YYSET_LVAL: ------------------ | Branch (1141:7): [True: 0, False: 0] ------------------ 1142| 0| ctrl.no_yyset_lval = true; ------------------ | | 83| 0|# define true 1 ------------------ 1143| 0| break; 1144| 0| case OPT_NO_YYGET_LLOC: ------------------ | Branch (1144:7): [True: 0, False: 0] ------------------ 1145| 0| ctrl.no_yyget_lloc = true; ------------------ | | 83| 0|# define true 1 ------------------ 1146| 0| break; 1147| 0| case OPT_NO_YYSET_LLOC: ------------------ | Branch (1147:7): [True: 0, False: 0] ------------------ 1148| 0| ctrl.no_yyset_lloc = true; ------------------ | | 83| 0|# define true 1 ------------------ 1149| 0| break; 1150| 0| case OPT_NO_YYGET_DEBUG: ------------------ | Branch (1150:7): [True: 0, False: 0] ------------------ 1151| 0| ctrl.no_get_debug = true; ------------------ | | 83| 0|# define true 1 ------------------ 1152| 0| break; 1153| 0| case OPT_NO_YYSET_DEBUG: ------------------ | Branch (1153:7): [True: 0, False: 0] ------------------ 1154| 0| ctrl.no_set_debug = true; ------------------ | | 83| 0|# define true 1 ------------------ 1155| 0| break; 1156| | 1157| 0| case OPT_HEX: ------------------ | Branch (1157:7): [True: 0, False: 0] ------------------ 1158| 0| env.trace_hex = true; ------------------ | | 83| 0|# define true 1 ------------------ 1159| 0| break; 1160| 0| case OPT_NO_SECT3_ESCAPE: ------------------ | Branch (1160:7): [True: 0, False: 0] ------------------ 1161| 0| ctrl.no_section3_escape = true; ------------------ | | 83| 0|# define true 1 ------------------ 1162| 0| break; 1163| 0| } /* switch */ 1164| 0| } /* while scanopt() */ 1165| | 1166| 778| scanopt_destroy (sopt); 1167| | 1168| 778| num_input_files = argc - optind; 1169| 778| input_files = argv + optind; 1170| 778| set_input_file (num_input_files > 0 ? input_files[0] : NULL); ------------------ | Branch (1170:18): [True: 778, False: 0] ------------------ 1171| | 1172| 778| lastccl = lastsc = lastdfa = lastnfa = 0; 1173| 778| num_rules = num_eof_rules = default_rule = 0; 1174| 778| numas = numsnpairs = tmpuses = 0; 1175| 778| numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 1176| 778| 0; 1177| 778| numuniq = numdup = hshsave = datapos = dataline = 0; 1178| 778| eofseen = false; ------------------ | | 82| 778|# define false 0 ------------------ 1179| 778| num_backing_up = onesp = numprots = 0; 1180| 778| variable_trailing_context_rules = bol_needed = false; ------------------ | | 82| 778|# define false 0 ------------------ 1181| | 1182| 778| linenum = sectnum = 1; 1183| 778| firstprot = NIL; ------------------ | | 192| 778|#define NIL 0 ------------------ 1184| | 1185| | /* Used in mkprot() so that the first proto goes in slot 1 1186| | * of the proto queue. 1187| | */ 1188| 778| lastprot = 1; 1189| | 1190| 778| set_up_initial_allocations (); 1191| 778|} readin: 1197| 778|{ 1198| 778| char buf[256]; 1199| | 1200| 778| line_directive_out(NULL, infilename, linenum); 1201| | 1202| 778| if (yyparse ()) { ------------------ | Branch (1202:6): [True: 547, False: 231] ------------------ 1203| 547| pinpoint_message (_("fatal parse error")); ------------------ | | 102| 547|#define _(STRING) STRING ------------------ 1204| 547| flexend (1); 1205| 547| } 1206| | 1207| 778| if (syntaxerror) ------------------ | Branch (1207:6): [True: 231, False: 547] ------------------ 1208| 231| flexend (1); 1209| | 1210| | /* On --emit, -e, or change backends This is where backend 1211| | * properties are collected, which means they can't be set 1212| | * from a custom skelfile. Note: might have been called sooner 1213| | * when %option emit was evaluated; this catches command-line 1214| | * optiins and the default case. 1215| | */ 1216| 778| backend_by_name(ctrl.emit); 1217| | 1218| 778| initialize_output_filters(); 1219| | 1220| 778| yyout = stdout; 1221| | 1222| 778| if (tablesext) ------------------ | Branch (1222:6): [True: 0, False: 778] ------------------ 1223| 0| gentables = false; ------------------ | | 82| 0|# define false 0 ------------------ 1224| | 1225| 778| if (tablesverify) ------------------ | Branch (1225:6): [True: 0, False: 778] ------------------ 1226| | /* force generation of C tables. */ 1227| 0| gentables = true; ------------------ | | 83| 0|# define true 1 ------------------ 1228| | 1229| | 1230| 778| if (tablesext) { ------------------ | Branch (1230:6): [True: 0, False: 778] ------------------ 1231| 0| FILE *tablesout; 1232| 0| struct yytbl_hdr hdr; 1233| 0| char *pname = 0; 1234| 0| size_t nbytes = 0; 1235| | 1236| 0| if (!tablesfilename) { ------------------ | Branch (1236:7): [True: 0, False: 0] ------------------ 1237| 0| nbytes = strlen (ctrl.prefix) + strlen (tablesfile_template) + 2; 1238| 0| tablesfilename = pname = calloc(nbytes, 1); 1239| 0| snprintf (pname, nbytes, tablesfile_template, ctrl.prefix); 1240| 0| } 1241| | 1242| 0| if ((tablesout = fopen (tablesfilename, "w")) == NULL) ------------------ | Branch (1242:7): [True: 0, False: 0] ------------------ 1243| 0| lerr (_("could not create %s"), tablesfilename); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1244| 0| free(pname); 1245| 0| tablesfilename = 0; 1246| | 1247| 0| yytbl_writer_init (&tableswr, tablesout); 1248| | 1249| 0| nbytes = strlen (ctrl.prefix) + strlen ("tables") + 2; 1250| 0| tablesname = calloc(nbytes, 1); 1251| 0| snprintf (tablesname, nbytes, "%stables", ctrl.prefix); 1252| 0| yytbl_hdr_init (&hdr, flex_version, tablesname); 1253| | 1254| 0| if (yytbl_hdr_fwrite (&tableswr, &hdr) <= 0) ------------------ | Branch (1254:7): [True: 0, False: 0] ------------------ 1255| 0| flexerror (_("could not write tables header")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1256| 0| } 1257| | 1258| 778| if (env.skelname && (skelfile = fopen (env.skelname, "r")) == NULL) ------------------ | Branch (1258:6): [True: 0, False: 778] | Branch (1258:22): [True: 0, False: 0] ------------------ 1259| 0| lerr (_("can't open skeleton file %s"), env.skelname); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1260| | 1261| 778| if (strchr(ctrl.prefix, '[') || strchr(ctrl.prefix, ']')) ------------------ | Branch (1261:6): [True: 778, False: 0] | Branch (1261:34): [True: 0, False: 0] ------------------ 1262| 0| flexerror(_("Prefix cannot include '[' or ']'")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1263| | 1264| 778| if (env.did_outfilename) ------------------ | Branch (1264:6): [True: 0, False: 778] ------------------ 1265| 0| line_directive_out (stdout, NULL, linenum); 1266| | 1267| | /* This is where we begin writing to the file. */ 1268| | 1269| 778| skelout(false); /* [0.0] Make hook macros available, silently */ ------------------ | | 82| 778|# define false 0 ------------------ 1270| | 1271| 778| comment("A lexical scanner generated by flex\n"); 1272| | 1273| | /* Dump the %top code. */ 1274| 778| if( top_buf.elts) ------------------ | Branch (1274:6): [True: 0, False: 778] ------------------ 1275| 0| outn((char*) top_buf.elts); 1276| | 1277| | /* Place a bogus line directive, it will be fixed in the filter. */ 1278| 778| line_directive_out(NULL, NULL, 0); 1279| | 1280| | /* User may want to set the scanner prototype */ 1281| 778| if (ctrl.yydecl != NULL) { ------------------ | Branch (1281:6): [True: 0, False: 778] ------------------ 1282| 0| out_str ("M4_HOOK_SET_YY_DECL(%s)\n", ctrl.yydecl); 1283| 0| } 1284| | 1285| 778| if (ctrl.userinit != NULL) { ------------------ | Branch (1285:6): [True: 0, False: 778] ------------------ 1286| 0| out_str ("M4_HOOK_SET_USERINIT(%s)\n", ctrl.userinit); 1287| 0| } 1288| 778| if (ctrl.preaction != NULL) { ------------------ | Branch (1288:6): [True: 0, False: 778] ------------------ 1289| 0| out_str ("M4_HOOK_SET_PREACTION(%s)\n", ctrl.preaction); 1290| 0| } 1291| 778| if (ctrl.postaction != NULL) { ------------------ | Branch (1291:6): [True: 0, False: 778] ------------------ 1292| 0| out_str ("M4_HOOK_SET_POSTACTION(%s)\n", ctrl.postaction); 1293| 0| } 1294| | 1295| | /* This has to be a straight textual substitution rather 1296| | * than a constant declaration because in C a const is 1297| | * not const enough to be a static array bound. 1298| | */ 1299| 778| out_dec ("m4_define([[YYLMAX]], [[%d]])\n", ctrl.yylmax); 1300| | 1301| | /* Dump the user defined preproc directives. */ 1302| 778| if (userdef_buf.elts) ------------------ | Branch (1302:6): [True: 0, False: 778] ------------------ 1303| 0| outn ((char *) (userdef_buf.elts)); 1304| | 1305| | /* If the user explicitly requested posix compatibility by specifying the 1306| | * posix-compat option, then we check for conflicting options. However, if 1307| | * the POSIXLY_CORRECT variable is set, then we quietly make flex as 1308| | * posix-compatible as possible. This is the recommended behavior 1309| | * according to the GNU Coding Standards. 1310| | * 1311| | * Note: The posix option was added to flex to provide the posix behavior 1312| | * of the repeat operator in regular expressions, e.g., `ab{3}' 1313| | */ 1314| 778| if (ctrl.posix_compat) { ------------------ | Branch (1314:6): [True: 0, False: 778] ------------------ 1315| | /* TODO: This is where we try to make flex behave according to 1316| | * POSIX, *and* check for conflicting ctrl. How far should we go 1317| | * with this? Should we disable all the neat-o flex features? 1318| | */ 1319| | /* Update: Estes says no, since other flex features don't violate posix. */ 1320| 0| } 1321| | 1322| 778| if (getenv ("POSIXLY_CORRECT")) { ------------------ | Branch (1322:6): [True: 0, False: 778] ------------------ 1323| 0| ctrl.posix_compat = true; ------------------ | | 83| 0|# define true 1 ------------------ 1324| 0| } 1325| | 1326| 778| if (env.backing_up_report) { ------------------ | Branch (1326:6): [True: 0, False: 778] ------------------ 1327| 0| ctrl.backing_up_file = fopen (backing_name, "w"); 1328| 0| if (ctrl.backing_up_file == NULL) ------------------ | Branch (1328:7): [True: 0, False: 0] ------------------ 1329| 0| lerr (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1330| 0| ("could not create backing-up info file %s"), 1331| 0| backing_name); 1332| 0| } 1333| | 1334| 778| else 1335| 778| ctrl.backing_up_file = NULL; 1336| | 1337| 778| if (ctrl.yymore_really_used == true) ------------------ | | 83| 778|# define true 1 ------------------ | Branch (1337:6): [True: 0, False: 778] ------------------ 1338| 0| yymore_used = true; ------------------ | | 83| 0|# define true 1 ------------------ 1339| 778| else if (ctrl.yymore_really_used == false) ------------------ | | 82| 778|# define false 0 ------------------ | Branch (1339:11): [True: 0, False: 778] ------------------ 1340| 0| yymore_used = false; ------------------ | | 82| 0|# define false 0 ------------------ 1341| | 1342| 778| if (ctrl.reject_really_used == true) ------------------ | | 83| 778|# define true 1 ------------------ | Branch (1342:6): [True: 0, False: 778] ------------------ 1343| 0| reject = true; ------------------ | | 83| 0|# define true 1 ------------------ 1344| 778| else if (ctrl.reject_really_used == false) ------------------ | | 82| 778|# define false 0 ------------------ | Branch (1344:11): [True: 0, False: 778] ------------------ 1345| 0| reject = false; ------------------ | | 82| 0|# define false 0 ------------------ 1346| | 1347| 778| if (env.performance_hint > 0) { ------------------ | Branch (1347:6): [True: 0, False: 778] ------------------ 1348| 0| if (ctrl.lex_compat) { ------------------ | Branch (1348:7): [True: 0, False: 0] ------------------ 1349| 0| fprintf (stderr, 1350| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1351| 0| ("-l AT&T lex compatibility option entails a large performance penalty\n")); 1352| 0| fprintf (stderr, 1353| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1354| 0| (" and may be the actual source of other reported performance penalties\n")); 1355| 0| } 1356| | 1357| 0| else if (ctrl.do_yylineno) { ------------------ | Branch (1357:12): [True: 0, False: 0] ------------------ 1358| 0| fprintf (stderr, 1359| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1360| 0| ("%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n")); 1361| 0| } 1362| | 1363| 0| if (env.performance_hint > 1) { ------------------ | Branch (1363:7): [True: 0, False: 0] ------------------ 1364| 0| if (ctrl.interactive == trit_true) ------------------ | Branch (1364:8): [True: 0, False: 0] ------------------ 1365| 0| fprintf (stderr, 1366| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1367| 0| ("-I (interactive) entails a minor performance penalty\n")); 1368| | 1369| 0| if (yymore_used) ------------------ | Branch (1369:8): [True: 0, False: 0] ------------------ 1370| 0| fprintf (stderr, 1371| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1372| 0| ("yymore() entails a minor performance penalty\n")); 1373| 0| } 1374| | 1375| 0| if (reject) ------------------ | Branch (1375:7): [True: 0, False: 0] ------------------ 1376| 0| fprintf (stderr, 1377| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1378| 0| ("REJECT entails a large performance penalty\n")); 1379| | 1380| 0| if (variable_trailing_context_rules) ------------------ | Branch (1380:7): [True: 0, False: 0] ------------------ 1381| 0| fprintf (stderr, 1382| 0| _ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1383| 0| ("Variable trailing context rules entail a large performance penalty\n")); 1384| 0| } 1385| | 1386| 778| if (reject) ------------------ | Branch (1386:6): [True: 0, False: 778] ------------------ 1387| 0| real_reject = true; ------------------ | | 83| 0|# define true 1 ------------------ 1388| | 1389| 778| if (variable_trailing_context_rules) ------------------ | Branch (1389:6): [True: 0, False: 778] ------------------ 1390| 0| reject = true; ------------------ | | 83| 0|# define true 1 ------------------ 1391| | 1392| 778| if ((ctrl.fulltbl || ctrl.fullspd) && reject) { ------------------ | Branch (1392:7): [True: 778, False: 0] | Branch (1392:23): [True: 0, False: 0] | Branch (1392:40): [True: 0, False: 0] ------------------ 1393| 0| if (real_reject) ------------------ | Branch (1393:7): [True: 0, False: 0] ------------------ 1394| 0| flexerror (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1395| 0| ("REJECT cannot be used with -f or -F")); 1396| 0| else if (ctrl.do_yylineno) ------------------ | Branch (1396:12): [True: 0, False: 0] ------------------ 1397| 0| flexerror (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1398| 0| ("%option yylineno cannot be used with REJECT")); 1399| 0| else 1400| 0| flexerror (_ ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1401| 0| ("variable trailing context rules cannot be used with -f or -F")); 1402| 0| } 1403| | 1404| 778| if (ctrl.useecs) ------------------ | Branch (1404:6): [True: 0, False: 778] ------------------ 1405| 0| numecs = cre8ecs (nextecm, ecgroup, ctrl.csize); 1406| 778| else 1407| 778| numecs = ctrl.csize; 1408| | 1409| | /* Now map the equivalence class for NUL to its expected place. */ 1410| 778| ecgroup[0] = ecgroup[ctrl.csize]; 1411| 778| NUL_ec = ABS (ecgroup[0]); ------------------ | | 123| 778|#define ABS(x) ((x) < 0 ? -(x) : (x)) | | ------------------ | | | Branch (123:17): [True: 0, False: 778] | | ------------------ ------------------ 1412| | 1413| 778| if (ctrl.useecs) ------------------ | Branch (1413:6): [True: 0, False: 778] ------------------ 1414| 0| ccl2ecl (); 1415| | 1416| | // These are used to conditionalize code in the lex skeleton 1417| | // that historically used to be generated by C code in flex 1418| | // itself; by shoving all this stuff out to the skeleton file 1419| | // we make it easier to retarget the code generation. 1420| 778| snprintf(buf, sizeof(buf), "Target: %s\n", ctrl.backend_name); 1421| 778| comment(buf); 1422| 778| comment("START of m4 controls\n"); 1423| | 1424| | /* Define the start condition macros. */ 1425| 778| { 1426| 778| struct Buf tmpbuf; 1427| 778| int i; 1428| 778| buf_init(&tmpbuf, sizeof(char)); 1429| 778| for (i = 1; i <= lastsc; i++) { ------------------ | Branch (1429:15): [True: 0, False: 778] ------------------ 1430| 0| char *str, *fmt = "M4_HOOK_CONST_DEFINE_STATE(%s, %d)"; 1431| 0| size_t strsz; 1432| | 1433| 0| strsz = strlen(fmt) + strlen(scname[i]) + (size_t)(1 + ceil (log10(i))) + 2; 1434| 0| str = malloc(strsz); 1435| 0| if (!str) ------------------ | Branch (1435:8): [True: 0, False: 0] ------------------ 1436| 0| flexfatal(_("allocation of macro definition failed")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 1437| 0| snprintf(str, strsz, fmt, scname[i], i - 1); 1438| 0| buf_strappend(&tmpbuf, str); 1439| 0| free(str); 1440| 0| } 1441| | // FIXME: Not dumped visibly because we plan to do away with the indirection 1442| 778| out_m4_define("M4_YY_SC_DEFS", tmpbuf.elts); 1443| 778| buf_destroy(&tmpbuf); 1444| 778| } 1445| | 1446| 778| if (ctrl.bison_bridge_lval) ------------------ | Branch (1446:6): [True: 0, False: 778] ------------------ 1447| 0| visible_define("M4_YY_BISON_LVAL"); 1448| | 1449| 778| if (ctrl.bison_bridge_lloc) ------------------ | Branch (1449:6): [True: 0, False: 778] ------------------ 1450| 0| visible_define(""); 1451| | 1452| 778| if (extra_type != NULL) ------------------ | Branch (1452:6): [True: 0, False: 778] ------------------ 1453| 0| visible_define_str ("M4_MODE_EXTRA_TYPE", extra_type); 1454| | 1455| | /* always generate the tablesverify flag. */ 1456| 778| visible_define_str ("M4_YY_TABLES_VERIFY", tablesverify ? "1" : "0"); ------------------ | Branch (1456:45): [True: 0, False: 778] ------------------ 1457| | 1458| 778| if (ctrl.reentrant) { ------------------ | Branch (1458:6): [True: 0, False: 778] ------------------ 1459| 0| visible_define ("M4_YY_REENTRANT"); 1460| 0| if (ctrl.yytext_is_array) ------------------ | Branch (1460:7): [True: 0, False: 0] ------------------ 1461| 0| visible_define ("M4_MODE_REENTRANT_TEXT_IS_ARRAY"); 1462| 0| } 1463| | 1464| 778| if (ctrl.do_main == trit_true) ------------------ | Branch (1464:6): [True: 0, False: 778] ------------------ 1465| 0| visible_define_str ( "YY_MAIN", "1"); 1466| 778| else if (ctrl.do_main == trit_false) ------------------ | Branch (1466:11): [True: 0, False: 778] ------------------ 1467| 0| visible_define_str ( "YY_MAIN", "0"); 1468| | 1469| 778| if (ctrl.do_stdinit) ------------------ | Branch (1469:6): [True: 0, False: 778] ------------------ 1470| 0| visible_define ( "M4_MODE_DO_STDINIT"); 1471| 778| else 1472| 778| visible_define ( "M4_MODE_NO_DO_STDINIT"); 1473| | 1474| | // mode switches for YY_DO_BEFORE_ACTION code generation 1475| 778| if (ctrl.yytext_is_array) ------------------ | Branch (1475:6): [True: 0, False: 778] ------------------ 1476| 0| visible_define ( "M4_MODE_YYTEXT_IS_ARRAY"); 1477| 778| else 1478| 778| visible_define ( "M4_MODE_NO_YYTEXT_IS_ARRAY"); 1479| 778| if (yymore_used) ------------------ | Branch (1479:6): [True: 0, False: 778] ------------------ 1480| 0| visible_define ( "M4_MODE_YYMORE_USED"); 1481| 778| else 1482| 778| visible_define ( "M4_MODE_NO_YYMORE_USED"); 1483| | 1484| 778| if (ctrl.fullspd) ------------------ | Branch (1484:6): [True: 0, False: 778] ------------------ 1485| 0| visible_define ( "M4_MODE_REAL_FULLSPD"); 1486| 778| else 1487| 778| visible_define ( "M4_MODE_NO_REAL_FULLSPD"); 1488| | 1489| 778| if (ctrl.fulltbl) ------------------ | Branch (1489:6): [True: 0, False: 778] ------------------ 1490| 0| visible_define ( "M4_MODE_REAL_FULLTBL"); 1491| 778| else 1492| 778| visible_define ( "M4_MODE_NO_REAL_FULLTBL"); 1493| | 1494| | // niode switches for YYINPUT code generation 1495| 778| if (ctrl.use_read) ------------------ | Branch (1495:6): [True: 0, False: 778] ------------------ 1496| 0| visible_define ( "M4_MODE_CPP_USE_READ"); 1497| 778| else 1498| 778| visible_define ( "M4_MODE_NO_CPP_USE_READ"); 1499| | 1500| | // mode switches for next-action code 1501| 778| if (variable_trailing_context_rules) { ------------------ | Branch (1501:6): [True: 0, False: 778] ------------------ 1502| 0| visible_define ( "M4_MODE_VARIABLE_TRAILING_CONTEXT_RULES"); 1503| 778| } else { 1504| 778| visible_define ( "M4_MODE_NO_VARIABLE_TRAILING_CONTEXT_RULES"); 1505| 778| } 1506| 778| if (real_reject) ------------------ | Branch (1506:6): [True: 0, False: 778] ------------------ 1507| 0| visible_define ( "M4_MODE_REAL_REJECT"); 1508| 778| if (ctrl.reject_really_used) ------------------ | Branch (1508:6): [True: 0, False: 778] ------------------ 1509| 0| visible_define ( "M4_MODE_FIND_ACTION_REJECT_REALLY_USED"); 1510| 778| if (reject) ------------------ | Branch (1510:6): [True: 0, False: 778] ------------------ 1511| 0| visible_define ( "M4_MODE_USES_REJECT"); 1512| 778| else 1513| 778| visible_define ( "M4_MODE_NO_USES_REJECT"); 1514| | 1515| | // mode switches for computing next compressed state 1516| 778| if (ctrl.usemecs) ------------------ | Branch (1516:6): [True: 0, False: 778] ------------------ 1517| 0| visible_define ( "M4_MODE_USEMECS"); 1518| | 1519| | // mode switches for find-action code 1520| 778| if (ctrl.fullspd) ------------------ | Branch (1520:6): [True: 0, False: 778] ------------------ 1521| 0| visible_define ( "M4_MODE_FULLSPD"); 1522| 778| else if (ctrl.fulltbl) ------------------ | Branch (1522:11): [True: 0, False: 778] ------------------ 1523| 0| visible_define ( "M4_MODE_FIND_ACTION_FULLTBL"); 1524| 778| else if (reject) ------------------ | Branch (1524:11): [True: 0, False: 778] ------------------ 1525| 0| visible_define ( "M4_MODE_FIND_ACTION_REJECT"); 1526| 778| else 1527| 778| visible_define ( "M4_MODE_FIND_ACTION_COMPRESSED"); 1528| | 1529| | // mode switches for backup generation and gen_start_state 1530| 778| if (!ctrl.fullspd) ------------------ | Branch (1530:6): [True: 0, False: 778] ------------------ 1531| 0| visible_define ( "M4_MODE_NO_FULLSPD"); 1532| 778| if (bol_needed) ------------------ | Branch (1532:6): [True: 0, False: 778] ------------------ 1533| 0| visible_define ( "M4_MODE_BOL_NEEDED"); 1534| 778| else 1535| 778| visible_define ( "M4_MODE_NO_BOL_NEEDED"); 1536| | 1537| | // yylineno 1538| 778| if (ctrl.do_yylineno) ------------------ | Branch (1538:6): [True: 0, False: 778] ------------------ 1539| 0| visible_define ( "M4_MODE_YYLINENO"); 1540| | 1541| | // Equivalence classes 1542| 778| if (ctrl.useecs) ------------------ | Branch (1542:6): [True: 0, False: 778] ------------------ 1543| 0| visible_define ( "M4_MODE_USEECS"); 1544| 778| else 1545| 778| visible_define ( "M4_MODE_NO_USEECS"); 1546| | 1547| | // mode switches for getting next action 1548| 778| if (gentables) ------------------ | Branch (1548:6): [True: 0, False: 778] ------------------ 1549| 0| visible_define ( "M4_MODE_GENTABLES"); 1550| 778| else 1551| 778| visible_define ( "M4_MODE_NO_GENTABLES"); 1552| 778| if (ctrl.interactive == trit_true) ------------------ | Branch (1552:6): [True: 0, False: 778] ------------------ 1553| 0| visible_define ( "M4_MODE_INTERACTIVE"); 1554| 778| else 1555| 778| visible_define ( "M4_MODE_NO_INTERACTIVE"); 1556| 778| if (!(ctrl.fullspd || ctrl.fulltbl)) ------------------ | Branch (1556:8): [True: 778, False: 0] | Branch (1556:24): [True: 0, False: 0] ------------------ 1557| 0| visible_define ( "M4_MODE_NO_FULLSPD_OR_FULLTBL"); 1558| 778| if (reject || ctrl.interactive == trit_true) ------------------ | Branch (1558:6): [True: 778, False: 0] | Branch (1558:16): [True: 0, False: 0] ------------------ 1559| 0| visible_define ( "M4_MODE_FIND_ACTION_REJECT_OR_INTERACTIVE"); 1560| | 1561| 778| if (ctrl.yyclass != NULL) { ------------------ | Branch (1561:6): [True: 0, False: 778] ------------------ 1562| 0| visible_define ( "M4_MODE_YYCLASS"); 1563| 0| out_m4_define("M4_YY_CLASS_NAME", ctrl.yyclass); 1564| 0| } 1565| | 1566| 778| if (ctrl.ddebug) ------------------ | Branch (1566:6): [True: 0, False: 778] ------------------ 1567| 0| visible_define ( "M4_MODE_DEBUG"); 1568| | 1569| 778| if (ctrl.lex_compat) ------------------ | Branch (1569:6): [True: 0, False: 778] ------------------ 1570| 0| visible_define ( "M4_MODE_OPTIONS.LEX_COMPAT"); 1571| | 1572| 778| if (ctrl.do_yywrap) ------------------ | Branch (1572:6): [True: 0, False: 778] ------------------ 1573| 0| visible_define ( "M4_MODE_YYWRAP"); 1574| 778| else 1575| 778| visible_define ( "M4_MODE_NO_YYWRAP"); 1576| | 1577| 778| if (ctrl.interactive == trit_true) ------------------ | Branch (1577:6): [True: 0, False: 778] ------------------ 1578| 0| visible_define ( "M4_MODE_INTERACTIVE"); 1579| | 1580| 778| if (ctrl.noyyread) ------------------ | Branch (1580:6): [True: 0, False: 778] ------------------ 1581| 0| visible_define("M4_MODE_USER_YYREAD"); 1582| | 1583| 778| if (is_default_backend()) { ------------------ | Branch (1583:6): [True: 0, False: 778] ------------------ 1584| 0| if (ctrl.C_plus_plus) { ------------------ | Branch (1584:7): [True: 0, False: 0] ------------------ 1585| 0| visible_define ( "M4_MODE_CXX_ONLY"); 1586| 0| } else { 1587| 0| visible_define ( "M4_MODE_C_ONLY"); 1588| 0| } 1589| 0| } 1590| | 1591| 778| if (tablesext) ------------------ | Branch (1591:6): [True: 0, False: 778] ------------------ 1592| 0| visible_define ( "M4_MODE_TABLESEXT"); 1593| 778| if (ctrl.prefix != NULL) ------------------ | Branch (1593:6): [True: 0, False: 778] ------------------ 1594| 0| visible_define_str ( "M4_MODE_PREFIX", ctrl.prefix); 1595| | 1596| 778| if (ctrl.no_yyinput) ------------------ | Branch (1596:6): [True: 0, False: 778] ------------------ 1597| 0| visible_define("M4_MODE_NO_YYINPUT"); 1598| | 1599| 778| if (ctrl.bufsize != 0) ------------------ | Branch (1599:6): [True: 0, False: 778] ------------------ 1600| 0| visible_define_int("M4_MODE_YY_BUFSIZE", ctrl.bufsize); 1601| | 1602| 778| if (ctrl.yyterminate != NULL) ------------------ | Branch (1602:6): [True: 0, False: 778] ------------------ 1603| 0| visible_define_str("M4_MODE_YYTERMINATE", ctrl.yyterminate); 1604| | 1605| 778| if (ctrl.no_yypanic) ------------------ | Branch (1605:6): [True: 0, False: 778] ------------------ 1606| 0| visible_define("M4_YY_NO_YYPANIC"); 1607| 778| if (ctrl.no_yy_push_state) ------------------ | Branch (1607:6): [True: 0, False: 778] ------------------ 1608| 0| visible_define("M4_YY_NO_PUSH_STATE"); 1609| 778| if (ctrl.no_yy_pop_state) ------------------ | Branch (1609:6): [True: 0, False: 778] ------------------ 1610| 0| visible_define("M4_YY_NO_POP_STATE"); 1611| 778| if (ctrl.no_yy_top_state) ------------------ | Branch (1611:6): [True: 0, False: 778] ------------------ 1612| 0| visible_define("M4_YY_NO_TOP_STATE"); 1613| 778| if (ctrl.no_yyunput) ------------------ | Branch (1613:6): [True: 0, False: 778] ------------------ 1614| 0| visible_define("M4_YY_NO_YYUNPUT"); 1615| 778| if (ctrl.no_yy_scan_buffer) ------------------ | Branch (1615:6): [True: 0, False: 778] ------------------ 1616| 0| visible_define("M4_YY_NO_SCAN_BUFFER"); 1617| 778| if (ctrl.no_yy_scan_bytes) ------------------ | Branch (1617:6): [True: 0, False: 778] ------------------ 1618| 0| visible_define("M4_YY_NO_SCAN_BYTES"); 1619| 778| if (ctrl.no_yy_scan_string) ------------------ | Branch (1619:6): [True: 0, False: 778] ------------------ 1620| 0| visible_define("M4_YY_NO_SCAN_STRING"); 1621| 778| if (ctrl.no_yyget_extra) ------------------ | Branch (1621:6): [True: 0, False: 778] ------------------ 1622| 0| visible_define("M4_YY_NO_GET_EXTRA"); 1623| 778| if (ctrl.no_yyset_extra) ------------------ | Branch (1623:6): [True: 0, False: 778] ------------------ 1624| 0| visible_define("M4_YY_NO_SET_EXTRA"); 1625| 778| if (ctrl.no_yyget_leng) ------------------ | Branch (1625:6): [True: 0, False: 778] ------------------ 1626| 0| visible_define("M4_YY_NO_GET_LENG"); 1627| 778| if (ctrl.no_yyget_text) ------------------ | Branch (1627:6): [True: 0, False: 778] ------------------ 1628| 0| visible_define("M4_YY_NO_GET_TEXT"); 1629| 778| if (ctrl.no_yyget_lineno) ------------------ | Branch (1629:6): [True: 0, False: 778] ------------------ 1630| 0| visible_define("M4_YY_NO_GET_LINENO"); 1631| 778| if (ctrl.no_yyset_lineno) ------------------ | Branch (1631:6): [True: 0, False: 778] ------------------ 1632| 0| visible_define("M4_YY_NO_SET_LINENO"); 1633| 778| if (ctrl.no_yyget_column) ------------------ | Branch (1633:6): [True: 0, False: 778] ------------------ 1634| 0| visible_define("M4_YY_NO_GET_COLUMN"); 1635| 778| if (ctrl.no_yyset_column) ------------------ | Branch (1635:6): [True: 0, False: 778] ------------------ 1636| 0| visible_define("M4_YY_NO_SET_COLUMN"); 1637| 778| if (ctrl.no_yyget_in) ------------------ | Branch (1637:6): [True: 0, False: 778] ------------------ 1638| 0| visible_define("M4_YY_NO_GET_IN"); 1639| 778| if (ctrl.no_yyset_in) ------------------ | Branch (1639:6): [True: 0, False: 778] ------------------ 1640| 0| visible_define("M4_YY_NO_SET_IN"); 1641| 778| if (ctrl.no_yyget_out) ------------------ | Branch (1641:6): [True: 0, False: 778] ------------------ 1642| 0| visible_define("M4_YY_NO_GET_OUT"); 1643| 778| if (ctrl.no_yyset_out) ------------------ | Branch (1643:6): [True: 0, False: 778] ------------------ 1644| 0| visible_define("M4_YY_NO_SET_OUT"); 1645| 778| if (ctrl.no_yyget_lval) ------------------ | Branch (1645:6): [True: 0, False: 778] ------------------ 1646| 0| visible_define("M4_YY_NO_GET_LVAL"); 1647| 778| if (ctrl.no_yyset_lval) ------------------ | Branch (1647:6): [True: 0, False: 778] ------------------ 1648| 0| visible_define("M4_YY_NO_SET_LVAL"); 1649| 778| if (ctrl.no_yyget_lloc) ------------------ | Branch (1649:6): [True: 0, False: 778] ------------------ 1650| 0| visible_define("M4_YY_NO_GET_LLOC"); 1651| 778| if (ctrl.no_yyset_lloc) ------------------ | Branch (1651:6): [True: 0, False: 778] ------------------ 1652| 0| visible_define("M4_YY_NO_SET_LLOC"); 1653| 778| if (ctrl.no_flex_alloc) ------------------ | Branch (1653:6): [True: 0, False: 778] ------------------ 1654| 0| visible_define("M4_YY_NO_FLEX_ALLOC"); 1655| 778| if (ctrl.no_flex_realloc) ------------------ | Branch (1655:6): [True: 0, False: 778] ------------------ 1656| 0| visible_define("M4_YY_NO_FLEX_REALLOC"); 1657| 778| if (ctrl.no_flex_free) ------------------ | Branch (1657:6): [True: 0, False: 778] ------------------ 1658| 0| visible_define("M4_YY_NO_FLEX_FREE"); 1659| 778| if (ctrl.no_get_debug) ------------------ | Branch (1659:6): [True: 0, False: 778] ------------------ 1660| 0| visible_define("M4_YY_NO_GET_DEBUG"); 1661| 778| if (ctrl.no_set_debug) ------------------ | Branch (1661:6): [True: 0, False: 778] ------------------ 1662| 0| visible_define("M4_YY_NO_SET_DEBUG"); 1663| | 1664| 778| if (ctrl.no_unistd) ------------------ | Branch (1664:6): [True: 0, False: 778] ------------------ 1665| 0| visible_define("M4_YY_NO_UNISTD_H"); 1666| | 1667| 778| if (ctrl.always_interactive) ------------------ | Branch (1667:6): [True: 0, False: 778] ------------------ 1668| 0| visible_define("M4_YY_ALWAYS_INTERACTIVE"); 1669| 778| if (ctrl.never_interactive) ------------------ | Branch (1669:6): [True: 0, False: 778] ------------------ 1670| 0| visible_define("M4_YY_NEVER_INTERACTIVE"); 1671| 778| if (ctrl.stack_used) ------------------ | Branch (1671:6): [True: 0, False: 778] ------------------ 1672| 0| visible_define("M4_YY_STACK_USED"); 1673| | 1674| 778| if (ctrl.rewrite) ------------------ | Branch (1674:6): [True: 0, False: 778] ------------------ 1675| 0| visible_define ( "M4_MODE_REWRITE"); 1676| 778| else 1677| 778| visible_define ( "M4_MODE_NO_REWRITE"); 1678| | 1679| 778| comment("END of m4 controls\n"); 1680| 778| out ("\n"); 1681| 778|} set_up_initial_allocations: 1686| 778|{ 1687| 778| maximum_mns = (ctrl.long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS); ------------------ | | 219| 0|#define MAXIMUM_MNS_LONG 1999999999 ------------------ maximum_mns = (ctrl.long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS); ------------------ | | 218| 778|#define MAXIMUM_MNS 31999 ------------------ | Branch (1687:17): [True: 0, False: 778] ------------------ 1688| 778| current_mns = INITIAL_MNS; ------------------ | | 209| 778|#define INITIAL_MNS 2000 /* default maximum number of nfa states */ ------------------ 1689| 778| firstst = allocate_integer_array (current_mns); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1690| 778| lastst = allocate_integer_array (current_mns); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1691| 778| finalst = allocate_integer_array (current_mns); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1692| 778| transchar = allocate_integer_array (current_mns); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1693| 778| trans1 = allocate_integer_array (current_mns); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1694| 778| trans2 = allocate_integer_array (current_mns); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1695| 778| accptnum = allocate_integer_array (current_mns); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1696| 778| assoc_rule = allocate_integer_array (current_mns); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1697| 778| state_type = allocate_integer_array (current_mns); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1698| | 1699| 778| current_max_rules = INITIAL_MAX_RULES; ------------------ | | 206| 778|#define INITIAL_MAX_RULES 100 /* default maximum number of rules */ ------------------ 1700| 778| rule_type = allocate_integer_array (current_max_rules); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1701| 778| rule_linenum = allocate_integer_array (current_max_rules); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1702| 778| rule_useful = allocate_array(current_max_rules, sizeof(char)); 1703| 778| rule_has_nl = allocate_array(current_max_rules, sizeof(char)); 1704| | 1705| 778| current_max_scs = INITIAL_MAX_SCS; ------------------ | | 236| 778|#define INITIAL_MAX_SCS 40 /* maximum number of start conditions */ ------------------ 1706| 778| scset = allocate_integer_array (current_max_scs); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1707| 778| scbol = allocate_integer_array (current_max_scs); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1708| 778| scxclu = allocate_array(current_max_scs, sizeof(char)); 1709| 778| sceof = allocate_array(current_max_scs, sizeof(char)); 1710| 778| scname = allocate_char_ptr_array (current_max_scs); ------------------ | | 734| 778| allocate_array(size, sizeof(char *)) ------------------ 1711| | 1712| 778| current_maxccls = INITIAL_MAX_CCLS; ------------------ | | 199| 778|#define INITIAL_MAX_CCLS 100 /* max number of unique character classes */ ------------------ 1713| 778| cclmap = allocate_integer_array (current_maxccls); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1714| 778| ccllen = allocate_integer_array (current_maxccls); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1715| 778| cclng = allocate_integer_array (current_maxccls); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1716| 778| ccl_has_nl = allocate_array(current_maxccls, sizeof(char)); 1717| | 1718| 778| current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE; ------------------ | | 203| 778|#define INITIAL_MAX_CCL_TBL_SIZE 500 ------------------ 1719| 778| ccltbl = allocate_Character_array (current_max_ccl_tbl_size); ------------------ | | 749| 778| allocate_array(size, sizeof(unsigned char)) ------------------ 1720| | 1721| 778| current_max_dfa_size = INITIAL_MAX_DFA_SIZE; ------------------ | | 165| 778|#define INITIAL_MAX_DFA_SIZE 750 ------------------ 1722| | 1723| 778| current_max_xpairs = INITIAL_MAX_XPAIRS; ------------------ | | 227| 778|#define INITIAL_MAX_XPAIRS 2000 ------------------ 1724| 778| nxt = allocate_integer_array (current_max_xpairs); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1725| 778| chk = allocate_integer_array (current_max_xpairs); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1726| | 1727| 778| current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS; ------------------ | | 231| 778|#define INITIAL_MAX_TEMPLATE_XPAIRS 2500 ------------------ 1728| 778| tnxt = allocate_integer_array (current_max_template_xpairs); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1729| | 1730| 778| current_max_dfas = INITIAL_MAX_DFAS; ------------------ | | 212| 778|#define INITIAL_MAX_DFAS 1000 /* default maximum number of dfa states */ ------------------ 1731| 778| base = allocate_integer_array (current_max_dfas); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1732| 778| def = allocate_integer_array (current_max_dfas); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1733| 778| dfasiz = allocate_integer_array (current_max_dfas); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1734| 778| accsiz = allocate_integer_array (current_max_dfas); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1735| 778| dhash = allocate_integer_array (current_max_dfas); ------------------ | | 725| 778| allocate_array(size, sizeof(int)) ------------------ 1736| 778| dss = allocate_int_ptr_array (current_max_dfas); ------------------ | | 731| 778| allocate_array(size, sizeof(int *)) ------------------ 1737| 778| dfaacc = allocate_array(current_max_dfas, 1738| 778| sizeof(union dfaacc_union)); 1739| | 1740| | nultrans = NULL; 1741| 778|} add_action: 40| 3.23k|{ 41| 3.23k| int len = (int) strlen (new_text); 42| | 43| 3.23k| while (len + action_index >= action_size - 10 /* slop */ ) { ------------------ | Branch (43:9): [True: 0, False: 3.23k] ------------------ 44| | 45| 0| if (action_size > INT_MAX / 2) ------------------ | Branch (45:7): [True: 0, False: 0] ------------------ 46| | /* Increase just a little, to try to avoid overflow 47| | * on 16-bit machines. 48| | */ 49| 0| action_size += action_size / 8; 50| 0| else 51| 0| action_size = action_size * 2; 52| | 53| 0| action_array = 54| 0| reallocate_character_array (action_array, ------------------ | | 746| 0| reallocate_array((void *) array, size, sizeof(char)) ------------------ 55| 0| action_size); 56| 0| } 57| | 58| 3.23k| strcpy (&action_array[action_index], new_text); 59| | 60| 3.23k| action_index += len; 61| 3.23k|} allocate_array: 67| 26.6k|{ 68| | return reallocate_array(NULL, size, element_size); 69| 26.6k|} xstrdup: 136| 796|{ 137| 796| char *s2; 138| | 139| 796| if ((s2 = strdup(s)) == NULL) ------------------ | Branch (139:6): [True: 0, False: 796] ------------------ 140| 0| flexfatal (_("memory allocation failure in xstrdup()")); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 141| | 142| 796| return s2; 143| 796|} line_directive_out: 250| 1.01k|{ 251| 1.01k| char *trace_fmt = "m4_ifdef([[M4_HOOK_TRACE_LINE_FORMAT]], [[M4_HOOK_TRACE_LINE_FORMAT([[%d]], [[%s]])]])"; 252| 1.01k| char directive[MAXLINE*2], filename[MAXLINE]; 253| 1.01k| char *s1, *s2, *s3; 254| | 255| 1.01k| if (!ctrl.gen_line_dirs) ------------------ | Branch (255:6): [True: 1.01k, False: 0] ------------------ 256| 1.01k| return; 257| | 258| 0| s1 = (path != NULL) ? path : "M4_YY_OUTFILE_NAME"; ------------------ | Branch (258:7): [True: 0, False: 0] ------------------ 259| | 260| 0| if ((path != NULL) && !s1) ------------------ | Branch (260:6): [True: 0, False: 0] | Branch (260:24): [True: 0, False: 0] ------------------ 261| 0| s1 = ""; 262| | 263| 0| s2 = filename; 264| 0| s3 = &filename[sizeof (filename) - 2]; 265| | 266| 0| while (s2 < s3 && *s1) { ------------------ | Branch (266:9): [True: 0, False: 0] | Branch (266:20): [True: 0, False: 0] ------------------ 267| 0| if (*s1 == '\\' || *s1 == '"') ------------------ | Branch (267:7): [True: 0, False: 0] | Branch (267:22): [True: 0, False: 0] ------------------ 268| | /* Escape the '\' or '"' */ 269| 0| *s2++ = '\\'; 270| | 271| 0| *s2++ = *s1++; 272| 0| } 273| | 274| 0| *s2 = '\0'; 275| | 276| 0| if (path != NULL) ------------------ | Branch (276:6): [True: 0, False: 0] ------------------ 277| 0| snprintf (directive, sizeof(directive), trace_fmt, linenum, filename); 278| 0| else { 279| 0| snprintf (directive, sizeof(directive), trace_fmt, 0, filename); 280| 0| } 281| | 282| | /* If output_file is nil then we should put the directive in 283| | * the accumulated actions. 284| | */ 285| 0| if (output_file) { ------------------ | Branch (285:6): [True: 0, False: 0] ------------------ 286| 0| fputs (directive, output_file); 287| 0| } 288| 0| else 289| 0| add_action (directive); 290| 0|} mark_defs1: 298| 1|{ 299| 1| defs1_offset = 0; 300| 1| action_array[action_index++] = '\0'; 301| 1| action_offset = prolog_offset = action_index; 302| 1| action_array[action_index] = '\0'; 303| 1|} mark_prolog: 310| 2|{ 311| 2| action_array[action_index++] = '\0'; 312| 2| action_offset = action_index; 313| 2| action_array[action_index] = '\0'; 314| 2|} myesc: 387| 2|{ 388| 2| unsigned char c, esc_char; 389| | 390| 2| switch (array[1]) { 391| 0| case 'b': ------------------ | Branch (391:2): [True: 0, False: 2] ------------------ 392| 0| return '\b'; 393| 0| case 'f': ------------------ | Branch (393:2): [True: 0, False: 2] ------------------ 394| 0| return '\f'; 395| 0| case 'n': ------------------ | Branch (395:2): [True: 0, False: 2] ------------------ 396| 0| return '\n'; 397| 0| case 'r': ------------------ | Branch (397:2): [True: 0, False: 2] ------------------ 398| 0| return '\r'; 399| 0| case 't': ------------------ | Branch (399:2): [True: 0, False: 2] ------------------ 400| 0| return '\t'; 401| 0| case 'a': ------------------ | Branch (401:2): [True: 0, False: 2] ------------------ 402| 0| return '\a'; 403| 0| case 'v': ------------------ | Branch (403:2): [True: 0, False: 2] ------------------ 404| 0| return '\v'; 405| 0| case '0': ------------------ | Branch (405:2): [True: 0, False: 2] ------------------ 406| 1| case '1': ------------------ | Branch (406:2): [True: 1, False: 1] ------------------ 407| 1| case '2': ------------------ | Branch (407:2): [True: 0, False: 2] ------------------ 408| 1| case '3': ------------------ | Branch (408:2): [True: 0, False: 2] ------------------ 409| 1| case '4': ------------------ | Branch (409:2): [True: 0, False: 2] ------------------ 410| 1| case '5': ------------------ | Branch (410:2): [True: 0, False: 2] ------------------ 411| 1| case '6': ------------------ | Branch (411:2): [True: 0, False: 2] ------------------ 412| 1| case '7': ------------------ | Branch (412:2): [True: 0, False: 2] ------------------ 413| 1| { /* \ */ 414| 1| int sptr = 1; 415| | 416| 4| while (sptr <= 3 && ------------------ | Branch (416:11): [True: 3, False: 1] ------------------ 417| 3| array[sptr] >= '0' && array[sptr] <= '7') { ------------------ | Branch (417:32): [True: 3, False: 0] | Branch (417:54): [True: 3, False: 0] ------------------ 418| 3| ++sptr; 419| 3| } 420| | 421| 1| c = array[sptr]; 422| 1| array[sptr] = '\0'; 423| | 424| 1| esc_char = (unsigned char) strtoul (array + 1, NULL, 8); 425| | 426| 1| array[sptr] = c; 427| | 428| 1| return esc_char; 429| 1| } 430| | 431| 0| case 'x': ------------------ | Branch (431:2): [True: 0, False: 2] ------------------ 432| 0| { /* \x */ 433| 0| int sptr = 2; 434| | 435| 0| while (sptr <= 3 && isxdigit (array[sptr])) { ------------------ | Branch (435:11): [True: 0, False: 0] | Branch (435:24): [True: 0, False: 0] ------------------ 436| | /* Don't increment inside loop control 437| | * because if isxdigit() is a macro it might 438| | * expand into multiple increments ... 439| | */ 440| 0| ++sptr; 441| 0| } 442| | 443| 0| c = array[sptr]; 444| 0| array[sptr] = '\0'; 445| | 446| 0| esc_char = (unsigned char) strtoul (array + 2, NULL, 16); 447| | 448| 0| array[sptr] = c; 449| | 450| 0| return esc_char; 451| 1| } 452| | 453| 1| default: ------------------ | Branch (453:2): [True: 1, False: 1] ------------------ 454| 1| return array[1]; 455| 2| } 456| 2|} reallocate_array: 564| 26.6k|{ 565| 26.6k| void *new_array; 566| |#ifdef HAVE_REALLOCARR 567| | new_array = array; 568| | if (reallocarr(&new_array, (size_t) size, element_size)) { 569| | flexfatal ((array) ? 570| | _("attempt to increase array size failed") : 571| | /* Function name is allocate_array() because of 572| | * compatibility (for translations): */ 573| | _("memory allocation failed in allocate_array()")); 574| | } 575| |#else 576| 26.6k|# ifdef HAVE_REALLOCARRAY 577| 26.6k| new_array = reallocarray(array, (size_t) size, element_size); 578| |# else 579| | /* Do manual overflow detection */ 580| | size_t num_bytes = (size_t) size * element_size; 581| | new_array = (size && SIZE_MAX / (size_t) size < element_size) ? NULL : 582| | realloc(array, num_bytes); 583| |# endif 584| 26.6k| if (!new_array) { ------------------ | Branch (584:6): [True: 0, False: 26.6k] ------------------ 585| 0| flexfatal ((array) ? ------------------ | Branch (585:14): [True: 0, False: 0] ------------------ 586| 0| _("attempt to increase array size failed") : ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 587| | /* Function name is allocate_array() because of 588| | * compatibility (for translations): */ 589| | _("memory allocation failed in allocate_array()")); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 590| 0| } 591| 26.6k|#endif 592| 26.6k| return new_array; 593| 26.6k|} add_accept: 51| 231|{ 52| | /* Hang the accepting number off an epsilon state. if it is associated 53| | * with a state that has a non-epsilon out-transition, then the state 54| | * will accept BEFORE it makes that transition, i.e., one character 55| | * too soon. 56| | */ 57| | 58| 231| if (transchar[finalst[mach]] == SYM_EPSILON) ------------------ | | 234| 231|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 231|#define CSIZE 256 | | ------------------ ------------------ | Branch (58:6): [True: 0, False: 231] ------------------ 59| 0| accptnum[finalst[mach]] = accepting_number; 60| | 61| 231| else { 62| 231| int astate = mkstate (SYM_EPSILON); ------------------ | | 234| 231|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 231|#define CSIZE 256 | | ------------------ ------------------ 63| | 64| 231| accptnum[astate] = accepting_number; 65| 231| (void) link_machines (mach, astate); 66| 231| } 67| 231|} finish_rule: 198| 231|{ 199| 231| char action_text[MAXLINE]; 200| | 201| 231| add_accept (mach, num_rules); 202| | 203| | /* We did this in new_rule(), but it often gets the wrong 204| | * number because we do it before we start parsing the current rule. 205| | */ 206| 231| rule_linenum[num_rules] = linenum; 207| | 208| | /* If this is a continued action, then the line-number has already 209| | * been updated, giving us the wrong number. 210| | */ 211| 231| if (continued_action) ------------------ | Branch (211:6): [True: 0, False: 231] ------------------ 212| 0| --rule_linenum[num_rules]; 213| | 214| | 215| | /* If the previous rule was continued action, then we inherit the 216| | * previous newline flag, possibly overriding the current one. 217| | */ 218| 231| if (pcont_act && rule_has_nl[num_rules - 1]) ------------------ | Branch (218:6): [True: 0, False: 231] | Branch (218:19): [True: 0, False: 0] ------------------ 219| 0| rule_has_nl[num_rules] = true; 220| | 221| 231| snprintf (action_text, sizeof(action_text), "M4_HOOK_NORMAL_STATE_CASE_ARM(%d)\n", num_rules); 222| 231| add_action (action_text); 223| 231| if (rule_has_nl[num_rules]) { ------------------ | Branch (223:6): [True: 0, False: 231] ------------------ 224| 0| snprintf (action_text, sizeof(action_text), "M4_HOOK_COMMENT_OPEN rule %d can match eol M4_HOOK_COMMENT_CLOSE\n", 225| 0| num_rules); 226| 0| add_action (action_text); 227| 0| } 228| | 229| | 230| 231| if (variable_trail_rule) { ------------------ | Branch (230:6): [True: 0, False: 231] ------------------ 231| 0| rule_type[num_rules] = RULE_VARIABLE; ------------------ | | 568| 0|#define RULE_VARIABLE 1 ------------------ 232| | 233| 0| if (env.performance_hint > 0) ------------------ | Branch (233:7): [True: 0, False: 0] ------------------ 234| 0| fprintf (stderr, 235| 0| _ ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 236| 0| ("Variable trailing context rule at line %d\n"), 237| 0| rule_linenum[num_rules]); 238| | 239| 0| variable_trailing_context_rules = true; 240| 0| } 241| | 242| 231| else { 243| 231| rule_type[num_rules] = RULE_NORMAL; ------------------ | | 567| 231|#define RULE_NORMAL 0 ------------------ 244| | 245| 231| if (headcnt > 0 || trailcnt > 0) { ------------------ | Branch (245:7): [True: 0, False: 231] | Branch (245:22): [True: 0, False: 231] ------------------ 246| | /* Do trailing context magic to not match the trailing 247| | * characters. 248| | */ 249| 0| add_action ("M4_HOOK_RELEASE_YYTEXT\n"); 250| | 251| 0| if (headcnt > 0) { ------------------ | Branch (251:8): [True: 0, False: 0] ------------------ 252| 0| if (rule_has_nl[num_rules]) { ------------------ | Branch (252:9): [True: 0, False: 0] ------------------ 253| 0| snprintf (action_text, sizeof(action_text), 254| 0| "M4_HOOK_LINE_FORWARD(%d)\n", headcnt); 255| 0| add_action (action_text); 256| 0| } 257| 0| snprintf (action_text, sizeof(action_text), "M4_HOOK_CHAR_FORWARD(%d)\n", 258| 0| headcnt); 259| 0| add_action (action_text); 260| 0| } 261| | 262| 0| else { 263| 0| if (rule_has_nl[num_rules]) { ------------------ | Branch (263:9): [True: 0, False: 0] ------------------ 264| 0| snprintf (action_text, sizeof(action_text), 265| 0| "M4_HOOK_LINE_REWIND(%d)\n", trailcnt); 266| 0| add_action (action_text); 267| 0| } 268| | 269| 0| snprintf (action_text, sizeof(action_text), "M4_HOOK_CHAR_REWIND(%d)\n", 270| 0| trailcnt); 271| 0| add_action (action_text); 272| 0| } 273| | 274| 0| add_action 275| 0| ("M4_HOOK_TAKE_YYTEXT\n"); 276| 0| } 277| 231| } 278| | 279| | /* Okay, in the action code at this point yytext and yyleng have 280| | * their proper final values for this rule, so here's the point 281| | * to do any user action. But don't do it for continued actions, 282| | * as that'll result in multiple rule-setup calls. 283| | */ 284| 231| if (!continued_action) ------------------ | Branch (284:6): [True: 231, False: 0] ------------------ 285| 231| add_action ("M4_HOOK_SET_RULE_SETUP\n"); 286| | 287| | line_directive_out(NULL, infilename, linenum); 288| 231| add_action("[["); 289| 231|} link_machines: 309| 231|{ 310| 231| if (first == NIL) ------------------ | | 192| 231|#define NIL 0 ------------------ | Branch (310:6): [True: 0, False: 231] ------------------ 311| 0| return last; 312| | 313| 231| else if (last == NIL) ------------------ | | 192| 231|#define NIL 0 ------------------ | Branch (313:11): [True: 0, False: 231] ------------------ 314| 0| return first; 315| | 316| 231| else { 317| 231| mkxtion (finalst[first], last); 318| 231| finalst[first] = finalst[last]; 319| 231| lastst[first] = MAX (lastst[first], lastst[last]); ------------------ | | 120| 231|#define MAX(x,y) ((x) > (y) ? (x) : (y)) | | ------------------ | | | Branch (120:19): [True: 0, False: 231] | | ------------------ ------------------ 320| 231| firstst[first] = MIN (firstst[first], firstst[last]); ------------------ | | 117| 231|#define MIN(x,y) ((x) < (y) ? (x) : (y)) | | ------------------ | | | Branch (117:19): [True: 231, False: 0] | | ------------------ ------------------ 321| | 322| 231| return first; 323| 231| } 324| 231|} mkbranch: 376| 231|{ 377| 231| int eps; 378| | 379| 231| if (first == NO_TRANSITION) ------------------ | | 195| 231|#define NO_TRANSITION NIL | | ------------------ | | | | 192| 231|#define NIL 0 | | ------------------ ------------------ | Branch (379:6): [True: 0, False: 231] ------------------ 380| 0| return second; 381| | 382| 231| else if (second == NO_TRANSITION) ------------------ | | 195| 231|#define NO_TRANSITION NIL | | ------------------ | | | | 192| 231|#define NIL 0 | | ------------------ ------------------ | Branch (382:11): [True: 0, False: 231] ------------------ 383| 0| return first; 384| | 385| 231| eps = mkstate (SYM_EPSILON); ------------------ | | 234| 231|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 231|#define CSIZE 256 | | ------------------ ------------------ 386| | 387| 231| mkxtion (eps, first); 388| 231| mkxtion (eps, second); 389| | 390| 231| return eps; 391| 231|} mkstate: 591| 2.24k|{ 592| 2.24k| if (++lastnfa >= current_mns) { ------------------ | Branch (592:6): [True: 0, False: 2.24k] ------------------ 593| 0| if ((current_mns += MNS_INCREMENT) >= maximum_mns) ------------------ | | 210| 0|#define MNS_INCREMENT 1000 /* amount to bump above by if it's not enough */ ------------------ | Branch (593:7): [True: 0, False: 0] ------------------ 594| 0| lerr(_ ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 595| 0| ("input rules are too complicated (>= %d NFA states)"), 596| 0|current_mns); 597| | 598| 0| ++num_reallocs; 599| | 600| 0| firstst = reallocate_integer_array (firstst, current_mns); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 601| 0| lastst = reallocate_integer_array (lastst, current_mns); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 602| 0| finalst = reallocate_integer_array (finalst, current_mns); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 603| 0| transchar = 604| 0| reallocate_integer_array (transchar, current_mns); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 605| 0| trans1 = reallocate_integer_array (trans1, current_mns); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 606| 0| trans2 = reallocate_integer_array (trans2, current_mns); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 607| 0| accptnum = 608| 0| reallocate_integer_array (accptnum, current_mns); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 609| 0| assoc_rule = 610| 0| reallocate_integer_array (assoc_rule, current_mns); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 611| 0| state_type = 612| 0| reallocate_integer_array (state_type, current_mns); ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 613| 0| } 614| | 615| 2.24k| firstst[lastnfa] = lastnfa; 616| 2.24k| finalst[lastnfa] = lastnfa; 617| 2.24k| lastst[lastnfa] = lastnfa; 618| 2.24k| transchar[lastnfa] = sym; 619| 2.24k| trans1[lastnfa] = NO_TRANSITION; ------------------ | | 195| 2.24k|#define NO_TRANSITION NIL | | ------------------ | | | | 192| 2.24k|#define NIL 0 | | ------------------ ------------------ 620| 2.24k| trans2[lastnfa] = NO_TRANSITION; ------------------ | | 195| 2.24k|#define NO_TRANSITION NIL | | ------------------ | | | | 192| 2.24k|#define NIL 0 | | ------------------ ------------------ 621| 2.24k| accptnum[lastnfa] = NIL; ------------------ | | 192| 2.24k|#define NIL 0 ------------------ 622| 2.24k| assoc_rule[lastnfa] = num_rules; 623| 2.24k| state_type[lastnfa] = current_state_type; 624| | 625| | /* Fix up equivalence classes base on this transition. Note that any 626| | * character which has its own transition gets its own equivalence 627| | * class. Thus only characters which are only in character classes 628| | * have a chance at being in the same equivalence class. E.g. "a|b" 629| | * puts 'a' and 'b' into two different equivalence classes. "[ab]" 630| | * puts them in the same equivalence class (barring other differences 631| | * elsewhere in the input). 632| | */ 633| | 634| 2.24k| if (sym < 0) { ------------------ | Branch (634:6): [True: 231, False: 2.01k] ------------------ 635| | /* We don't have to update the equivalence classes since 636| | * that was already done when the ccl was created for the 637| | * first time. 638| | */ 639| 231| } 640| | 641| 2.01k| else if (sym == SYM_EPSILON) ------------------ | | 234| 2.01k|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 2.01k|#define CSIZE 256 | | ------------------ ------------------ | Branch (641:11): [True: 2.01k, False: 0] ------------------ 642| 2.01k| ++numeps; 643| | 644| 0| else { 645| 0| check_char (sym); 646| | 647| 0| if (ctrl.useecs) ------------------ | Branch (647:7): [True: 0, False: 0] ------------------ 648| | /* Map NUL's to csize. */ 649| 0| mkechar (sym ? sym : ctrl.csize, nextecm, ecgroup); ------------------ | Branch (649:13): [True: 0, False: 0] ------------------ 650| 0| } 651| | 652| 2.24k| return lastnfa; 653| 2.24k|} mkxtion: 667| 693|{ 668| 693| if (trans1[statefrom] == NO_TRANSITION) ------------------ | | 195| 693|#define NO_TRANSITION NIL | | ------------------ | | | | 192| 693|#define NIL 0 | | ------------------ ------------------ | Branch (668:6): [True: 462, False: 231] ------------------ 669| 462| trans1[statefrom] = stateto; 670| | 671| 231| else if ((transchar[statefrom] != SYM_EPSILON) || ------------------ | | 234| 231|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 231|#define CSIZE 256 | | ------------------ ------------------ | Branch (671:11): [True: 0, False: 231] ------------------ 672| 231| (trans2[statefrom] != NO_TRANSITION)) ------------------ | | 195| 231|#define NO_TRANSITION NIL | | ------------------ | | | | 192| 231|#define NIL 0 | | ------------------ ------------------ | Branch (672:4): [True: 0, False: 231] ------------------ 673| 0| flexfatal (_("found too many transitions in mkxtion()")); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 674| | 675| 231| else { /* second out-transition for an epsilon state */ 676| 231| ++eps2; 677| 231| trans2[statefrom] = stateto; 678| 231| } 679| 693|} new_rule: 684| 231|{ 685| 231| if (++num_rules >= current_max_rules) { ------------------ | Branch (685:6): [True: 0, False: 231] ------------------ 686| 0| ++num_reallocs; 687| 0| current_max_rules += MAX_RULES_INCREMENT; ------------------ | | 207| 0|#define MAX_RULES_INCREMENT 100 ------------------ 688| 0| rule_type = reallocate_integer_array (rule_type, ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 689| 0| current_max_rules); 690| 0| rule_linenum = reallocate_integer_array (rule_linenum, ------------------ | | 728| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 691| 0| current_max_rules); 692| 0| rule_useful = reallocate_array(rule_useful, 693| 0| current_max_rules, sizeof(char)); 694| 0| rule_has_nl = reallocate_array(rule_has_nl, 695| 0| current_max_rules, sizeof(char)); 696| 0| } 697| | 698| 231| if (num_rules > MAX_RULE) ------------------ | | 186| 231|#define MAX_RULE (YY_TRAILING_MASK - 1) | | ------------------ | | | | 178| 231|#define YY_TRAILING_MASK 0x2000 | | ------------------ ------------------ | Branch (698:6): [True: 0, False: 231] ------------------ 699| 0| lerr (_("too many rules (> %d)!"), MAX_RULE); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ lerr (_("too many rules (> %d)!"), MAX_RULE); ------------------ | | 186| 0|#define MAX_RULE (YY_TRAILING_MASK - 1) | | ------------------ | | | | 178| 0|#define YY_TRAILING_MASK 0x2000 | | ------------------ ------------------ 700| | 701| 231| rule_linenum[num_rules] = linenum; 702| 231| rule_useful[num_rules] = false; 703| | rule_has_nl[num_rules] = false; 704| 231|} yyparse: 1383| 778|{ 1384| 778| yy_state_fast_t yystate; 1385| | /* Number of tokens to shift before error messages enabled. */ 1386| 778| int yyerrstatus; 1387| | 1388| | /* The stacks and their tools: 1389| | 'yyss': related to states. 1390| | 'yyvs': related to semantic values. 1391| | 1392| | Refer to the stacks through separate pointers, to allow yyoverflow 1393| | to reallocate them elsewhere. */ 1394| | 1395| | /* The state stack. */ 1396| 778| yy_state_t yyssa[YYINITDEPTH]; 1397| 778| yy_state_t *yyss; 1398| 778| yy_state_t *yyssp; 1399| | 1400| | /* The semantic value stack. */ 1401| 778| YYSTYPE yyvsa[YYINITDEPTH]; ------------------ | | 151| 778|#define YYSTYPE int ------------------ 1402| 778| YYSTYPE *yyvs; ------------------ | | 151| 778|#define YYSTYPE int ------------------ 1403| 778| YYSTYPE *yyvsp; ------------------ | | 151| 778|#define YYSTYPE int ------------------ 1404| | 1405| 778| YYPTRDIFF_T yystacksize; ------------------ | | 391| 778|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1406| | 1407| 778| int yyn; 1408| 778| int yyresult; 1409| | /* Lookahead token as an internal (translated) token number. */ 1410| 778| int yytoken = 0; 1411| | /* The variables used to return semantic value and location from the 1412| | action routines. */ 1413| 778| YYSTYPE yyval; ------------------ | | 151| 778|#define YYSTYPE int ------------------ 1414| | 1415| |#if YYERROR_VERBOSE 1416| | /* Buffer for error messages, and its allocated size. */ 1417| | char yymsgbuf[128]; 1418| | char *yymsg = yymsgbuf; 1419| | YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; 1420| |#endif 1421| | 1422| 778|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1423| | 1424| | /* The number of symbols on the RHS of the reduced rule. 1425| | Keep to zero when no symbol should be popped. */ 1426| 778| int yylen = 0; 1427| | 1428| 778| yyssp = yyss = yyssa; 1429| 778| yyvsp = yyvs = yyvsa; 1430| 778| yystacksize = YYINITDEPTH; ------------------ | | 1101| 778|# define YYINITDEPTH 200 ------------------ 1431| | 1432| 778| YYDPRINTF ((stderr, "Starting parse\n")); 1433| | 1434| 778| yystate = 0; 1435| 778| yyerrstatus = 0; 1436| 778| yynerrs = 0; 1437| 778| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 934| 778|#define YYEMPTY (-2) ------------------ 1438| 778| goto yysetstate; 1439| | 1440| | 1441| |/*------------------------------------------------------------. 1442| || yynewstate -- push a new state, which is found in yystate. | 1443| |`------------------------------------------------------------*/ 1444| 6.12k|yynewstate: 1445| | /* In all cases, when you get here, the value and location stacks 1446| | have just been pushed. So pushing a state here evens the stacks. */ 1447| 6.12k| yyssp++; 1448| | 1449| | 1450| |/*--------------------------------------------------------------------. 1451| || yysetstate -- set current state (the top of the stack) to yystate. | 1452| |`--------------------------------------------------------------------*/ 1453| 6.90k|yysetstate: 1454| 6.90k| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1455| 6.90k| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 499| 6.90k|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (499:31): [Folded, False: 6.90k] | | | Branch (499:37): [True: 0, False: 0] | | | Branch (499:37): [True: 0, False: 0] | | ------------------ ------------------ 1456| 6.90k| YY_IGNORE_USELESS_CAST_BEGIN 1457| 6.90k| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 161| 6.90k|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1458| 6.90k| YY_IGNORE_USELESS_CAST_END 1459| | 1460| 6.90k| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1460:7): [True: 0, False: 6.90k] ------------------ 1461| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1462| | goto yyexhaustedlab; 1463| |#else 1464| 0| { 1465| | /* Get the current used size of the three stacks, in elements. */ 1466| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 391| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1467| | 1468| |# if defined yyoverflow 1469| | { 1470| | /* Give user a chance to reallocate the stack. Use copies of 1471| | these so that the &'s don't force the real ones into 1472| | memory. */ 1473| | yy_state_t *yyss1 = yyss; 1474| | YYSTYPE *yyvs1 = yyvs; 1475| | 1476| | /* Each stack pointer address is followed by the size of the 1477| | data in use in that stack, in bytes. This used to be a 1478| | conditional around just the two extra args, but that might 1479| | be undefined if yyoverflow is a macro. */ 1480| | yyoverflow (YY_("memory exhausted"), 1481| | &yyss1, yysize * YYSIZEOF (*yyssp), 1482| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1483| | &yystacksize); 1484| | yyss = yyss1; 1485| | yyvs = yyvs1; 1486| | } 1487| |# else /* defined YYSTACK_RELOCATE */ 1488| | /* Extend the stack our own way. */ 1489| 0| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1112| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1489:11): [True: 0, False: 0] ------------------ 1490| 0| goto yyexhaustedlab; 1491| 0| yystacksize *= 2; 1492| 0| if (YYMAXDEPTH < yystacksize) ------------------ | | 1112| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1492:11): [True: 0, False: 0] ------------------ 1493| 0| yystacksize = YYMAXDEPTH; ------------------ | | 1112| 0|# define YYMAXDEPTH 10000 ------------------ 1494| | 1495| 0| { 1496| 0| yy_state_t *yyss1 = yyss; 1497| 0| union yyalloc *yyptr = 1498| 0| YY_CAST (union yyalloc *, ------------------ | | 161| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1499| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1500| 0| if (! yyptr) ------------------ | Branch (1500:13): [True: 0, False: 0] ------------------ 1501| 0| goto yyexhaustedlab; 1502| 0| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 597| 0| do \ | | 598| 0| { \ | | 599| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 391| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 600| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 615| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 161| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 601| 0| Stack = &yyptr->Stack_alloc; \ | | 602| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 424| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 161| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 581| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 424| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 161| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 603| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 424| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 161| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 604| 0| } \ | | 605| 0| while (0) | | ------------------ | | | Branch (605:12): [Folded, False: 0] | | ------------------ ------------------ 1503| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 597| 0| do \ | | 598| 0| { \ | | 599| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 391| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 600| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 615| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 161| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 601| 0| Stack = &yyptr->Stack_alloc; \ | | 602| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 424| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 161| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 581| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 424| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 161| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 603| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 424| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 161| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 604| 0| } \ | | 605| 0| while (0) | | ------------------ | | | Branch (605:12): [Folded, False: 0] | | ------------------ ------------------ 1504| 0|# undef YYSTACK_RELOCATE 1505| 0| if (yyss1 != yyssa) ------------------ | Branch (1505:13): [True: 0, False: 0] ------------------ 1506| 0| YYSTACK_FREE (yyss1); ------------------ | | 541| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 560| 0|# define YYFREE free | | ------------------ ------------------ 1507| 0| } 1508| 0|# endif 1509| | 1510| 0| yyssp = yyss + yysize - 1; 1511| 0| yyvsp = yyvs + yysize - 1; 1512| | 1513| 0| YY_IGNORE_USELESS_CAST_BEGIN 1514| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n", 1515| 0| YY_CAST (long, yystacksize))); 1516| 0| YY_IGNORE_USELESS_CAST_END 1517| | 1518| 0| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1518:11): [True: 0, False: 0] ------------------ 1519| 0| YYABORT; ------------------ | | 938| 0|#define YYABORT goto yyabortlab ------------------ 1520| 0| } 1521| 6.90k|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1522| | 1523| 6.90k| if (yystate == YYFINAL) ------------------ | | 630| 6.90k|#define YYFINAL 3 ------------------ | Branch (1523:7): [True: 231, False: 6.67k] ------------------ 1524| 231| YYACCEPT; ------------------ | | 937| 231|#define YYACCEPT goto yyacceptlab ------------------ 1525| | 1526| 6.67k| goto yybackup; 1527| | 1528| | 1529| |/*-----------. 1530| || yybackup. | 1531| |`-----------*/ 1532| 6.67k|yybackup: 1533| | /* Do appropriate processing given the current state. Read a 1534| | lookahead token if we need one and don't already have one. */ 1535| | 1536| | /* First try to decide what to do without reference to lookahead token. */ 1537| 6.67k| yyn = yypact[yystate]; 1538| 6.67k| if (yypact_value_is_default (yyn)) ------------------ | | 755| 6.67k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 752| 6.67k|#define YYPACT_NINF (-88) | | ------------------ | | | Branch (755:3): [True: 3.35k, False: 3.32k] | | ------------------ ------------------ 1539| 3.35k| goto yydefault; 1540| | 1541| | /* Not known => get a lookahead token if don't already have one. */ 1542| | 1543| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1544| 3.32k| if (yychar == YYEMPTY) ------------------ | | 934| 3.32k|#define YYEMPTY (-2) ------------------ | Branch (1544:7): [True: 2.31k, False: 1.00k] ------------------ 1545| 2.31k| { 1546| 2.31k| YYDPRINTF ((stderr, "Reading a token: ")); 1547| 2.31k| yychar = yylex (); 1548| 2.31k| } 1549| | 1550| 3.32k| if (yychar <= YYEOF) ------------------ | | 935| 3.32k|#define YYEOF 0 ------------------ | Branch (1550:7): [True: 1.55k, False: 1.76k] ------------------ 1551| 1.55k| { 1552| 1.55k| yychar = yytoken = YYEOF; ------------------ | | 935| 1.55k|#define YYEOF 0 ------------------ 1553| 1.55k| YYDPRINTF ((stderr, "Now at end of input.\n")); 1554| 1.55k| } 1555| 1.76k| else 1556| 1.76k| { 1557| 1.76k| yytoken = YYTRANSLATE (yychar); ------------------ | | 650| 1.76k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 644| 1.76k|#define YYMAXUTOK 311 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 643| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (650:4): [True: 1.76k, False: 0] | | | Branch (650:18): [True: 1.76k, False: 0] | | ------------------ ------------------ 1558| 1.76k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1559| 1.76k| } 1560| | 1561| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1562| | detect an error, take that action. */ 1563| 3.32k| yyn += yytoken; 1564| 3.32k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 632| 3.32k|#define YYLAST 193 ------------------ | Branch (1564:7): [True: 0, False: 3.32k] | Branch (1564:18): [True: 60, False: 3.26k] | Branch (1564:34): [True: 2.36k, False: 894] ------------------ 1565| 2.42k| goto yydefault; 1566| 894| yyn = yytable[yyn]; 1567| 894| if (yyn <= 0) ------------------ | Branch (1567:7): [True: 432, False: 462] ------------------ 1568| 432| { 1569| 432| if (yytable_value_is_error (yyn)) ------------------ | | 760| 432| 0 | | ------------------ | | | Branch (760:3): [Folded, False: 432] | | ------------------ ------------------ 1570| 0| goto yyerrlab; 1571| 432| yyn = -yyn; 1572| 432| goto yyreduce; 1573| 432| } 1574| | 1575| | /* Count tokens shifted since error; after three, turn off error 1576| | status. */ 1577| 462| if (yyerrstatus) ------------------ | Branch (1577:7): [True: 60, False: 402] ------------------ 1578| 60| yyerrstatus--; 1579| | 1580| | /* Shift the lookahead token. */ 1581| 462| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1582| 462| yystate = yyn; 1583| 462| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1584| 462| *++yyvsp = yylval; 1585| 462| YY_IGNORE_MAYBE_UNINITIALIZED_END 1586| | 1587| | /* Discard the shifted token. */ 1588| 462| yychar = YYEMPTY; ------------------ | | 934| 462|#define YYEMPTY (-2) ------------------ 1589| 462| goto yynewstate; 1590| | 1591| | 1592| |/*-----------------------------------------------------------. 1593| || yydefault -- do the default action for the current state. | 1594| |`-----------------------------------------------------------*/ 1595| 5.78k|yydefault: 1596| 5.78k| yyn = yydefact[yystate]; 1597| 5.78k| if (yyn == 0) ------------------ | Branch (1597:7): [True: 2.42k, False: 3.35k] ------------------ 1598| 2.42k| goto yyerrlab; 1599| 3.35k| goto yyreduce; 1600| | 1601| | 1602| |/*-----------------------------. 1603| || yyreduce -- do a reduction. | 1604| |`-----------------------------*/ 1605| 3.78k|yyreduce: 1606| | /* yyn is the number of a rule to reduce with. */ 1607| 3.78k| yylen = yyr2[yyn]; 1608| | 1609| | /* If YYLEN is nonzero, implement the default value of the action: 1610| | '$$ = $1'. 1611| | 1612| | Otherwise, the following line sets YYVAL to garbage. 1613| | This behavior is undocumented and Bison 1614| | users should not rely upon it. Assigning to YYVAL 1615| | unconditionally makes the parser a bit smaller, and it avoids a 1616| | GCC warning that YYVAL may be used uninitialized. */ 1617| 3.78k| yyval = yyvsp[1-yylen]; 1618| | 1619| | 1620| 3.78k| YY_REDUCE_PRINT (yyn); 1621| 3.78k| switch (yyn) 1622| 3.78k| { 1623| 231| case 2: ------------------ | Branch (1623:3): [True: 231, False: 3.55k] ------------------ 1624| 231|#line 122 "parse.y" 1625| 231| { /* add default rule */ 1626| 231| int def_rule; 1627| | 1628| 231| pat = cclinit(); 1629| 231| cclnegate( pat ); 1630| | 1631| 231| def_rule = mkstate( -pat ); 1632| | 1633| | /* Remember the number of the default rule so we 1634| | * don't generate "can't match" warnings for it. 1635| | */ 1636| 231| default_rule = num_rules; 1637| | 1638| 231| finish_rule( def_rule, false, 0, 0, 0); 1639| | 1640| 462| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1640:17): [True: 231, False: 231] ------------------ 1641| 231| scset[i] = mkbranch( scset[i], def_rule ); 1642| | 1643| 231| add_action("]]"); 1644| | 1645| 231| if ( ctrl.spprdflt ) ------------------ | Branch (1645:9): [True: 0, False: 231] ------------------ 1646| 0| add_action( 1647| 0| "M4_HOOK_FATAL_ERROR(\"flex scanner jammed\")"); 1648| 231| else { 1649| 231| add_action("M4_HOOK_ECHO"); 1650| 231| } 1651| | 1652| 231| add_action( "\n\tM4_HOOK_STATE_CASE_BREAK\n" ); 1653| 231| } 1654| 231|#line 1655 "parse.c" 1655| 231| break; 1656| | 1657| 778| case 3: ------------------ | Branch (1657:3): [True: 778, False: 3.00k] ------------------ 1658| 778|#line 154 "parse.y" 1659| 778| { /* initialize for processing rules */ 1660| | 1661| | /* Create default DFA start condition. */ 1662| 778| scinstal( "INITIAL", false ); 1663| 778| } 1664| 778|#line 1665 "parse.c" 1665| 778| break; 1666| | 1667| 1.88k| case 7: ------------------ | Branch (1667:3): [True: 1.88k, False: 1.90k] ------------------ 1668| 1.88k|#line 165 "parse.y" 1669| 1.88k| { synerr( _("unknown error processing section 1") ); } ------------------ | | 100| 1.88k|#define _(String) gettext (String) ------------------ 1670| 1.88k|#line 1671 "parse.c" 1671| 1.88k| break; 1672| | 1673| 231| case 8: ------------------ | Branch (1673:3): [True: 231, False: 3.55k] ------------------ 1674| 231|#line 169 "parse.y" 1675| 231| { 1676| 231| check_options(); 1677| 231| scon_stk = allocate_integer_array( lastsc + 1 ); ------------------ | | 725| 231| allocate_array(size, sizeof(int)) ------------------ 1678| 231| scon_stk_ptr = 0; 1679| 231| } 1680| 231|#line 1681 "parse.c" 1681| 231| break; 1682| | 1683| 0| case 9: ------------------ | Branch (1683:3): [True: 0, False: 3.78k] ------------------ 1684| 0|#line 177 "parse.y" 1685| 0| { sc_is_exclusive = false; } 1686| 0|#line 1687 "parse.c" 1687| 0| break; 1688| | 1689| 0| case 10: ------------------ | Branch (1689:3): [True: 0, False: 3.78k] ------------------ 1690| 0|#line 180 "parse.y" 1691| 0| { sc_is_exclusive = true; } 1692| 0|#line 1693 "parse.c" 1693| 0| break; 1694| | 1695| 0| case 11: ------------------ | Branch (1695:3): [True: 0, False: 3.78k] ------------------ 1696| 0|#line 184 "parse.y" 1697| 0| { scinstal( nmstr, sc_is_exclusive ); } 1698| 0|#line 1699 "parse.c" 1699| 0| break; 1700| | 1701| 0| case 12: ------------------ | Branch (1701:3): [True: 0, False: 3.78k] ------------------ 1702| 0|#line 187 "parse.y" 1703| 0| { scinstal( nmstr, sc_is_exclusive ); } 1704| 0|#line 1705 "parse.c" 1705| 0| break; 1706| | 1707| 0| case 13: ------------------ | Branch (1707:3): [True: 0, False: 3.78k] ------------------ 1708| 0|#line 190 "parse.y" 1709| 0| { synerr( _("bad start condition list") ); } ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 1710| 0|#line 1711 "parse.c" 1711| 0| break; 1712| | 1713| 0| case 17: ------------------ | Branch (1713:3): [True: 0, False: 3.78k] ------------------ 1714| 0|#line 201 "parse.y" 1715| 0| { 1716| 0| env.outfilename = xstrdup(nmstr); 1717| 0| env.did_outfilename = 1; 1718| 0| } 1719| 0|#line 1720 "parse.c" 1720| 0| break; 1721| | 1722| 0| case 18: ------------------ | Branch (1722:3): [True: 0, False: 3.78k] ------------------ 1723| 0|#line 206 "parse.y" 1724| 0| { extra_type = xstrdup(nmstr); } 1725| 0|#line 1726 "parse.c" 1726| 0| break; 1727| | 1728| 0| case 19: ------------------ | Branch (1728:3): [True: 0, False: 3.78k] ------------------ 1729| 0|#line 208 "parse.y" 1730| 0| { ctrl.prefix = xstrdup(nmstr); 1731| 0| if (strchr(ctrl.prefix, '[') || strchr(ctrl.prefix, ']')) ------------------ | Branch (1731:31): [True: 0, False: 0] | Branch (1731:59): [True: 0, False: 0] ------------------ 1732| 0| flexerror(_("Prefix must not contain [ or ]")); } ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 1733| 0|#line 1734 "parse.c" 1734| 0| break; 1735| | 1736| 0| case 20: ------------------ | Branch (1736:3): [True: 0, False: 3.78k] ------------------ 1737| 0|#line 212 "parse.y" 1738| 0| { ctrl.yyclass = xstrdup(nmstr); } 1739| 0|#line 1740 "parse.c" 1740| 0| break; 1741| | 1742| 0| case 21: ------------------ | Branch (1742:3): [True: 0, False: 3.78k] ------------------ 1743| 0|#line 214 "parse.y" 1744| 0| { env.headerfilename = xstrdup(nmstr); } 1745| 0|#line 1746 "parse.c" 1746| 0| break; 1747| | 1748| 0| case 22: ------------------ | Branch (1748:3): [True: 0, False: 3.78k] ------------------ 1749| 0|#line 216 "parse.y" 1750| 0| { ctrl.yylmax = nmval; } 1751| 0|#line 1752 "parse.c" 1752| 0| break; 1753| | 1754| 0| case 23: ------------------ | Branch (1754:3): [True: 0, False: 3.78k] ------------------ 1755| 0|#line 218 "parse.y" 1756| 0| { ctrl.yydecl = xstrdup(nmstr); } 1757| 0|#line 1758 "parse.c" 1758| 0| break; 1759| | 1760| 0| case 24: ------------------ | Branch (1760:3): [True: 0, False: 3.78k] ------------------ 1761| 0|#line 220 "parse.y" 1762| 0| { ctrl.preaction = xstrdup(nmstr); } 1763| 0|#line 1764 "parse.c" 1764| 0| break; 1765| | 1766| 0| case 25: ------------------ | Branch (1766:3): [True: 0, False: 3.78k] ------------------ 1767| 0|#line 222 "parse.y" 1768| 0| { ctrl.postaction = xstrdup(nmstr); } 1769| 0|#line 1770 "parse.c" 1770| 0| break; 1771| | 1772| 0| case 26: ------------------ | Branch (1772:3): [True: 0, False: 3.78k] ------------------ 1773| 0|#line 224 "parse.y" 1774| 0| { ctrl.bufsize = nmval; } 1775| 0|#line 1776 "parse.c" 1776| 0| break; 1777| | 1778| 0| case 27: ------------------ | Branch (1778:3): [True: 0, False: 3.78k] ------------------ 1779| 0|#line 226 "parse.y" 1780| 0| { ctrl.emit = xstrdup(nmstr); backend_by_name(ctrl.emit); } 1781| 0|#line 1782 "parse.c" 1782| 0| break; 1783| | 1784| 0| case 28: ------------------ | Branch (1784:3): [True: 0, False: 3.78k] ------------------ 1785| 0|#line 228 "parse.y" 1786| 0| { ctrl.userinit = xstrdup(nmstr); } 1787| 0|#line 1788 "parse.c" 1788| 0| break; 1789| | 1790| 0| case 29: ------------------ | Branch (1790:3): [True: 0, False: 3.78k] ------------------ 1791| 0|#line 230 "parse.y" 1792| 0| { ctrl.yyterminate = xstrdup(nmstr); } 1793| 0|#line 1794 "parse.c" 1794| 0| break; 1795| | 1796| 0| case 30: ------------------ | Branch (1796:3): [True: 0, False: 3.78k] ------------------ 1797| 0|#line 232 "parse.y" 1798| 0| { tablesext = true; tablesfilename = xstrdup(nmstr); } 1799| 0|#line 1800 "parse.c" 1800| 0| break; 1801| | 1802| 0| case 31: ------------------ | Branch (1802:3): [True: 0, False: 3.78k] ------------------ 1803| 0|#line 236 "parse.y" 1804| 0| { scon_stk_ptr = yyvsp[-3]; } 1805| 0|#line 1806 "parse.c" 1806| 0| break; 1807| | 1808| 0| case 32: ------------------ | Branch (1808:3): [True: 0, False: 3.78k] ------------------ 1809| 0|#line 238 "parse.y" 1810| 0| { scon_stk_ptr = yyvsp[-3]; } 1811| 0|#line 1812 "parse.c" 1812| 0| break; 1813| | 1814| 231| case 34: ------------------ | Branch (1814:3): [True: 231, False: 3.55k] ------------------ 1815| 231|#line 243 "parse.y" 1816| 231| { 1817| | /* Initialize for a parse of one rule. */ 1818| 231| trlcontxt = variable_trail_rule = varlength = false; 1819| 231| trailcnt = headcnt = rulelen = 0; 1820| 231| current_state_type = STATE_NORMAL; ------------------ | | 559| 231|#define STATE_NORMAL 0x1 ------------------ 1821| 231| previous_continued_action = continued_action; 1822| 231| in_rule = true; 1823| | 1824| 231| new_rule(); 1825| 231| } 1826| 231|#line 1827 "parse.c" 1827| 231| break; 1828| | 1829| 0| case 35: ------------------ | Branch (1829:3): [True: 0, False: 3.78k] ------------------ 1830| 0|#line 256 "parse.y" 1831| 0| { 1832| 0| pat = yyvsp[0]; 1833| 0| finish_rule( pat, variable_trail_rule, 1834| 0| headcnt, trailcnt , previous_continued_action); 1835| | 1836| 0| if ( scon_stk_ptr > 0 ) ------------------ | Branch (1836:9): [True: 0, False: 0] ------------------ 1837| 0| { 1838| 0| for ( i = 1; i <= scon_stk_ptr; ++i ) ------------------ | Branch (1838:18): [True: 0, False: 0] ------------------ 1839| 0| scbol[scon_stk[i]] = 1840| 0| mkbranch( scbol[scon_stk[i]], 1841| 0| pat ); 1842| 0| } 1843| | 1844| 0| else 1845| 0| { 1846| | /* Add to all non-exclusive start conditions, 1847| | * including the default (0) start condition. 1848| | */ 1849| | 1850| 0| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1850:18): [True: 0, False: 0] ------------------ 1851| 0| if ( ! scxclu[i] ) ------------------ | Branch (1851:11): [True: 0, False: 0] ------------------ 1852| 0| scbol[i] = mkbranch( scbol[i], 1853| 0| pat ); 1854| 0| } 1855| | 1856| 0| if ( ! bol_needed ) ------------------ | Branch (1856:9): [True: 0, False: 0] ------------------ 1857| 0| { 1858| 0| bol_needed = true; 1859| | 1860| 0| if ( env.performance_hint > 1 ) ------------------ | Branch (1860:10): [True: 0, False: 0] ------------------ 1861| 0| pinpoint_message( 1862| 0| "'^' operator results in sub-optimal performance" ); 1863| 0| } 1864| 0| } 1865| 0|#line 1866 "parse.c" 1866| 0| break; 1867| | 1868| 0| case 36: ------------------ | Branch (1868:3): [True: 0, False: 3.78k] ------------------ 1869| 0|#line 292 "parse.y" 1870| 0| { 1871| 0| pat = yyvsp[0]; 1872| 0| finish_rule( pat, variable_trail_rule, 1873| 0| headcnt, trailcnt , previous_continued_action); 1874| | 1875| 0| if ( scon_stk_ptr > 0 ) ------------------ | Branch (1875:9): [True: 0, False: 0] ------------------ 1876| 0| { 1877| 0| for ( i = 1; i <= scon_stk_ptr; ++i ) ------------------ | Branch (1877:18): [True: 0, False: 0] ------------------ 1878| 0| scset[scon_stk[i]] = 1879| 0| mkbranch( scset[scon_stk[i]], 1880| 0| pat ); 1881| 0| } 1882| | 1883| 0| else 1884| 0| { 1885| 0| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1885:18): [True: 0, False: 0] ------------------ 1886| 0| if ( ! scxclu[i] ) ------------------ | Branch (1886:11): [True: 0, False: 0] ------------------ 1887| 0| scset[i] = 1888| 0| mkbranch( scset[i], 1889| 0| pat ); 1890| 0| } 1891| 0| } 1892| 0|#line 1893 "parse.c" 1893| 0| break; 1894| | 1895| 0| case 37: ------------------ | Branch (1895:3): [True: 0, False: 3.78k] ------------------ 1896| 0|#line 316 "parse.y" 1897| 0| { 1898| 0| if ( scon_stk_ptr > 0 ) ------------------ | Branch (1898:9): [True: 0, False: 0] ------------------ 1899| 0| build_eof_action(); 1900| | 1901| 0| else 1902| 0| { 1903| | /* This EOF applies to all start conditions 1904| | * which don't already have EOF actions. 1905| | */ 1906| 0| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1906:18): [True: 0, False: 0] ------------------ 1907| 0| if ( ! sceof[i] ) ------------------ | Branch (1907:11): [True: 0, False: 0] ------------------ 1908| 0| scon_stk[++scon_stk_ptr] = i; 1909| | 1910| 0| if ( scon_stk_ptr == 0 ) ------------------ | Branch (1910:10): [True: 0, False: 0] ------------------ 1911| 0| lwarn( 1912| 0| "all start conditions already have <> rules" ); 1913| | 1914| 0| else 1915| 0| build_eof_action(); 1916| 0| } 1917| 0| } 1918| 0|#line 1919 "parse.c" 1919| 0| break; 1920| | 1921| 0| case 38: ------------------ | Branch (1921:3): [True: 0, False: 3.78k] ------------------ 1922| 0|#line 339 "parse.y" 1923| 0| { synerr( _("unrecognized rule") ); } ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 1924| 0|#line 1925 "parse.c" 1925| 0| break; 1926| | 1927| 0| case 39: ------------------ | Branch (1927:3): [True: 0, False: 3.78k] ------------------ 1928| 0|#line 343 "parse.y" 1929| 0| { yyval = scon_stk_ptr; } 1930| 0|#line 1931 "parse.c" 1931| 0| break; 1932| | 1933| 0| case 40: ------------------ | Branch (1933:3): [True: 0, False: 3.78k] ------------------ 1934| 0|#line 347 "parse.y" 1935| 0| { yyval = yyvsp[-2]; } 1936| 0|#line 1937 "parse.c" 1937| 0| break; 1938| | 1939| 0| case 41: ------------------ | Branch (1939:3): [True: 0, False: 3.78k] ------------------ 1940| 0|#line 350 "parse.y" 1941| 0| { 1942| 0| yyval = scon_stk_ptr; 1943| | 1944| 0| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1944:17): [True: 0, False: 0] ------------------ 1945| 0| { 1946| 0| int j; 1947| | 1948| 0| for ( j = 1; j <= scon_stk_ptr; ++j ) ------------------ | Branch (1948:18): [True: 0, False: 0] ------------------ 1949| 0| if ( scon_stk[j] == i ) ------------------ | Branch (1949:11): [True: 0, False: 0] ------------------ 1950| 0| break; 1951| | 1952| 0| if ( j > scon_stk_ptr ) ------------------ | Branch (1952:10): [True: 0, False: 0] ------------------ 1953| 0| scon_stk[++scon_stk_ptr] = i; 1954| 0| } 1955| 0| } 1956| 0|#line 1957 "parse.c" 1957| 0| break; 1958| | 1959| 0| case 42: ------------------ | Branch (1959:3): [True: 0, False: 3.78k] ------------------ 1960| 0|#line 367 "parse.y" 1961| 0| { yyval = scon_stk_ptr; } 1962| 0|#line 1963 "parse.c" 1963| 0| break; 1964| | 1965| 0| case 45: ------------------ | Branch (1965:3): [True: 0, False: 3.78k] ------------------ 1966| 0|#line 375 "parse.y" 1967| 0| { synerr( _("bad start condition list") ); } ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 1968| 0|#line 1969 "parse.c" 1969| 0| break; 1970| | 1971| 0| case 46: ------------------ | Branch (1971:3): [True: 0, False: 3.78k] ------------------ 1972| 0|#line 379 "parse.y" 1973| 0| { 1974| 0| if ( (scnum = sclookup( nmstr )) == 0 ) ------------------ | Branch (1974:9): [True: 0, False: 0] ------------------ 1975| 0| format_pinpoint_message( 1976| 0| "undeclared start condition %s", 1977| 0| nmstr ); 1978| 0| else 1979| 0| { 1980| 0| for ( i = 1; i <= scon_stk_ptr; ++i ) ------------------ | Branch (1980:18): [True: 0, False: 0] ------------------ 1981| 0| if ( scon_stk[i] == scnum ) ------------------ | Branch (1981:11): [True: 0, False: 0] ------------------ 1982| 0| { 1983| 0| format_warn( 1984| 0| "<%s> specified twice", 1985| 0| scname[scnum] ); 1986| 0| break; 1987| 0| } 1988| | 1989| 0| if ( i > scon_stk_ptr ) ------------------ | Branch (1989:10): [True: 0, False: 0] ------------------ 1990| 0| scon_stk[++scon_stk_ptr] = scnum; 1991| 0| } 1992| 0| } 1993| 0|#line 1994 "parse.c" 1994| 0| break; 1995| | 1996| 0| case 47: ------------------ | Branch (1996:3): [True: 0, False: 3.78k] ------------------ 1997| 0|#line 402 "parse.y" 1998| 0| { 1999| 0| if ( transchar[lastst[yyvsp[0]]] != SYM_EPSILON ) ------------------ | | 234| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 0|#define CSIZE 256 | | ------------------ ------------------ | Branch (1999:9): [True: 0, False: 0] ------------------ 2000| | /* Provide final transition \now/ so it 2001| | * will be marked as a trailing context 2002| | * state. 2003| | */ 2004| 0| yyvsp[0] = link_machines( yyvsp[0], 2005| 0| mkstate( SYM_EPSILON ) ); ------------------ | | 234| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 0|#define CSIZE 256 | | ------------------ ------------------ 2006| | 2007| 0| mark_beginning_as_normal( yyvsp[0] ); 2008| 0| current_state_type = STATE_NORMAL; ------------------ | | 559| 0|#define STATE_NORMAL 0x1 ------------------ 2009| | 2010| 0| if ( previous_continued_action ) ------------------ | Branch (2010:9): [True: 0, False: 0] ------------------ 2011| 0| { 2012| | /* We need to treat this as variable trailing 2013| | * context so that the backup does not happen 2014| | * in the action but before the action switch 2015| | * statement. If the backup happens in the 2016| | * action, then the rules "falling into" this 2017| | * one's action will *also* do the backup, 2018| | * erroneously. 2019| | */ 2020| 0| if ( ! varlength || headcnt != 0 ) ------------------ | Branch (2020:10): [True: 0, False: 0] | Branch (2020:25): [True: 0, False: 0] ------------------ 2021| 0| lwarn( 2022| 0| "trailing context made variable due to preceding '|' action" ); 2023| | 2024| | /* Mark as variable. */ 2025| 0| varlength = true; 2026| 0| headcnt = 0; 2027| | 2028| 0| } 2029| | 2030| 0| if ( ctrl.lex_compat || (varlength && headcnt == 0) ) ------------------ | Branch (2030:9): [True: 0, False: 0] | Branch (2030:29): [True: 0, False: 0] | Branch (2030:42): [True: 0, False: 0] ------------------ 2031| 0| { /* variable trailing context rule */ 2032| | /* Mark the first part of the rule as the 2033| | * accepting "head" part of a trailing 2034| | * context rule. 2035| | * 2036| | * By the way, we didn't do this at the 2037| | * beginning of this production because back 2038| | * then current_state_type was set up for a 2039| | * trail rule, and add_accept() can create 2040| | * a new state ... 2041| | */ 2042| 0| add_accept( yyvsp[-1], 2043| 0| num_rules | YY_TRAILING_HEAD_MASK ); ------------------ | | 183| 0|#define YY_TRAILING_HEAD_MASK 0x4000 ------------------ 2044| 0| variable_trail_rule = true; 2045| 0| } 2046| | 2047| 0| else 2048| 0| trailcnt = rulelen; 2049| | 2050| 0| yyval = link_machines( yyvsp[-1], yyvsp[0] ); 2051| 0| } 2052| 0|#line 2053 "parse.c" 2053| 0| break; 2054| | 2055| 0| case 48: ------------------ | Branch (2055:3): [True: 0, False: 3.78k] ------------------ 2056| 0|#line 458 "parse.y" 2057| 0| { synerr( _("trailing context used twice") ); } ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2058| 0|#line 2059 "parse.c" 2059| 0| break; 2060| | 2061| 0| case 49: ------------------ | Branch (2061:3): [True: 0, False: 3.78k] ------------------ 2062| 0|#line 461 "parse.y" 2063| 0| { 2064| 0| headcnt = 0; 2065| 0| trailcnt = 1; 2066| 0| rulelen = 1; 2067| 0| varlength = false; 2068| | 2069| 0| current_state_type = STATE_TRAILING_CONTEXT; ------------------ | | 560| 0|#define STATE_TRAILING_CONTEXT 0x2 ------------------ 2070| | 2071| 0| if ( trlcontxt ) ------------------ | Branch (2071:9): [True: 0, False: 0] ------------------ 2072| 0| { 2073| 0| synerr( _("trailing context used twice") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2074| 0| yyval = mkstate( SYM_EPSILON ); ------------------ | | 234| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 0|#define CSIZE 256 | | ------------------ ------------------ 2075| 0| } 2076| | 2077| 0| else if ( previous_continued_action ) ------------------ | Branch (2077:14): [True: 0, False: 0] ------------------ 2078| 0| { 2079| | /* See the comment in the rule for "re2 re" 2080| | * above. 2081| | */ 2082| 0| lwarn( 2083| 0| "trailing context made variable due to preceding '|' action" ); 2084| | 2085| 0| varlength = true; 2086| 0| } 2087| | 2088| 0| if ( ctrl.lex_compat || varlength ) ------------------ | Branch (2088:9): [True: 0, False: 0] | Branch (2088:28): [True: 0, False: 0] ------------------ 2089| 0| { 2090| | /* Again, see the comment in the rule for 2091| | * "re2 re" above. 2092| | */ 2093| 0| add_accept( yyvsp[-1], 2094| 0| num_rules | YY_TRAILING_HEAD_MASK ); ------------------ | | 183| 0|#define YY_TRAILING_HEAD_MASK 0x4000 ------------------ 2095| 0| variable_trail_rule = true; 2096| 0| } 2097| | 2098| 0| trlcontxt = true; 2099| | 2100| 0| eps = mkstate( SYM_EPSILON ); ------------------ | | 234| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 0|#define CSIZE 256 | | ------------------ ------------------ 2101| 0| yyval = link_machines( yyvsp[-1], 2102| 0| link_machines( eps, mkstate( '\n' ) ) ); 2103| 0| } 2104| 0|#line 2105 "parse.c" 2105| 0| break; 2106| | 2107| 0| case 50: ------------------ | Branch (2107:3): [True: 0, False: 3.78k] ------------------ 2108| 0|#line 504 "parse.y" 2109| 0| { 2110| 0| yyval = yyvsp[0]; 2111| | 2112| 0| if ( trlcontxt ) ------------------ | Branch (2112:9): [True: 0, False: 0] ------------------ 2113| 0| { 2114| 0| if ( ctrl.lex_compat || (varlength && headcnt == 0) ) ------------------ | Branch (2114:10): [True: 0, False: 0] | Branch (2114:30): [True: 0, False: 0] | Branch (2114:43): [True: 0, False: 0] ------------------ 2115| | /* Both head and trail are 2116| | * variable-length. 2117| | */ 2118| 0| variable_trail_rule = true; 2119| 0| else 2120| 0| trailcnt = rulelen; 2121| 0| } 2122| 0| } 2123| 0|#line 2124 "parse.c" 2124| 0| break; 2125| | 2126| 0| case 51: ------------------ | Branch (2126:3): [True: 0, False: 3.78k] ------------------ 2127| 0|#line 522 "parse.y" 2128| 0| { 2129| 0| varlength = true; 2130| 0| yyval = mkor( yyvsp[-2], yyvsp[0] ); 2131| 0| } 2132| 0|#line 2133 "parse.c" 2133| 0| break; 2134| | 2135| 0| case 52: ------------------ | Branch (2135:3): [True: 0, False: 3.78k] ------------------ 2136| 0|#line 528 "parse.y" 2137| 0| { yyval = yyvsp[0]; } 2138| 0|#line 2139 "parse.c" 2139| 0| break; 2140| | 2141| 0| case 53: ------------------ | Branch (2141:3): [True: 0, False: 3.78k] ------------------ 2142| 0|#line 533 "parse.y" 2143| 0| { 2144| | /* This rule is written separately so the 2145| | * reduction will occur before the trailing 2146| | * series is parsed. 2147| | */ 2148| | 2149| 0| if ( trlcontxt ) ------------------ | Branch (2149:9): [True: 0, False: 0] ------------------ 2150| 0| synerr( _("trailing context used twice") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2151| 0| else 2152| 0| trlcontxt = true; 2153| | 2154| 0| if ( varlength ) ------------------ | Branch (2154:9): [True: 0, False: 0] ------------------ 2155| | /* We hope the trailing context is 2156| | * fixed-length. 2157| | */ 2158| 0| varlength = false; 2159| 0| else 2160| 0| headcnt = rulelen; 2161| | 2162| 0| rulelen = 0; 2163| | 2164| 0| current_state_type = STATE_TRAILING_CONTEXT; ------------------ | | 560| 0|#define STATE_TRAILING_CONTEXT 0x2 ------------------ 2165| 0| yyval = yyvsp[-1]; 2166| 0| } 2167| 0|#line 2168 "parse.c" 2168| 0| break; 2169| | 2170| 0| case 54: ------------------ | Branch (2170:3): [True: 0, False: 3.78k] ------------------ 2171| 0|#line 560 "parse.y" 2172| 0| { 2173| | /* This is where concatenation of adjacent patterns 2174| | * gets done. 2175| | */ 2176| 0| yyval = link_machines( yyvsp[-1], yyvsp[0] ); 2177| 0| } 2178| 0|#line 2179 "parse.c" 2179| 0| break; 2180| | 2181| 0| case 55: ------------------ | Branch (2181:3): [True: 0, False: 3.78k] ------------------ 2182| 0|#line 568 "parse.y" 2183| 0| { yyval = yyvsp[0]; } 2184| 0|#line 2185 "parse.c" 2185| 0| break; 2186| | 2187| 0| case 56: ------------------ | Branch (2187:3): [True: 0, False: 3.78k] ------------------ 2188| 0|#line 571 "parse.y" 2189| 0| { 2190| 0| varlength = true; 2191| | 2192| 0| if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 ) ------------------ | Branch (2192:9): [True: 0, False: 0] | Branch (2192:34): [True: 0, False: 0] ------------------ 2193| 0| { 2194| 0| synerr( _("bad iteration values") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2195| 0| yyval = yyvsp[-5]; 2196| 0| } 2197| 0| else 2198| 0| { 2199| 0| if ( yyvsp[-3] == 0 ) ------------------ | Branch (2199:10): [True: 0, False: 0] ------------------ 2200| 0| { 2201| 0| if ( yyvsp[-1] <= 0 ) ------------------ | Branch (2201:11): [True: 0, False: 0] ------------------ 2202| 0| { 2203| 0| synerr( 2204| 0| _("bad iteration values") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2205| 0| yyval = yyvsp[-5]; 2206| 0| } 2207| 0| else 2208| 0| yyval = mkopt( 2209| 0| mkrep( yyvsp[-5], 1, yyvsp[-1] ) ); 2210| 0| } 2211| 0| else 2212| 0| yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] ); 2213| 0| } 2214| 0| } 2215| 0|#line 2216 "parse.c" 2216| 0| break; 2217| | 2218| 0| case 57: ------------------ | Branch (2218:3): [True: 0, False: 3.78k] ------------------ 2219| 0|#line 599 "parse.y" 2220| 0| { 2221| 0| varlength = true; 2222| | 2223| 0| if ( yyvsp[-2] <= 0 ) ------------------ | Branch (2223:9): [True: 0, False: 0] ------------------ 2224| 0| { 2225| 0| synerr( _("iteration value must be positive") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2226| 0| yyval = yyvsp[-4]; 2227| 0| } 2228| | 2229| 0| else 2230| 0| yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITE_REPEAT ); ------------------ | | 197| 0|#define INFINITE_REPEAT -1 /* for x{5,} constructions */ ------------------ 2231| 0| } 2232| 0|#line 2233 "parse.c" 2233| 0| break; 2234| | 2235| 0| case 58: ------------------ | Branch (2235:3): [True: 0, False: 3.78k] ------------------ 2236| 0|#line 613 "parse.y" 2237| 0| { 2238| | /* The series could be something like "(foo)", 2239| | * in which case we have no idea what its length 2240| | * is, so we punt here. 2241| | */ 2242| 0| varlength = true; 2243| | 2244| 0| if ( yyvsp[-1] <= 0 ) ------------------ | Branch (2244:9): [True: 0, False: 0] ------------------ 2245| 0| { 2246| 0| synerr( _("iteration value must be positive") ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2247| 0| ); 2248| 0| yyval = yyvsp[-3]; 2249| 0| } 2250| | 2251| 0| else 2252| 0| yyval = link_machines( yyvsp[-3], 2253| 0| copysingl( yyvsp[-3], yyvsp[-1] - 1 ) ); 2254| 0| } 2255| 0|#line 2256 "parse.c" 2256| 0| break; 2257| | 2258| 0| case 59: ------------------ | Branch (2258:3): [True: 0, False: 3.78k] ------------------ 2259| 0|#line 635 "parse.y" 2260| 0| { 2261| 0| varlength = true; 2262| | 2263| 0| yyval = mkclos( yyvsp[-1] ); 2264| 0| } 2265| 0|#line 2266 "parse.c" 2266| 0| break; 2267| | 2268| 0| case 60: ------------------ | Branch (2268:3): [True: 0, False: 3.78k] ------------------ 2269| 0|#line 642 "parse.y" 2270| 0| { 2271| 0| varlength = true; 2272| 0| yyval = mkposcl( yyvsp[-1] ); 2273| 0| } 2274| 0|#line 2275 "parse.c" 2275| 0| break; 2276| | 2277| 0| case 61: ------------------ | Branch (2277:3): [True: 0, False: 3.78k] ------------------ 2278| 0|#line 648 "parse.y" 2279| 0| { 2280| 0| varlength = true; 2281| 0| yyval = mkopt( yyvsp[-1] ); 2282| 0| } 2283| 0|#line 2284 "parse.c" 2284| 0| break; 2285| | 2286| 0| case 62: ------------------ | Branch (2286:3): [True: 0, False: 3.78k] ------------------ 2287| 0|#line 654 "parse.y" 2288| 0| { 2289| 0| varlength = true; 2290| | 2291| 0| if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 ) ------------------ | Branch (2291:9): [True: 0, False: 0] | Branch (2291:34): [True: 0, False: 0] ------------------ 2292| 0| { 2293| 0| synerr( _("bad iteration values") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2294| 0| yyval = yyvsp[-5]; 2295| 0| } 2296| 0| else 2297| 0| { 2298| 0| if ( yyvsp[-3] == 0 ) ------------------ | Branch (2298:10): [True: 0, False: 0] ------------------ 2299| 0| { 2300| 0| if ( yyvsp[-1] <= 0 ) ------------------ | Branch (2300:11): [True: 0, False: 0] ------------------ 2301| 0| { 2302| 0| synerr( 2303| 0| _("bad iteration values") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2304| 0| yyval = yyvsp[-5]; 2305| 0| } 2306| 0| else 2307| 0| yyval = mkopt( 2308| 0| mkrep( yyvsp[-5], 1, yyvsp[-1] ) ); 2309| 0| } 2310| 0| else 2311| 0| yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] ); 2312| 0| } 2313| 0| } 2314| 0|#line 2315 "parse.c" 2315| 0| break; 2316| | 2317| 0| case 63: ------------------ | Branch (2317:3): [True: 0, False: 3.78k] ------------------ 2318| 0|#line 682 "parse.y" 2319| 0| { 2320| 0| varlength = true; 2321| | 2322| 0| if ( yyvsp[-2] <= 0 ) ------------------ | Branch (2322:9): [True: 0, False: 0] ------------------ 2323| 0| { 2324| 0| synerr( _("iteration value must be positive") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2325| 0| yyval = yyvsp[-4]; 2326| 0| } 2327| | 2328| 0| else 2329| 0| yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITE_REPEAT ); ------------------ | | 197| 0|#define INFINITE_REPEAT -1 /* for x{5,} constructions */ ------------------ 2330| 0| } 2331| 0|#line 2332 "parse.c" 2332| 0| break; 2333| | 2334| 0| case 64: ------------------ | Branch (2334:3): [True: 0, False: 3.78k] ------------------ 2335| 0|#line 696 "parse.y" 2336| 0| { 2337| | /* The singleton could be something like "(foo)", 2338| | * in which case we have no idea what its length 2339| | * is, so we punt here. 2340| | */ 2341| 0| varlength = true; 2342| | 2343| 0| if ( yyvsp[-1] <= 0 ) ------------------ | Branch (2343:9): [True: 0, False: 0] ------------------ 2344| 0| { 2345| 0| synerr( _("iteration value must be positive") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2346| 0| yyval = yyvsp[-3]; 2347| 0| } 2348| | 2349| 0| else 2350| 0| yyval = link_machines( yyvsp[-3], 2351| 0| copysingl( yyvsp[-3], yyvsp[-1] - 1 ) ); 2352| 0| } 2353| 0|#line 2354 "parse.c" 2354| 0| break; 2355| | 2356| 0| case 65: ------------------ | Branch (2356:3): [True: 0, False: 3.78k] ------------------ 2357| 0|#line 715 "parse.y" 2358| 0| { 2359| 0| if ( ! madeany ) ------------------ | Branch (2359:9): [True: 0, False: 0] ------------------ 2360| 0| { 2361| | /* Create the '.' character class. */ 2362| 0| ccldot = cclinit(); 2363| 0| ccladd( ccldot, '\n' ); 2364| 0| cclnegate( ccldot ); 2365| | 2366| 0| if ( ctrl.useecs ) ------------------ | Branch (2366:26): [True: 0, False: 0] ------------------ 2367| 0| mkeccl( ccltbl + cclmap[ccldot], 2368| 0| ccllen[ccldot], nextecm, 2369| 0| ecgroup, ctrl.csize, ctrl.csize ); 2370| | 2371| | /* Create the (?s:'.') character class. */ 2372| 0| cclany = cclinit(); 2373| 0| cclnegate( cclany ); 2374| | 2375| 0| if ( ctrl.useecs ) ------------------ | Branch (2375:26): [True: 0, False: 0] ------------------ 2376| 0| mkeccl( ccltbl + cclmap[cclany], 2377| 0| ccllen[cclany], nextecm, 2378| 0| ecgroup, ctrl.csize, ctrl.csize ); 2379| | 2380| 0| madeany = true; 2381| 0| } 2382| | 2383| 0| ++rulelen; 2384| | 2385| 0| if (sf_dot_all()) ------------------ | | 1186| 0|#define sf_dot_all() (sf_top() & _SF_DOT_ALL) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_dot_all() (sf_top() & _SF_DOT_ALL) | | ------------------ | | | | 1182| 0|#define _SF_DOT_ALL ((scanflags_t) 0x0002) | | ------------------ | | | Branch (1186:28): [True: 0, False: 0] | | ------------------ ------------------ 2386| 0| yyval = mkstate( -cclany ); 2387| 0| else 2388| 0| yyval = mkstate( -ccldot ); 2389| 0| } 2390| 0|#line 2391 "parse.c" 2391| 0| break; 2392| | 2393| 0| case 66: ------------------ | Branch (2393:3): [True: 0, False: 3.78k] ------------------ 2394| 0|#line 749 "parse.y" 2395| 0| { 2396| | /* Sort characters for fast searching. 2397| | */ 2398| 0| qsort( ccltbl + cclmap[yyvsp[0]], (size_t) ccllen[yyvsp[0]], sizeof (*ccltbl), cclcmp ); 2399| | 2400| 0| if ( ctrl.useecs ) ------------------ | Branch (2400:9): [True: 0, False: 0] ------------------ 2401| 0| mkeccl( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], 2402| 0| nextecm, ecgroup, ctrl.csize, ctrl.csize); 2403| | 2404| 0| ++rulelen; 2405| | 2406| 0| if (ccl_has_nl[yyvsp[0]]) ------------------ | Branch (2406:8): [True: 0, False: 0] ------------------ 2407| 0| rule_has_nl[num_rules] = true; 2408| | 2409| 0| yyval = mkstate( -yyvsp[0] ); 2410| 0| } 2411| 0|#line 2412 "parse.c" 2412| 0| break; 2413| | 2414| 0| case 67: ------------------ | Branch (2414:3): [True: 0, False: 3.78k] ------------------ 2415| 0|#line 767 "parse.y" 2416| 0| { 2417| 0| ++rulelen; 2418| | 2419| 0| if (ccl_has_nl[yyvsp[0]]) ------------------ | Branch (2419:8): [True: 0, False: 0] ------------------ 2420| 0| rule_has_nl[num_rules] = true; 2421| | 2422| 0| yyval = mkstate( -yyvsp[0] ); 2423| 0| } 2424| 0|#line 2425 "parse.c" 2425| 0| break; 2426| | 2427| 0| case 68: ------------------ | Branch (2427:3): [True: 0, False: 3.78k] ------------------ 2428| 0|#line 777 "parse.y" 2429| 0| { yyval = yyvsp[-1]; } 2430| 0|#line 2431 "parse.c" 2431| 0| break; 2432| | 2433| 0| case 69: ------------------ | Branch (2433:3): [True: 0, False: 3.78k] ------------------ 2434| 0|#line 780 "parse.y" 2435| 0| { yyval = yyvsp[-1]; } 2436| 0|#line 2437 "parse.c" 2437| 0| break; 2438| | 2439| 0| case 70: ------------------ | Branch (2439:3): [True: 0, False: 3.78k] ------------------ 2440| 0|#line 783 "parse.y" 2441| 0| { 2442| 0| ++rulelen; 2443| | 2444| 0| if (yyvsp[0] == nlch) ------------------ | Branch (2444:8): [True: 0, False: 0] ------------------ 2445| 0| rule_has_nl[num_rules] = true; 2446| | 2447| 0| if (sf_case_ins() && has_case(yyvsp[0])) ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2447:34): [True: 0, False: 0] ------------------ 2448| | /* create an alternation, as in (a|A) */ 2449| 0| yyval = mkor (mkstate(yyvsp[0]), mkstate(reverse_case(yyvsp[0]))); 2450| 0| else 2451| 0| yyval = mkstate( yyvsp[0] ); 2452| 0| } 2453| 0|#line 2454 "parse.c" 2454| 0| break; 2455| | 2456| 0| case 71: ------------------ | Branch (2456:3): [True: 0, False: 3.78k] ------------------ 2457| 0|#line 797 "parse.y" 2458| 0| { yyval = ccl_set_diff (yyvsp[-2], yyvsp[0]); } 2459| 0|#line 2460 "parse.c" 2460| 0| break; 2461| | 2462| 0| case 72: ------------------ | Branch (2462:3): [True: 0, False: 3.78k] ------------------ 2463| 0|#line 798 "parse.y" 2464| 0| { yyval = ccl_set_union (yyvsp[-2], yyvsp[0]); } 2465| 0|#line 2466 "parse.c" 2466| 0| break; 2467| | 2468| 0| case 74: ------------------ | Branch (2468:3): [True: 0, False: 3.78k] ------------------ 2469| 0|#line 804 "parse.y" 2470| 0| { yyval = yyvsp[-1]; } 2471| 0|#line 2472 "parse.c" 2472| 0| break; 2473| | 2474| 0| case 75: ------------------ | Branch (2474:3): [True: 0, False: 3.78k] ------------------ 2475| 0|#line 807 "parse.y" 2476| 0| { 2477| 0| cclnegate( yyvsp[-1] ); 2478| 0| yyval = yyvsp[-1]; 2479| 0| } 2480| 0|#line 2481 "parse.c" 2481| 0| break; 2482| | 2483| 0| case 76: ------------------ | Branch (2483:3): [True: 0, False: 3.78k] ------------------ 2484| 0|#line 814 "parse.y" 2485| 0| { 2486| | 2487| 0| if (sf_case_ins()) ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ 2488| 0| { 2489| | 2490| | /* If one end of the range has case and the other 2491| | * does not, or the cases are different, then we're not 2492| | * sure what range the user is trying to express. 2493| | * Examples: [@-z] or [S-t] 2494| | */ 2495| 0| if (has_case (yyvsp[-2]) != has_case (yyvsp[0]) ------------------ | Branch (2495:12): [True: 0, False: 0] ------------------ 2496| 0| || (has_case (yyvsp[-2]) && (b_islower (yyvsp[-2]) != b_islower (yyvsp[0]))) ------------------ | | 1120| 0|#define b_islower(c) (islower(c)?true:false) ------------------ || (has_case (yyvsp[-2]) && (b_islower (yyvsp[-2]) != b_islower (yyvsp[0]))) ------------------ | | 1120| 0|#define b_islower(c) (islower(c)?true:false) ------------------ | Branch (2496:14): [True: 0, False: 0] | Branch (2496:38): [True: 0, False: 0] | Branch (2496:39): [True: 0, False: 0] | Branch (2496:64): [True: 0, False: 0] ------------------ 2497| 0| || (has_case (yyvsp[-2]) && (b_isupper (yyvsp[-2]) != b_isupper (yyvsp[0])))) ------------------ | | 1124| 0|#define b_isupper(c) (isupper(c)?true:false) ------------------ || (has_case (yyvsp[-2]) && (b_isupper (yyvsp[-2]) != b_isupper (yyvsp[0])))) ------------------ | | 1124| 0|#define b_isupper(c) (isupper(c)?true:false) ------------------ | Branch (2497:14): [True: 0, False: 0] | Branch (2497:38): [True: 0, False: 0] | Branch (2497:39): [True: 0, False: 0] | Branch (2497:64): [True: 0, False: 0] ------------------ 2498| 0| format_warn3 ( ------------------ | | 118| 0| do{ \ | | 119| 0| char fw3_msg[MAXLINE];\ | | 120| 0| snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\ | | ------------------ | | | | 114| 0|#define MAXLINE 2048 | | ------------------ | | 121| 0| lwarn( fw3_msg );\ | | 122| 0| }while(0) | | ------------------ | | | Branch (122:9): [Folded, False: 0] | | ------------------ ------------------ 2499| 0| _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"), 2500| 0| yyvsp[-2], yyvsp[0]); 2501| | 2502| | /* If the range spans uppercase characters but not 2503| | * lowercase (or vice-versa), then should we automatically 2504| | * include lowercase characters in the range? 2505| | * Example: [@-_] spans [a-z] but not [A-Z] 2506| | */ 2507| 0| else if (!has_case (yyvsp[-2]) && !has_case (yyvsp[0]) && !range_covers_case (yyvsp[-2], yyvsp[0])) ------------------ | Branch (2507:17): [True: 0, False: 0] | Branch (2507:42): [True: 0, False: 0] | Branch (2507:66): [True: 0, False: 0] ------------------ 2508| 0| format_warn3 ( ------------------ | | 118| 0| do{ \ | | 119| 0| char fw3_msg[MAXLINE];\ | | 120| 0| snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\ | | ------------------ | | | | 114| 0|#define MAXLINE 2048 | | ------------------ | | 121| 0| lwarn( fw3_msg );\ | | 122| 0| }while(0) | | ------------------ | | | Branch (122:9): [Folded, False: 0] | | ------------------ ------------------ 2509| 0| _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"), 2510| 0| yyvsp[-2], yyvsp[0]); 2511| 0| } 2512| | 2513| 0| if ( yyvsp[-2] > yyvsp[0] ) ------------------ | Branch (2513:9): [True: 0, False: 0] ------------------ 2514| 0| synerr( _("negative range in character class") ); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2515| | 2516| 0| else 2517| 0| { 2518| 0| for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i ) ------------------ | Branch (2518:26): [True: 0, False: 0] ------------------ 2519| 0| ccladd( yyvsp[-3], i ); 2520| | 2521| | /* Keep track if this ccl is staying in 2522| | * alphabetical order. 2523| | */ 2524| 0| cclsorted = cclsorted && (yyvsp[-2] > lastchar); ------------------ | Branch (2524:17): [True: 0, False: 0] | Branch (2524:30): [True: 0, False: 0] ------------------ 2525| 0| lastchar = yyvsp[0]; 2526| | 2527| | /* Do it again for upper/lowercase */ 2528| 0| if (sf_case_ins() && has_case(yyvsp[-2]) && has_case(yyvsp[0])){ ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2528:38): [True: 0, False: 0] | Branch (2528:61): [True: 0, False: 0] ------------------ 2529| 0| yyvsp[-2] = reverse_case (yyvsp[-2]); 2530| 0| yyvsp[0] = reverse_case (yyvsp[0]); 2531| | 2532| 0| for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i ) ------------------ | Branch (2532:42): [True: 0, False: 0] ------------------ 2533| 0| ccladd( yyvsp[-3], i ); 2534| | 2535| 0| cclsorted = cclsorted && (yyvsp[-2] > lastchar); ------------------ | Branch (2535:33): [True: 0, False: 0] | Branch (2535:46): [True: 0, False: 0] ------------------ 2536| 0| lastchar = yyvsp[0]; 2537| 0| } 2538| | 2539| 0| } 2540| | 2541| 0| yyval = yyvsp[-3]; 2542| 0| } 2543| 0|#line 2544 "parse.c" 2544| 0| break; 2545| | 2546| 0| case 77: ------------------ | Branch (2546:3): [True: 0, False: 3.78k] ------------------ 2547| 0|#line 874 "parse.y" 2548| 0| { 2549| 0| ccladd( yyvsp[-1], yyvsp[0] ); 2550| 0| cclsorted = cclsorted && (yyvsp[0] > lastchar); ------------------ | Branch (2550:16): [True: 0, False: 0] | Branch (2550:29): [True: 0, False: 0] ------------------ 2551| 0| lastchar = yyvsp[0]; 2552| | 2553| | /* Do it again for upper/lowercase */ 2554| 0| if (sf_case_ins() && has_case(yyvsp[0])){ ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2554:34): [True: 0, False: 0] ------------------ 2555| 0| yyvsp[0] = reverse_case (yyvsp[0]); 2556| 0| ccladd (yyvsp[-1], yyvsp[0]); 2557| | 2558| 0| cclsorted = cclsorted && (yyvsp[0] > lastchar); ------------------ | Branch (2558:29): [True: 0, False: 0] | Branch (2558:42): [True: 0, False: 0] ------------------ 2559| 0| lastchar = yyvsp[0]; 2560| 0| } 2561| | 2562| 0| yyval = yyvsp[-1]; 2563| 0| } 2564| 0|#line 2565 "parse.c" 2565| 0| break; 2566| | 2567| 0| case 78: ------------------ | Branch (2567:3): [True: 0, False: 3.78k] ------------------ 2568| 0|#line 892 "parse.y" 2569| 0| { 2570| | /* Too hard to properly maintain cclsorted. */ 2571| 0| cclsorted = false; 2572| 0| yyval = yyvsp[-1]; 2573| 0| } 2574| 0|#line 2575 "parse.c" 2575| 0| break; 2576| | 2577| 0| case 79: ------------------ | Branch (2577:3): [True: 0, False: 3.78k] ------------------ 2578| 0|#line 899 "parse.y" 2579| 0| { 2580| 0| cclsorted = true; 2581| 0| lastchar = 0; 2582| 0| currccl = yyval = cclinit(); 2583| 0| } 2584| 0|#line 2585 "parse.c" 2585| 0| break; 2586| | 2587| 0| case 80: ------------------ | Branch (2587:3): [True: 0, False: 3.78k] ------------------ 2588| 0|#line 907 "parse.y" 2589| 0| { CCL_EXPR(isalnum); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2589| 0| { CCL_EXPR(isalnum); } | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2589:27): [True: 0, False: 0] | Branch (2589:36): [True: 0, False: 0] ------------------ 2590| 0|#line 2591 "parse.c" 2591| 0| break; 2592| | 2593| 0| case 81: ------------------ | Branch (2593:3): [True: 0, False: 3.78k] ------------------ 2594| 0|#line 908 "parse.y" 2595| 0| { CCL_EXPR(isalpha); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2595| 0| { CCL_EXPR(isalpha); } | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2595:35): [True: 0, False: 0] | Branch (2595:44): [True: 0, False: 0] ------------------ 2596| 0|#line 2597 "parse.c" 2597| 0| break; 2598| | 2599| 0| case 82: ------------------ | Branch (2599:3): [True: 0, False: 3.78k] ------------------ 2600| 0|#line 909 "parse.y" 2601| 0| { CCL_EXPR(IS_BLANK); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2601| 0| { CCL_EXPR(IS_BLANK); } | | | | ------------------ | | | | | | 143| 0|#define IS_BLANK(c) ((c) == ' ' || (c) == '\t') | | | | | | ------------------ | | | | | | | Branch (143:22): [True: 0, False: 0] | | | | | | | Branch (143:36): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2601:35): [True: 0, False: 0] ------------------ 2602| 0|#line 2603 "parse.c" 2603| 0| break; 2604| | 2605| 0| case 83: ------------------ | Branch (2605:3): [True: 0, False: 3.78k] ------------------ 2606| 0|#line 910 "parse.y" 2607| 0| { CCL_EXPR(iscntrl); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2607| 0| { CCL_EXPR(iscntrl); } | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2607:35): [True: 0, False: 0] | Branch (2607:44): [True: 0, False: 0] ------------------ 2608| 0|#line 2609 "parse.c" 2609| 0| break; 2610| | 2611| 0| case 84: ------------------ | Branch (2611:3): [True: 0, False: 3.78k] ------------------ 2612| 0|#line 911 "parse.y" 2613| 0| { CCL_EXPR(isdigit); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2613| 0| { CCL_EXPR(isdigit); } | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2613:35): [True: 0, False: 0] | Branch (2613:44): [True: 0, False: 0] ------------------ 2614| 0|#line 2615 "parse.c" 2615| 0| break; 2616| | 2617| 0| case 85: ------------------ | Branch (2617:3): [True: 0, False: 3.78k] ------------------ 2618| 0|#line 912 "parse.y" 2619| 0| { CCL_EXPR(isgraph); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2619| 0| { CCL_EXPR(isgraph); } | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2619:35): [True: 0, False: 0] | Branch (2619:44): [True: 0, False: 0] ------------------ 2620| 0|#line 2621 "parse.c" 2621| 0| break; 2622| | 2623| 0| case 86: ------------------ | Branch (2623:3): [True: 0, False: 3.78k] ------------------ 2624| 0|#line 913 "parse.y" 2625| 0| { 2626| 0| CCL_EXPR(islower); ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2626| 0| CCL_EXPR(islower); | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2626:27): [True: 0, False: 0] | Branch (2626:36): [True: 0, False: 0] ------------------ 2627| 0| if (sf_case_ins()) ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ 2628| 0| CCL_EXPR(isupper); ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2628| 0| CCL_EXPR(isupper); | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2628:31): [True: 0, False: 0] | Branch (2628:40): [True: 0, False: 0] ------------------ 2629| 0| } 2630| 0|#line 2631 "parse.c" 2631| 0| break; 2632| | 2633| 0| case 87: ------------------ | Branch (2633:3): [True: 0, False: 3.78k] ------------------ 2634| 0|#line 918 "parse.y" 2635| 0| { CCL_EXPR(isprint); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2635| 0| { CCL_EXPR(isprint); } | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2635:35): [True: 0, False: 0] | Branch (2635:44): [True: 0, False: 0] ------------------ 2636| 0|#line 2637 "parse.c" 2637| 0| break; 2638| | 2639| 0| case 88: ------------------ | Branch (2639:3): [True: 0, False: 3.78k] ------------------ 2640| 0|#line 919 "parse.y" 2641| 0| { CCL_EXPR(ispunct); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2641| 0| { CCL_EXPR(ispunct); } | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2641:35): [True: 0, False: 0] | Branch (2641:44): [True: 0, False: 0] ------------------ 2642| 0|#line 2643 "parse.c" 2643| 0| break; 2644| | 2645| 0| case 89: ------------------ | Branch (2645:3): [True: 0, False: 3.78k] ------------------ 2646| 0|#line 920 "parse.y" 2647| 0| { CCL_EXPR(isspace); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2647| 0| { CCL_EXPR(isspace); } | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2647:35): [True: 0, False: 0] | Branch (2647:44): [True: 0, False: 0] ------------------ 2648| 0|#line 2649 "parse.c" 2649| 0| break; 2650| | 2651| 0| case 90: ------------------ | Branch (2651:3): [True: 0, False: 3.78k] ------------------ 2652| 0|#line 921 "parse.y" 2653| 0| { CCL_EXPR(isxdigit); } ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2653| 0| { CCL_EXPR(isxdigit); } | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2653:35): [True: 0, False: 0] | Branch (2653:44): [True: 0, False: 0] ------------------ 2654| 0|#line 2655 "parse.c" 2655| 0| break; 2656| | 2657| 0| case 91: ------------------ | Branch (2657:3): [True: 0, False: 3.78k] ------------------ 2658| 0|#line 922 "parse.y" 2659| 0| { 2660| 0| CCL_EXPR(isupper); ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2660| 0| CCL_EXPR(isupper); | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2660:21): [True: 0, False: 0] | Branch (2660:30): [True: 0, False: 0] ------------------ 2661| 0| if (sf_case_ins()) ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ 2662| 0| CCL_EXPR(islower); ------------------ | | 126| 0| do{ \ | | 127| 0| int c; \ | | 128| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (128:15): [True: 0, False: 0] | | ------------------ | | 129| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2662| 0| CCL_EXPR(islower); | | ------------------ | | 130| 0| ccladd( currccl, c ); \ | | 131| 0| }while(0) | | ------------------ | | | Branch (131:9): [Folded, False: 0] | | ------------------ ------------------ | Branch (2662:25): [True: 0, False: 0] | Branch (2662:34): [True: 0, False: 0] ------------------ 2663| 0| } 2664| 0|#line 2665 "parse.c" 2665| 0| break; 2666| | 2667| 0| case 92: ------------------ | Branch (2667:3): [True: 0, False: 3.78k] ------------------ 2668| 0|#line 928 "parse.y" 2669| 0| { CCL_NEG_EXPR(isalnum); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2669| 0| { CCL_NEG_EXPR(isalnum); } | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2670| 0|#line 2671 "parse.c" 2671| 0| break; 2672| | 2673| 0| case 93: ------------------ | Branch (2673:3): [True: 0, False: 3.78k] ------------------ 2674| 0|#line 929 "parse.y" 2675| 0| { CCL_NEG_EXPR(isalpha); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2675| 0| { CCL_NEG_EXPR(isalpha); } | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2676| 0|#line 2677 "parse.c" 2677| 0| break; 2678| | 2679| 0| case 94: ------------------ | Branch (2679:3): [True: 0, False: 3.78k] ------------------ 2680| 0|#line 930 "parse.y" 2681| 0| { CCL_NEG_EXPR(IS_BLANK); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2681| 0| { CCL_NEG_EXPR(IS_BLANK); } | | | | ------------------ | | | | | | 143| 0|#define IS_BLANK(c) ((c) == ' ' || (c) == '\t') | | | | | | ------------------ | | | | | | | Branch (143:22): [True: 0, False: 0] | | | | | | | Branch (143:36): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2682| 0|#line 2683 "parse.c" 2683| 0| break; 2684| | 2685| 0| case 95: ------------------ | Branch (2685:3): [True: 0, False: 3.78k] ------------------ 2686| 0|#line 931 "parse.y" 2687| 0| { CCL_NEG_EXPR(iscntrl); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2687| 0| { CCL_NEG_EXPR(iscntrl); } | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2688| 0|#line 2689 "parse.c" 2689| 0| break; 2690| | 2691| 0| case 96: ------------------ | Branch (2691:3): [True: 0, False: 3.78k] ------------------ 2692| 0|#line 932 "parse.y" 2693| 0| { CCL_NEG_EXPR(isdigit); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2693| 0| { CCL_NEG_EXPR(isdigit); } | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2694| 0|#line 2695 "parse.c" 2695| 0| break; 2696| | 2697| 0| case 97: ------------------ | Branch (2697:3): [True: 0, False: 3.78k] ------------------ 2698| 0|#line 933 "parse.y" 2699| 0| { CCL_NEG_EXPR(isgraph); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2699| 0| { CCL_NEG_EXPR(isgraph); } | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2700| 0|#line 2701 "parse.c" 2701| 0| break; 2702| | 2703| 0| case 98: ------------------ | Branch (2703:3): [True: 0, False: 3.78k] ------------------ 2704| 0|#line 934 "parse.y" 2705| 0| { CCL_NEG_EXPR(isprint); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2705| 0| { CCL_NEG_EXPR(isprint); } | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2706| 0|#line 2707 "parse.c" 2707| 0| break; 2708| | 2709| 0| case 99: ------------------ | Branch (2709:3): [True: 0, False: 3.78k] ------------------ 2710| 0|#line 935 "parse.y" 2711| 0| { CCL_NEG_EXPR(ispunct); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2711| 0| { CCL_NEG_EXPR(ispunct); } | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2712| 0|#line 2713 "parse.c" 2713| 0| break; 2714| | 2715| 0| case 100: ------------------ | Branch (2715:3): [True: 0, False: 3.78k] ------------------ 2716| 0|#line 936 "parse.y" 2717| 0| { CCL_NEG_EXPR(isspace); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2717| 0| { CCL_NEG_EXPR(isspace); } | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2718| 0|#line 2719 "parse.c" 2719| 0| break; 2720| | 2721| 0| case 101: ------------------ | Branch (2721:3): [True: 0, False: 3.78k] ------------------ 2722| 0|#line 937 "parse.y" 2723| 0| { CCL_NEG_EXPR(isxdigit); } ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2723| 0| { CCL_NEG_EXPR(isxdigit); } | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2724| 0|#line 2725 "parse.c" 2725| 0| break; 2726| | 2727| 0| case 102: ------------------ | Branch (2727:3): [True: 0, False: 3.78k] ------------------ 2728| 0|#line 938 "parse.y" 2729| 0| { 2730| 0| if ( sf_case_ins() ) ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ 2731| 0| lwarn(_("[:^lower:] is ambiguous in case insensitive scanner")); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2732| 0| else 2733| 0| CCL_NEG_EXPR(islower); ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2733| 0| CCL_NEG_EXPR(islower); | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2734| 0| } 2735| 0|#line 2736 "parse.c" 2736| 0| break; 2737| | 2738| 0| case 103: ------------------ | Branch (2738:3): [True: 0, False: 3.78k] ------------------ 2739| 0|#line 944 "parse.y" 2740| 0| { 2741| 0| if ( sf_case_ins() ) ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ 2742| 0| lwarn(_("[:^upper:] ambiguous in case insensitive scanner")); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 2743| 0| else 2744| 0| CCL_NEG_EXPR(isupper); ------------------ | | 135| 0| do{ \ | | 136| 0| int c; \ | | 137| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (137:15): [True: 0, False: 0] | | ------------------ | | 138| 0| if ( !func(c) ) \ | | ------------------ | | | | 2744| 0| CCL_NEG_EXPR(isupper); | | ------------------ | | | Branch (138:8): [True: 0, False: 0] | | ------------------ | | 139| 0| ccladd( currccl, c ); \ | | 140| 0| }while(0) | | ------------------ | | | Branch (140:9): [Folded, False: 0] | | ------------------ ------------------ 2745| 0| } 2746| 0|#line 2747 "parse.c" 2747| 0| break; 2748| | 2749| 0| case 104: ------------------ | Branch (2749:3): [True: 0, False: 3.78k] ------------------ 2750| 0|#line 953 "parse.y" 2751| 0| { 2752| 0| if ( yyvsp[0] == nlch ) ------------------ | Branch (2752:9): [True: 0, False: 0] ------------------ 2753| 0| rule_has_nl[num_rules] = true; 2754| | 2755| 0| ++rulelen; 2756| | 2757| 0| if (sf_case_ins() && has_case(yyvsp[0])) ------------------ | | 1185| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1185:28): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2757:34): [True: 0, False: 0] ------------------ 2758| 0| yyval = mkor (mkstate(yyvsp[0]), mkstate(reverse_case(yyvsp[0]))); 2759| 0| else 2760| 0| yyval = mkstate (yyvsp[0]); 2761| | 2762| 0| yyval = link_machines( yyvsp[-1], yyval); 2763| 0| } 2764| 0|#line 2765 "parse.c" 2765| 0| break; 2766| | 2767| 0| case 105: ------------------ | Branch (2767:3): [True: 0, False: 3.78k] ------------------ 2768| 0|#line 968 "parse.y" 2769| 0| { yyval = mkstate( SYM_EPSILON ); } ------------------ | | 234| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 0|#define CSIZE 256 | | ------------------ ------------------ 2770| 0|#line 2771 "parse.c" 2771| 0| break; 2772| | 2773| | 2774| 0|#line 2775 "parse.c" 2775| | 2776| 432| default: break; ------------------ | Branch (2776:7): [True: 432, False: 3.35k] ------------------ 2777| 3.78k| } 2778| | /* User semantic actions sometimes alter yychar, and that requires 2779| | that yytoken be updated with the new translation. We take the 2780| | approach of translating immediately before every use of yytoken. 2781| | One alternative is translating here after every semantic action, 2782| | but that translation would be missed if the semantic action invokes 2783| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2784| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2785| | incorrect destructor might then be invoked immediately. In the 2786| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 2787| | to an incorrect destructor call or verbose syntax error message 2788| | before the lookahead is translated. */ 2789| 3.78k| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2790| | 2791| 3.78k| YYPOPSTACK (yylen); ------------------ | | 1422| 3.78k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2792| 3.78k| yylen = 0; 2793| 3.78k| YY_STACK_PRINT (yyss, yyssp); 2794| | 2795| 3.78k| *++yyvsp = yyval; 2796| | 2797| | /* Now 'shift' the result of the reduction. Determine what state 2798| | that goes to, based on the state we popped back to and the rule 2799| | number reduced by. */ 2800| 3.78k| { 2801| 3.78k| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 635| 3.78k|#define YYNTOKENS 78 ------------------ 2802| 3.78k| const int yyi = yypgoto[yylhs] + *yyssp; 2803| 3.78k| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 632| 4.24k|#define YYLAST 193 ------------------ | Branch (2803:16): [True: 462, False: 3.32k] | Branch (2803:28): [True: 462, False: 0] | Branch (2803:45): [True: 0, False: 462] ------------------ 2804| 3.78k| ? yytable[yyi] 2805| 3.78k| : yydefgoto[yylhs]); 2806| 3.78k| } 2807| | 2808| 3.78k| goto yynewstate; 2809| | 2810| | 2811| |/*--------------------------------------. 2812| || yyerrlab -- here on detecting error. | 2813| |`--------------------------------------*/ 2814| 2.42k|yyerrlab: 2815| | /* Make sure we have latest lookahead translation. See comments at 2816| | user semantic actions for why this is necessary. */ 2817| 2.42k| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 934| 2.42k|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 934| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 650| 4.85k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 644| 2.42k|#define YYMAXUTOK 311 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 643| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (650:4): [True: 2.42k, False: 0] | | | Branch (650:18): [True: 2.42k, False: 0] | | ------------------ ------------------ | Branch (2817:13): [True: 0, False: 2.42k] ------------------ 2818| | 2819| | /* If not already recovering from an error, report this error. */ 2820| 2.42k| if (!yyerrstatus) ------------------ | Branch (2820:7): [True: 577, False: 1.85k] ------------------ 2821| 577| { 2822| 577| ++yynerrs; 2823| 577|#if ! YYERROR_VERBOSE 2824| 577| yyerror (YY_("syntax error")); ------------------ | | 440| 577|# define YY_(Msgid) Msgid ------------------ 2825| |#else 2826| |# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2827| | yyssp, yytoken) 2828| | { 2829| | char const *yymsgp = YY_("syntax error"); 2830| | int yysyntax_error_status; 2831| | yysyntax_error_status = YYSYNTAX_ERROR; 2832| | if (yysyntax_error_status == 0) 2833| | yymsgp = yymsg; 2834| | else if (yysyntax_error_status == 1) 2835| | { 2836| | if (yymsg != yymsgbuf) 2837| | YYSTACK_FREE (yymsg); 2838| | yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); 2839| | if (!yymsg) 2840| | { 2841| | yymsg = yymsgbuf; 2842| | yymsg_alloc = sizeof yymsgbuf; 2843| | yysyntax_error_status = 2; 2844| | } 2845| | else 2846| | { 2847| | yysyntax_error_status = YYSYNTAX_ERROR; 2848| | yymsgp = yymsg; 2849| | } 2850| | } 2851| | yyerror (yymsgp); 2852| | if (yysyntax_error_status == 2) 2853| | goto yyexhaustedlab; 2854| | } 2855| |# undef YYSYNTAX_ERROR 2856| |#endif 2857| 577| } 2858| | 2859| | 2860| | 2861| 2.42k| if (yyerrstatus == 3) ------------------ | Branch (2861:7): [True: 1.85k, False: 577] ------------------ 2862| 1.85k| { 2863| | /* If just tried and failed to reuse lookahead token after an 2864| | error, discard it. */ 2865| | 2866| 1.85k| if (yychar <= YYEOF) ------------------ | | 935| 1.85k|#define YYEOF 0 ------------------ | Branch (2866:11): [True: 547, False: 1.30k] ------------------ 2867| 547| { 2868| | /* Return failure if at end of input. */ 2869| 547| if (yychar == YYEOF) ------------------ | | 935| 547|#define YYEOF 0 ------------------ | Branch (2869:15): [True: 547, False: 0] ------------------ 2870| 547| YYABORT; ------------------ | | 938| 547|#define YYABORT goto yyabortlab ------------------ 2871| 547| } 2872| 1.30k| else 2873| 1.30k| { 2874| 1.30k| yydestruct ("Error: discarding", 2875| 1.30k| yytoken, &yylval); 2876| 1.30k| yychar = YYEMPTY; ------------------ | | 934| 1.30k|#define YYEMPTY (-2) ------------------ 2877| 1.30k| } 2878| 1.85k| } 2879| | 2880| | /* Else will try to reuse lookahead token after shifting the error 2881| | token. */ 2882| 1.88k| goto yyerrlab1; 2883| | 2884| | 2885| |/*---------------------------------------------------. 2886| || yyerrorlab -- error raised explicitly by YYERROR. | 2887| |`---------------------------------------------------*/ 2888| 1.88k|yyerrorlab: 2889| | /* Pacify compilers when the user code never invokes YYERROR and the 2890| | label yyerrorlab therefore never appears in user code. */ 2891| 0| if (0) ------------------ | Branch (2891:7): [Folded, False: 0] ------------------ 2892| 0| YYERROR; ------------------ | | 939| 0|#define YYERROR goto yyerrorlab ------------------ 2893| | 2894| | /* Do not reclaim the symbols of the rule whose action triggered 2895| | this YYERROR. */ 2896| 0| YYPOPSTACK (yylen); ------------------ | | 1422| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2897| 0| yylen = 0; 2898| 0| YY_STACK_PRINT (yyss, yyssp); 2899| 0| yystate = *yyssp; 2900| 0| goto yyerrlab1; 2901| | 2902| | 2903| |/*-------------------------------------------------------------. 2904| || yyerrlab1 -- common code for both syntax error and YYERROR. | 2905| |`-------------------------------------------------------------*/ 2906| 1.88k|yyerrlab1: 2907| 1.88k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 2908| | 2909| 1.88k| for (;;) 2910| 3.18k| { 2911| 3.18k| yyn = yypact[yystate]; 2912| 3.18k| if (!yypact_value_is_default (yyn)) ------------------ | | 755| 3.18k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 752| 3.18k|#define YYPACT_NINF (-88) | | ------------------ ------------------ | Branch (2912:11): [True: 3.18k, False: 0] ------------------ 2913| 3.18k| { 2914| 3.18k| yyn += YYTERROR; ------------------ | | 962| 3.18k|#define YYTERROR 1 ------------------ 2915| 3.18k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 632| 6.37k|#define YYLAST 193 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 962| 3.18k|#define YYTERROR 1 ------------------ | Branch (2915:15): [True: 3.18k, False: 0] | Branch (2915:27): [True: 3.18k, False: 0] | Branch (2915:44): [True: 1.88k, False: 1.30k] ------------------ 2916| 1.88k| { 2917| 1.88k| yyn = yytable[yyn]; 2918| 1.88k| if (0 < yyn) ------------------ | Branch (2918:19): [True: 1.88k, False: 0] ------------------ 2919| 1.88k| break; 2920| 1.88k| } 2921| 3.18k| } 2922| | 2923| | /* Pop the current state because it cannot handle the error token. */ 2924| 1.30k| if (yyssp == yyss) ------------------ | Branch (2924:11): [True: 0, False: 1.30k] ------------------ 2925| 0| YYABORT; ------------------ | | 938| 0|#define YYABORT goto yyabortlab ------------------ 2926| | 2927| | 2928| 1.30k| yydestruct ("Error: popping", 2929| 1.30k| yystos[yystate], yyvsp); 2930| 1.30k| YYPOPSTACK (1); ------------------ | | 1422| 1.30k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2931| 1.30k| yystate = *yyssp; 2932| 1.30k| YY_STACK_PRINT (yyss, yyssp); 2933| 1.30k| } 2934| | 2935| 1.88k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2936| 1.88k| *++yyvsp = yylval; 2937| 1.88k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2938| | 2939| | 2940| | /* Shift the error token. */ 2941| 1.88k| YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2942| | 2943| 1.88k| yystate = yyn; 2944| 1.88k| goto yynewstate; 2945| | 2946| | 2947| |/*-------------------------------------. 2948| || yyacceptlab -- YYACCEPT comes here. | 2949| |`-------------------------------------*/ 2950| 231|yyacceptlab: 2951| 231| yyresult = 0; 2952| 231| goto yyreturn; 2953| | 2954| | 2955| |/*-----------------------------------. 2956| || yyabortlab -- YYABORT comes here. | 2957| |`-----------------------------------*/ 2958| 547|yyabortlab: 2959| 547| yyresult = 1; 2960| 547| goto yyreturn; 2961| | 2962| | 2963| 0|#if !defined yyoverflow || YYERROR_VERBOSE 2964| |/*-------------------------------------------------. 2965| || yyexhaustedlab -- memory exhaustion comes here. | 2966| |`-------------------------------------------------*/ 2967| 0|yyexhaustedlab: 2968| 0| yyerror (YY_("memory exhausted")); ------------------ | | 440| 0|# define YY_(Msgid) Msgid ------------------ 2969| 0| yyresult = 2; 2970| | /* Fall through. */ 2971| 0|#endif 2972| | 2973| | 2974| |/*-----------------------------------------------------. 2975| || yyreturn -- parsing is finished, return the result. | 2976| |`-----------------------------------------------------*/ 2977| 778|yyreturn: 2978| 778| if (yychar != YYEMPTY) ------------------ | | 934| 778|#define YYEMPTY (-2) ------------------ | Branch (2978:7): [True: 547, False: 231] ------------------ 2979| 547| { 2980| | /* Make sure we have latest lookahead translation. See comments at 2981| | user semantic actions for why this is necessary. */ 2982| 547| yytoken = YYTRANSLATE (yychar); ------------------ | | 650| 547| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 644| 547|#define YYMAXUTOK 311 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 643| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (650:4): [True: 547, False: 0] | | | Branch (650:18): [True: 547, False: 0] | | ------------------ ------------------ 2983| 547| yydestruct ("Cleanup: discarding lookahead", 2984| 547| yytoken, &yylval); 2985| 547| } 2986| | /* Do not reclaim the symbols of the rule whose action triggered 2987| | this YYABORT or YYACCEPT. */ 2988| 778| YYPOPSTACK (yylen); ------------------ | | 1422| 778|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2989| 778| YY_STACK_PRINT (yyss, yyssp); 2990| 2.33k| while (yyssp != yyss) ------------------ | Branch (2990:10): [True: 1.55k, False: 778] ------------------ 2991| 1.55k| { 2992| 1.55k| yydestruct ("Cleanup: popping", 2993| 1.55k| yystos[+*yyssp], yyvsp); 2994| 1.55k| YYPOPSTACK (1); ------------------ | | 1422| 1.55k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2995| 1.55k| } 2996| 778|#ifndef yyoverflow 2997| 778| if (yyss != yyssa) ------------------ | Branch (2997:7): [True: 0, False: 778] ------------------ 2998| 0| YYSTACK_FREE (yyss); ------------------ | | 541| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 560| 0|# define YYFREE free | | ------------------ ------------------ 2999| 778|#endif 3000| |#if YYERROR_VERBOSE 3001| | if (yymsg != yymsgbuf) 3002| | YYSTACK_FREE (yymsg); 3003| |#endif 3004| 778| return yyresult; 3005| 0|} format_synerr: 3055| 23| { 3056| 23| char errmsg[MAXLINE]; 3057| | 3058| 23| (void) snprintf( errmsg, sizeof(errmsg), msg, arg ); 3059| 23| synerr( errmsg ); 3060| 23| } synerr: 3066| 2.28k| { 3067| | syntaxerror = true; 3068| 2.28k| pinpoint_message( str ); 3069| 2.28k| } format_pinpoint_message: 3095| 777| { 3096| 777| char errmsg[MAXLINE*2]; 3097| | 3098| 777| snprintf( errmsg, sizeof(errmsg), msg, arg ); 3099| 777| pinpoint_message( errmsg ); 3100| 777| } pinpoint_message: 3106| 3.60k| { 3107| 3.60k| line_pinpoint( str, linenum ); 3108| 3.60k| } line_pinpoint: 3128| 3.60k| { 3129| | fprintf( stderr, "%s:%d: %s\n", infilename, line, str ); 3130| 3.60k| } yyerror: 3138| 577| { 3139| 577| (void)msg; 3140| 577| } parse.c:yydestruct: 1354| 4.71k|{ 1355| 4.71k| YYUSE (yyvaluep); ------------------ | | 462| 4.71k|# define YYUSE(E) ((void) (E)) ------------------ 1356| 4.71k| if (!yymsg) ------------------ | Branch (1356:7): [True: 0, False: 4.71k] ------------------ 1357| 0| yymsg = "Deleting"; 1358| 4.71k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1359| | 1360| 4.71k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1361| 4.71k| YYUSE (yytype); ------------------ | | 462| 4.71k|# define YYUSE(E) ((void) (E)) ------------------ 1362| 4.71k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1363| 4.71k|} flexscan: 2405| 2.08k|{ 2406| 2.08k| yy_state_type yy_current_state; 2407| 2.08k| char *yy_cp, *yy_bp; 2408| 2.08k| int yy_act; 2409| | 2410| 2.08k| if ( !(yy_init) ) ------------------ | Branch (2410:7): [True: 1, False: 2.08k] ------------------ 2411| 1| { 2412| 1| (yy_init) = 1; 2413| | 2414| 1|#ifdef YY_USER_INIT 2415| 1| YY_USER_INIT; ------------------ | | 2156| 1| if ( getenv("POSIXLY_CORRECT") ) \ | | ------------------ | | | Branch (2156:7): [True: 0, False: 1] | | ------------------ | | 2157| 1| ctrl.posix_compat = true; | | ------------------ | | | | 83| 0|# define true 1 | | ------------------ ------------------ 2416| 1|#endif 2417| | 2418| 1| if ( ! (yy_start) ) ------------------ | Branch (2418:8): [True: 1, False: 0] ------------------ 2419| 1| (yy_start) = 1; /* first start state */ 2420| | 2421| 1| if ( ! yyin ) ------------------ | Branch (2421:8): [True: 0, False: 1] ------------------ 2422| 0| yyin = stdin; 2423| | 2424| 1| if ( ! yyout ) ------------------ | Branch (2424:8): [True: 1, False: 0] ------------------ 2425| 1| yyout = stdout; 2426| | 2427| 1| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 262| 1|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (262:29): [True: 0, False: 1] | | ------------------ | | 263| 1| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 264| 1| : NULL) ------------------ | Branch (2427:8): [True: 1, False: 0] ------------------ 2428| 1| yyensure_buffer_stack (); 2429| 1| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 268| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2430| 1| yy_create_buffer( yyin, YY_BUF_SIZE ); ------------------ | | 142| 1|#define YY_BUF_SIZE 16384 ------------------ 2431| 1| } 2432| | 2433| 1| yy_load_buffer_state( ); 2434| 1| } 2435| | 2436| 2.08k| { 2437| 2.08k|#line 156 "scan.l" 2438| | 2439| 2.08k|#line 158 "scan.l" 2440| 2.08k| static int bracelevel, didadef, indented_code; 2441| 2.08k| static bool doing_rule_action = false; ------------------ | | 82| 2.08k|# define false 0 ------------------ 2442| 2.08k| static bool option_sense; 2443| | 2444| 2.08k| static bool doing_codeblock = false; ------------------ | | 82| 2.08k|# define false 0 ------------------ 2445| 2.08k| int brace_depth=0, brace_start_line=0; 2446| 2.08k| char nmdef[MAXLINE]; 2447| | 2448| | 2449| 2.08k|#line 2450 "scan.c" 2450| | 2451| 3.07M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (2451:23): [True: 3.07M, Folded] ------------------ 2452| 3.07M| { 2453| 3.07M| yy_cp = (yy_c_buf_p); 2454| | 2455| | /* Support of yytext. */ 2456| 3.07M| *yy_cp = (yy_hold_char); 2457| | 2458| | /* yy_bp points to the position in yy_ch_buf of the start of 2459| | * the current run. 2460| | */ 2461| 3.07M| yy_bp = yy_cp; 2462| | 2463| 3.07M| yy_current_state = (yy_start); 2464| 3.07M| yy_current_state += YY_AT_BOL(); ------------------ | | 325| 3.07M|#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) | | ------------------ | | | | 268| 3.07M|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ ------------------ 2465| 6.48M|yy_match: 2466| 6.48M| do 2467| 42.1M| { 2468| 42.1M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 114| 42.1M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 2469| 42.1M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (2469:9): [True: 42.1M, False: 3.29k] ------------------ 2470| 42.1M| { 2471| 42.1M| (yy_last_accepting_state) = yy_current_state; 2472| 42.1M| (yy_last_accepting_cpos) = yy_cp; 2473| 42.1M| } 2474| 81.0M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (2474:12): [True: 38.8M, False: 42.1M] ------------------ 2475| 38.8M| { 2476| 38.8M| yy_current_state = (int) yy_def[yy_current_state]; 2477| 38.8M| if ( yy_current_state >= 1336 ) ------------------ | Branch (2477:10): [True: 33.6M, False: 5.20M] ------------------ 2478| 33.6M| yy_c = yy_meta[yy_c]; 2479| 38.8M| } 2480| 42.1M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2481| 42.1M| ++yy_cp; 2482| 42.1M| } 2483| 42.1M| while ( yy_base[yy_current_state] != 5176 ); ------------------ | Branch (2483:11): [True: 35.7M, False: 6.48M] ------------------ 2484| | 2485| 6.57M|yy_find_action: 2486| 6.57M| yy_act = yy_accept[yy_current_state]; 2487| 6.57M| if ( yy_act == 0 ) ------------------ | Branch (2487:8): [True: 4.48M, False: 2.08M] ------------------ 2488| 4.48M| { /* have to back up */ 2489| 4.48M| yy_cp = (yy_last_accepting_cpos); 2490| 4.48M| yy_current_state = (yy_last_accepting_state); 2491| 4.48M| yy_act = yy_accept[yy_current_state]; 2492| 4.48M| } 2493| | 2494| 6.57M| YY_DO_BEFORE_ACTION; ------------------ | | 352| 6.57M| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 341| 6.57M|#define yytext_ptr yytext | | ------------------ | | 353| 6.57M| yyleng = (int) (yy_cp - yy_bp); \ | | 354| 6.57M| (yy_hold_char) = *yy_cp; \ | | 355| 6.57M| *yy_cp = '\0'; \ | | 356| 6.57M| (yy_c_buf_p) = yy_cp; ------------------ 2495| | 2496| 6.57M|do_action: /* This label is used only to access EOF actions. */ 2497| | 2498| 6.57M| switch ( yy_act ) 2499| 6.57M| { /* beginning of action switch */ 2500| 0| case 0: /* must back up */ ------------------ | Branch (2500:4): [True: 0, False: 6.57M] ------------------ 2501| | /* undo the effects of YY_DO_BEFORE_ACTION */ 2502| 0| *yy_cp = (yy_hold_char); 2503| 0| yy_cp = (yy_last_accepting_cpos); 2504| 0| yy_current_state = (yy_last_accepting_state); 2505| 0| goto yy_find_action; 2506| | 2507| 2|case 1: ------------------ | Branch (2507:1): [True: 2, False: 6.57M] ------------------ 2508| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 2509| 2|#line 168 "scan.l" 2510| 2|START_CODEBLOCK(true); ------------------ | | 2159| 2|#define START_CODEBLOCK(x) do { \ | | 2160| 2| /* Emit the needed line directive... */\ | | 2161| 2| if (indented_code == false) { \ | | ------------------ | | | | 82| 2|# define false 0 | | ------------------ | | | Branch (2161:9): [True: 1, False: 1] | | ------------------ | | 2162| 1| if (!x) linenum++; \ | | ------------------ | | | Branch (2162:13): [Folded, False: 1] | | ------------------ | | 2163| 1| line_directive_out(NULL, infilename, linenum); \ | | 2164| 1| } \ | | 2165| 2| add_action(M4QSTART); \ | | ------------------ | | | | 2110| 2|#define M4QSTART "[""[" | | ------------------ | | 2166| 2| yy_push_state(CODEBLOCK); \ | | ------------------ | | | | 2189| 2|#define CODEBLOCK 4 | | ------------------ | | 2167| 2| if ((indented_code = x)) ACTION_ECHO; \ | | ------------------ | | | | 2116| 2|#define ACTION_ECHO add_action( yytext ) | | ------------------ | | | Branch (2167:9): [True: 2, False: 0] | | ------------------ | | 2168| 2|} while(0) | | ------------------ | | | Branch (2168:9): [Folded, False: 2] | | ------------------ ------------------ 2511| 2| YY_BREAK ------------------ | | 2393| 2|#define YY_BREAK /*LINTED*/break; ------------------ 2512| 0|case 2: ------------------ | Branch (2512:1): [True: 0, False: 6.57M] ------------------ 2513| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2514| 0|#line 169 "scan.l" 2515| 0|add_action("/*[""["); yy_push_state( COMMENT ); ------------------ | | 2199| 0|#define COMMENT 14 ------------------ 2516| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2517| 0|case 3: ------------------ | Branch (2517:1): [True: 0, False: 6.57M] ------------------ 2518| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2519| 0|#line 170 "scan.l" 2520| 0|yy_push_state( LINEDIR ); ------------------ | | 2203| 0|#define LINEDIR 18 ------------------ 2521| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2522| 0|case 4: ------------------ | Branch (2522:1): [True: 0, False: 6.57M] ------------------ 2523| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2524| 0|#line 171 "scan.l" 2525| 0|return SCDECL; ------------------ | | 112| 0|#define SCDECL 261 ------------------ 2526| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2527| 0|case 5: ------------------ | Branch (2527:1): [True: 0, False: 6.57M] ------------------ 2528| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2529| 0|#line 172 "scan.l" 2530| 0|return XSCDECL; ------------------ | | 113| 0|#define XSCDECL 262 ------------------ 2531| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2532| 0|case 6: ------------------ | Branch (2532:1): [True: 0, False: 6.57M] ------------------ 2533| |/* rule 6 can match eol */ 2534| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2535| 0|#line 173 "scan.l" 2536| 0|START_CODEBLOCK(false); ------------------ | | 2159| 0|#define START_CODEBLOCK(x) do { \ | | 2160| 0| /* Emit the needed line directive... */\ | | 2161| 0| if (indented_code == false) { \ | | ------------------ | | | | 82| 0|# define false 0 | | ------------------ | | | Branch (2161:9): [True: 0, False: 0] | | ------------------ | | 2162| 0| if (!x) linenum++; \ | | ------------------ | | | Branch (2162:13): [True: 0, Folded] | | ------------------ | | 2163| 0| line_directive_out(NULL, infilename, linenum); \ | | 2164| 0| } \ | | 2165| 0| add_action(M4QSTART); \ | | ------------------ | | | | 2110| 0|#define M4QSTART "[""[" | | ------------------ | | 2166| 0| yy_push_state(CODEBLOCK); \ | | ------------------ | | | | 2189| 0|#define CODEBLOCK 4 | | ------------------ | | 2167| 0| if ((indented_code = x)) ACTION_ECHO; \ | | ------------------ | | | | 2116| 0|#define ACTION_ECHO add_action( yytext ) | | ------------------ | | | Branch (2167:9): [True: 0, False: 0] | | ------------------ | | 2168| 0|} while(0) | | ------------------ | | | Branch (2168:9): [Folded, False: 0] | | ------------------ ------------------ 2537| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2538| 0|case 7: ------------------ | Branch (2538:1): [True: 0, False: 6.57M] ------------------ 2539| |/* rule 7 can match eol */ 2540| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2541| 0|#line 174 "scan.l" 2542| 0|{ 2543| 0| char trampoline[512]; 2544| 0| brace_start_line = linenum; 2545| 0| ++linenum; 2546| 0| snprintf(trampoline, sizeof(trampoline), 2547| 0| "M4_HOOK_TRACE_LINE_FORMAT(%d, [[%s]])", 2548| 0| linenum, infilename?infilename:""); ------------------ | Branch (2548:14): [True: 0, False: 0] ------------------ 2549| 0| if (ctrl.gen_line_dirs) ------------------ | Branch (2549:21): [True: 0, False: 0] ------------------ 2550| 0| buf_strappend(&top_buf, trampoline); 2551| 0| brace_depth = 1; 2552| 0| yy_push_state(CODEBLOCK_MATCH_BRACE); ------------------ | | 2204| 0|#define CODEBLOCK_MATCH_BRACE 19 ------------------ 2553| 0| } 2554| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2555| 0|case 8: ------------------ | Branch (2555:1): [True: 0, False: 6.57M] ------------------ 2556| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2557| 0|#line 187 "scan.l" 2558| 0|synerr( _("malformed '%top' directive") ); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 2559| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2560| 1|case 9: ------------------ | Branch (2560:1): [True: 1, False: 6.57M] ------------------ 2561| 1|YY_RULE_SETUP ------------------ | | 2397| 1| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 1, False: 0] | | ------------------ | | 2398| 1| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 1| (yytext[yyleng - 1] == '\n'); \ | | 2400| 1| YY_USER_ACTION ------------------ 2562| 1|#line 189 "scan.l" 2563| |/* discard */ 2564| 1| YY_BREAK ------------------ | | 2393| 1|#define YY_BREAK /*LINTED*/break; ------------------ 2565| 1|case 10: ------------------ | Branch (2565:1): [True: 1, False: 6.57M] ------------------ 2566| 1|YY_RULE_SETUP ------------------ | | 2397| 1| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 1, False: 0] | | ------------------ | | 2398| 1| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 1| (yytext[yyleng - 1] == '\n'); \ | | 2400| 1| YY_USER_ACTION ------------------ 2567| 1|#line 191 "scan.l" 2568| 1|{ 2569| 1| sectnum = 2; 2570| 1| bracelevel = 0; 2571| 1| mark_defs1(); 2572| 1| line_directive_out(NULL, infilename, linenum); 2573| 1| BEGIN(SECT2PROLOG); ------------------ | | 120| 1|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2PROLOG); ------------------ | | 2187| 1|#define SECT2PROLOG 2 ------------------ 2574| 1| return SECTEND; ------------------ | | 111| 1|#define SECTEND 260 ------------------ 2575| 0| } 2576| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2577| 0|case 11: ------------------ | Branch (2577:1): [True: 0, False: 6.57M] ------------------ 2578| |/* rule 11 can match eol */ 2579| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2580| 0|#line 200 "scan.l" 2581| 0|ctrl.yytext_is_array = false; ++linenum; ------------------ | | 82| 0|# define false 0 ------------------ 2582| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2583| 0|case 12: ------------------ | Branch (2583:1): [True: 0, False: 6.57M] ------------------ 2584| |/* rule 12 can match eol */ 2585| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2586| 0|#line 201 "scan.l" 2587| 0|ctrl.yytext_is_array = true; ++linenum; ------------------ | | 83| 0|# define true 1 ------------------ 2588| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2589| 0|case 13: ------------------ | Branch (2589:1): [True: 0, False: 6.57M] ------------------ 2590| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2591| 0|#line 203 "scan.l" 2592| 0|BEGIN(OPTION); return TOK_OPTION; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(OPTION); return TOK_OPTION; ------------------ | | 2202| 0|#define OPTION 17 ------------------ BEGIN(OPTION); return TOK_OPTION; ------------------ | | 117| 0|#define TOK_OPTION 266 ------------------ 2593| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2594| 0|case 14: ------------------ | Branch (2594:1): [True: 0, False: 6.57M] ------------------ 2595| |/* rule 14 can match eol */ 2596| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2597| 0|#line 205 "scan.l" 2598| 0|++linenum; /* ignore */ 2599| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2600| 0|case 15: ------------------ | Branch (2600:1): [True: 0, False: 6.57M] ------------------ 2601| |/* rule 15 can match eol */ 2602| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2603| 0|#line 206 "scan.l" 2604| 0|++linenum; /* ignore */ 2605| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2606| |/* xgettext: no-c-format */ 2607| 1|case 16: ------------------ | Branch (2607:1): [True: 1, False: 6.57M] ------------------ 2608| |/* rule 16 can match eol */ 2609| 1|YY_RULE_SETUP ------------------ | | 2397| 1| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 1, False: 0] | | ------------------ | | 2398| 1| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 1| (yytext[yyleng - 1] == '\n'); \ | | 2400| 1| YY_USER_ACTION ------------------ 2610| 1|#line 209 "scan.l" 2611| 1|synerr( _( "unrecognized '%' directive" ) ); ------------------ | | 102| 1|#define _(STRING) STRING ------------------ 2612| 1| YY_BREAK ------------------ | | 2393| 1|#define YY_BREAK /*LINTED*/break; ------------------ 2613| 5|case 17: ------------------ | Branch (2613:1): [True: 5, False: 6.57M] ------------------ 2614| 5|YY_RULE_SETUP ------------------ | | 2397| 5| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 5, False: 0] | | ------------------ | | 2398| 5| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 5|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 5| (yytext[yyleng - 1] == '\n'); \ | | 2400| 5| YY_USER_ACTION ------------------ 2615| 5|#line 211 "scan.l" 2616| 5|{ 2617| 5| if(yyleng < MAXLINE) ------------------ | | 114| 5|#define MAXLINE 2048 ------------------ | Branch (2617:7): [True: 5, False: 0] ------------------ 2618| 5| { 2619| 5| strncpy( nmstr, yytext, sizeof(nmstr) ); 2620| 5| } 2621| 0| else 2622| 0| { 2623| 0| synerr( _("Definition name too long\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 2624| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 2625| 0| } 2626| | 2627| 5| didadef = false; ------------------ | | 82| 5|# define false 0 ------------------ 2628| 5| BEGIN(PICKUPDEF); ------------------ | | 120| 5|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(PICKUPDEF); ------------------ | | 2190| 5|#define PICKUPDEF 5 ------------------ 2629| 5| } 2630| 5| YY_BREAK ------------------ | | 2393| 5|#define YY_BREAK /*LINTED*/break; ------------------ 2631| 1|case 18: ------------------ | Branch (2631:1): [True: 1, False: 6.57M] ------------------ 2632| 1|YY_RULE_SETUP ------------------ | | 2397| 1| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 1, False: 0] | | ------------------ | | 2398| 1| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 1| (yytext[yyleng - 1] == '\n'); \ | | 2400| 1| YY_USER_ACTION ------------------ 2633| 1|#line 226 "scan.l" 2634| 1|RETURNNAME; ------------------ | | 2130| 1| if(yyleng < MAXLINE) \ | | ------------------ | | | | 114| 1|#define MAXLINE 2048 | | ------------------ | | | Branch (2130:5): [True: 1, False: 0] | | ------------------ | | 2131| 1| { \ | | 2132| 1| strncpy( nmstr, yytext, sizeof(nmstr) ); \ | | 2133| 1| return NAME; \ | | ------------------ | | | | 114| 1|#define NAME 263 | | ------------------ | | 2134| 1| } \ | | 2135| 1| else \ | | 2136| 1| do { \ | | 2137| 0| synerr(_("Input line too long\n")); \ | | ------------------ | | | | 102| 0|#define _(STRING) STRING | | ------------------ | | 2138| 0| FLEX_EXIT(EXIT_FAILURE); \ | | ------------------ | | | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) | | ------------------ | | 2139| 0| } while (0) | | ------------------ | | | Branch (2139:12): [Folded, False: 0] | | ------------------ ------------------ 2635| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2636| 7|case 19: ------------------ | Branch (2636:1): [True: 7, False: 6.57M] ------------------ 2637| |/* rule 19 can match eol */ 2638| 7|YY_RULE_SETUP ------------------ | | 2397| 7| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 7, False: 0] | | ------------------ | | 2398| 7| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 7|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 7| (yytext[yyleng - 1] == '\n'); \ | | 2400| 7| YY_USER_ACTION ------------------ 2639| 7|#line 227 "scan.l" 2640| 7|++linenum; /* allows blank lines in section 1 */ 2641| 7| YY_BREAK ------------------ | | 2393| 7|#define YY_BREAK /*LINTED*/break; ------------------ 2642| 2|case 20: ------------------ | Branch (2642:1): [True: 2, False: 6.57M] ------------------ 2643| |/* rule 20 can match eol */ 2644| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 2645| 2|#line 228 "scan.l" 2646| 2|ACTION_ECHO; ++linenum; /* maybe end of comment line */ ------------------ | | 2116| 2|#define ACTION_ECHO add_action( yytext ) ------------------ 2647| 2| YY_BREAK ------------------ | | 2393| 2|#define YY_BREAK /*LINTED*/break; ------------------ 2648| | 2649| |/* */ 2650| 209|case 21: ------------------ | Branch (2650:1): [True: 209, False: 6.57M] ------------------ 2651| 209|YY_RULE_SETUP ------------------ | | 2397| 209| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 209, False: 0] | | ------------------ | | 2398| 209| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 209|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 209| (yytext[yyleng - 1] == '\n'); \ | | 2400| 209| YY_USER_ACTION ------------------ 2652| 209|#line 233 "scan.l" 2653| 209|ACTION_ECHO; ------------------ | | 2116| 209|#define ACTION_ECHO add_action( yytext ) ------------------ 2654| 209| YY_BREAK ------------------ | | 2393| 209|#define YY_BREAK /*LINTED*/break; ------------------ 2655| 133|case 22: ------------------ | Branch (2655:1): [True: 133, False: 6.57M] ------------------ 2656| 133|YY_RULE_SETUP ------------------ | | 2397| 133| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 133, False: 0] | | ------------------ | | 2398| 133| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 133|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 133| (yytext[yyleng - 1] == '\n'); \ | | 2400| 133| YY_USER_ACTION ------------------ 2657| 133|#line 234 "scan.l" 2658| 133|ACTION_ECHO; ------------------ | | 2116| 133|#define ACTION_ECHO add_action( yytext ) ------------------ 2659| 133| YY_BREAK ------------------ | | 2393| 133|#define YY_BREAK /*LINTED*/break; ------------------ 2660| 106|case 23: ------------------ | Branch (2660:1): [True: 106, False: 6.57M] ------------------ 2661| |/* rule 23 can match eol */ 2662| 106|YY_RULE_SETUP ------------------ | | 2397| 106| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 106, False: 0] | | ------------------ | | 2398| 106| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 106|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 106| (yytext[yyleng - 1] == '\n'); \ | | 2400| 106| YY_USER_ACTION ------------------ 2663| 106|#line 236 "scan.l" 2664| 106|++linenum; ACTION_ECHO; ------------------ | | 2116| 106|#define ACTION_ECHO add_action( yytext ) ------------------ 2665| 106| YY_BREAK ------------------ | | 2393| 106|#define YY_BREAK /*LINTED*/break; ------------------ 2666| | 2667| | 2668| 0|case 24: ------------------ | Branch (2668:1): [True: 0, False: 6.57M] ------------------ 2669| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2670| 0|#line 239 "scan.l" 2671| 0|add_action("*/]""]"); yy_pop_state(); 2672| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2673| | 2674| | 2675| 4|case 25: ------------------ | Branch (2675:1): [True: 4, False: 6.57M] ------------------ 2676| 4|YY_RULE_SETUP ------------------ | | 2397| 4| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 4, False: 0] | | ------------------ | | 2398| 4| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 4|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 4| (yytext[yyleng - 1] == '\n'); \ | | 2400| 4| YY_USER_ACTION ------------------ 2677| 4|#line 242 "scan.l" 2678| 4|ACTION_ECHO; yy_pop_state(); ------------------ | | 2116| 4|#define ACTION_ECHO add_action( yytext ) ------------------ 2679| 4| YY_BREAK ------------------ | | 2393| 4|#define YY_BREAK /*LINTED*/break; ------------------ 2680| | 2681| | 2682| |/* This is the same as COMMENT, but is discarded rather than output. */ 2683| 0|case 26: ------------------ | Branch (2683:1): [True: 0, False: 6.57M] ------------------ 2684| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2685| 0|#line 247 "scan.l" 2686| 0|yy_pop_state(); 2687| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2688| 0|case 27: ------------------ | Branch (2688:1): [True: 0, False: 6.57M] ------------------ 2689| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2690| 0|#line 248 "scan.l" 2691| 0|; 2692| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2693| 0|case 28: ------------------ | Branch (2693:1): [True: 0, False: 6.57M] ------------------ 2694| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2695| 0|#line 249 "scan.l" 2696| 0|; 2697| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2698| 0|case 29: ------------------ | Branch (2698:1): [True: 0, False: 6.57M] ------------------ 2699| |/* rule 29 can match eol */ 2700| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2701| 0|#line 250 "scan.l" 2702| 0|++linenum; 2703| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2704| | 2705| | 2706| 0|case 30: ------------------ | Branch (2706:1): [True: 0, False: 6.57M] ------------------ 2707| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2708| 0|#line 254 "scan.l" 2709| 0|yy_pop_state(); 2710| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2711| 0|case 31: ------------------ | Branch (2711:1): [True: 0, False: 6.57M] ------------------ 2712| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2713| 0|#line 255 "scan.l" 2714| 0|; 2715| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2716| 0|case 32: ------------------ | Branch (2716:1): [True: 0, False: 6.57M] ------------------ 2717| |/* rule 32 can match eol */ 2718| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2719| 0|#line 256 "scan.l" 2720| 0|++linenum; 2721| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2722| | 2723| | 2724| 0|case 33: ------------------ | Branch (2724:1): [True: 0, False: 6.57M] ------------------ 2725| |/* rule 33 can match eol */ 2726| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2727| 0|#line 260 "scan.l" 2728| 0|yy_pop_state(); 2729| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2730| 0|case 34: ------------------ | Branch (2730:1): [True: 0, False: 6.57M] ------------------ 2731| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2732| 0|#line 261 "scan.l" 2733| 0|linenum = myctoi( yytext ); 2734| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2735| 0|case 35: ------------------ | Branch (2735:1): [True: 0, False: 6.57M] ------------------ 2736| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2737| 0|#line 263 "scan.l" 2738| 0|{ 2739| 0| free(infilename); 2740| 0| infilename = xstrdup(yytext + 1); 2741| 0| infilename[strlen( infilename ) - 1] = '\0'; 2742| 0| } 2743| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2744| 0|case 36: ------------------ | Branch (2744:1): [True: 0, False: 6.57M] ------------------ 2745| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2746| 0|#line 268 "scan.l" 2747| |/* ignore spurious characters */ 2748| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2749| | 2750| | 2751| 86|case 37: ------------------ | Branch (2751:1): [True: 86, False: 6.57M] ------------------ 2752| 86|YY_RULE_SETUP ------------------ | | 2397| 86| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 86, False: 0] | | ------------------ | | 2398| 86| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 86|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 86| (yytext[yyleng - 1] == '\n'); \ | | 2400| 86| YY_USER_ACTION ------------------ 2753| 86|#line 271 "scan.l" 2754| 86|ACTION_ECHO_QSTART; ------------------ | | 2117| 86|#define ACTION_ECHO_QSTART add_action (ESCAPED_QSTART) | | ------------------ | | | | 2113| 86|#define ESCAPED_QSTART "[" M4QEND M4QSTART "[" M4QEND M4QSTART | | | | ------------------ | | | | | | 2110| 86|#define M4QSTART "[""[" | | | | ------------------ | | ------------------ ------------------ 2755| 86| YY_BREAK ------------------ | | 2393| 86|#define YY_BREAK /*LINTED*/break; ------------------ 2756| 55|case 38: ------------------ | Branch (2756:1): [True: 55, False: 6.57M] ------------------ 2757| 55|YY_RULE_SETUP ------------------ | | 2397| 55| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 55, False: 0] | | ------------------ | | 2398| 55| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 55|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 55| (yytext[yyleng - 1] == '\n'); \ | | 2400| 55| YY_USER_ACTION ------------------ 2758| 55|#line 272 "scan.l" 2759| 55|ACTION_ECHO_QEND; ------------------ | | 2118| 55|#define ACTION_ECHO_QEND add_action (ESCAPED_QEND) | | ------------------ | | | | 2114| 55|#define ESCAPED_QEND M4QEND "]" M4QSTART M4QEND "]" M4QSTART | | | | ------------------ | | | | | | 2111| 55|#define M4QEND "]""]" | | | | ------------------ | | | | #define ESCAPED_QEND M4QEND "]" M4QSTART M4QEND "]" M4QSTART | | | | ------------------ | | | | | | 2110| 55|#define M4QSTART "[""[" | | | | ------------------ | | ------------------ ------------------ 2760| 55| YY_BREAK ------------------ | | 2393| 55|#define YY_BREAK /*LINTED*/break; ------------------ 2761| | 2762| | 2763| 0|case 39: ------------------ | Branch (2763:1): [True: 0, False: 6.57M] ------------------ 2764| |/* rule 39 can match eol */ 2765| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2766| 0|#line 276 "scan.l" 2767| 0|++linenum; END_CODEBLOCK; ------------------ | | 2170| 0|#define END_CODEBLOCK do { \ | | 2171| 0| yy_pop_state();\ | | 2172| 0| add_action(M4QEND); \ | | ------------------ | | | | 2111| 0|#define M4QEND "]""]" | | ------------------ | | 2173| 0| if (!indented_code) line_directive_out(NULL, NULL, linenum); \ | | ------------------ | | | Branch (2173:9): [True: 0, False: 0] | | ------------------ | | 2174| 0|} while (0) | | ------------------ | | | Branch (2174:10): [Folded, False: 0] | | ------------------ ------------------ 2768| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2769| 3|case 40: ------------------ | Branch (2769:1): [True: 3, False: 6.57M] ------------------ 2770| 3|YY_RULE_SETUP ------------------ | | 2397| 3| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 3, False: 0] | | ------------------ | | 2398| 3| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 3|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 3| (yytext[yyleng - 1] == '\n'); \ | | 2400| 3| YY_USER_ACTION ------------------ 2771| 3|#line 277 "scan.l" 2772| 3|ACTION_ECHO; ------------------ | | 2116| 3|#define ACTION_ECHO add_action( yytext ) ------------------ 2773| 3| YY_BREAK ------------------ | | 2393| 3|#define YY_BREAK /*LINTED*/break; ------------------ 2774| 1|case 41: ------------------ | Branch (2774:1): [True: 1, False: 6.57M] ------------------ 2775| 1|YY_RULE_SETUP ------------------ | | 2397| 1| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 1, False: 0] | | ------------------ | | 2398| 1| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 1| (yytext[yyleng - 1] == '\n'); \ | | 2400| 1| YY_USER_ACTION ------------------ 2776| 1|#line 278 "scan.l" 2777| 1|ACTION_ECHO; ------------------ | | 2116| 1|#define ACTION_ECHO add_action( yytext ) ------------------ 2778| 1| YY_BREAK ------------------ | | 2393| 1|#define YY_BREAK /*LINTED*/break; ------------------ 2779| 2|case 42: ------------------ | Branch (2779:1): [True: 2, False: 6.57M] ------------------ 2780| |/* rule 42 can match eol */ 2781| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 2782| 2|#line 279 "scan.l" 2783| 2|{ 2784| 2| ++linenum; 2785| 2| ACTION_ECHO; ------------------ | | 2116| 2|#define ACTION_ECHO add_action( yytext ) ------------------ 2786| 2| if ( indented_code ) END_CODEBLOCK; ------------------ | | 2170| 2|#define END_CODEBLOCK do { \ | | 2171| 2| yy_pop_state();\ | | 2172| 2| add_action(M4QEND); \ | | ------------------ | | | | 2111| 2|#define M4QEND "]""]" | | ------------------ | | 2173| 2| if (!indented_code) line_directive_out(NULL, NULL, linenum); \ | | ------------------ | | | Branch (2173:9): [True: 0, False: 2] | | ------------------ | | 2174| 2|} while (0) | | ------------------ | | | Branch (2174:10): [Folded, False: 2] | | ------------------ ------------------ | Branch (2786:9): [True: 2, False: 0] ------------------ 2787| 2| } 2788| 2| YY_BREAK ------------------ | | 2393| 2|#define YY_BREAK /*LINTED*/break; ------------------ 2789| | 2790| | 2791| 0|case 43: ------------------ | Branch (2791:1): [True: 0, False: 6.57M] ------------------ 2792| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2793| 0|#line 287 "scan.l" 2794| 0|{ 2795| 0| if( --brace_depth == 0){ ------------------ | Branch (2795:21): [True: 0, False: 0] ------------------ 2796| | /* TODO: Matched. */ 2797| 0| yy_pop_state(); 2798| 0| }else 2799| 0| buf_strnappend(&top_buf, yytext, yyleng); 2800| 0| } 2801| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2802| 0|case 44: ------------------ | Branch (2802:1): [True: 0, False: 6.57M] ------------------ 2803| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2804| 0|#line 295 "scan.l" 2805| 0|{ 2806| 0| brace_depth++; 2807| 0| buf_strnappend(&top_buf, yytext, yyleng); 2808| 0| } 2809| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2810| 0|case 45: ------------------ | Branch (2810:1): [True: 0, False: 6.57M] ------------------ 2811| |/* rule 45 can match eol */ 2812| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2813| 0|#line 300 "scan.l" 2814| 0|{ 2815| 0| ++linenum; 2816| 0| buf_strnappend(&top_buf, yytext, yyleng); 2817| 0| } 2818| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2819| 0|case 46: ------------------ | Branch (2819:1): [True: 0, False: 6.57M] ------------------ 2820| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2821| 0|#line 305 "scan.l" 2822| 0|buf_strnappend(&top_buf, escaped_qstart, (int) strlen(escaped_qstart)); 2823| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2824| 0|case 47: ------------------ | Branch (2824:1): [True: 0, False: 6.57M] ------------------ 2825| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2826| 0|#line 306 "scan.l" 2827| 0|buf_strnappend(&top_buf, escaped_qend, (int) strlen(escaped_qend)); 2828| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2829| 0|case 48: ------------------ | Branch (2829:1): [True: 0, False: 6.57M] ------------------ 2830| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2831| 0|#line 307 "scan.l" 2832| 0|{ 2833| 0| buf_strnappend(&top_buf, yytext, yyleng); 2834| 0| } 2835| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2836| 0|case YY_STATE_EOF(CODEBLOCK_MATCH_BRACE): ------------------ | | 128| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (2836:1): [True: 0, False: 6.57M] ------------------ 2837| 0|#line 311 "scan.l" 2838| 0|{ 2839| 0| linenum = brace_start_line; 2840| 0| synerr(_("Unmatched '{'")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 2841| 0| return YY_NULL; ------------------ | | 109| 0|#define YY_NULL 0 ------------------ 2842| 1| } 2843| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2844| | 2845| | 2846| 6|case 49: ------------------ | Branch (2846:1): [True: 6, False: 6.57M] ------------------ 2847| 6|YY_RULE_SETUP ------------------ | | 2397| 6| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 6, False: 0] | | ------------------ | | 2398| 6| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 6|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 6| (yytext[yyleng - 1] == '\n'); \ | | 2400| 6| YY_USER_ACTION ------------------ 2848| 6|#line 320 "scan.l" 2849| |/* separates name and definition */ 2850| 6| YY_BREAK ------------------ | | 2393| 6|#define YY_BREAK /*LINTED*/break; ------------------ 2851| 37|case 50: ------------------ | Branch (2851:1): [True: 37, False: 6.57M] ------------------ 2852| 37|YY_RULE_SETUP ------------------ | | 2397| 37| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 37, False: 0] | | ------------------ | | 2398| 37| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 37|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 37| (yytext[yyleng - 1] == '\n'); \ | | 2400| 37| YY_USER_ACTION ------------------ 2853| 37|#line 322 "scan.l" 2854| 37|{ 2855| 37| if(yyleng < MAXLINE) ------------------ | | 114| 37|#define MAXLINE 2048 ------------------ | Branch (2855:15): [True: 37, False: 0] ------------------ 2856| 37| { 2857| 37| strncpy( nmdef, yytext, sizeof(nmdef) ); 2858| 37| } 2859| 0| else 2860| 0| { 2861| 0| format_synerr( _("Definition value for {%s} too long\n"), nmstr); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 2862| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 2863| 0| } 2864| | /* Skip trailing whitespace. */ 2865| 37| { 2866| 37| size_t i = strlen( nmdef ); 2867| 37| while (i > 0 && (nmdef[i-1] == ' ' || nmdef[i-1] == '\t')) ------------------ | Branch (2867:15): [True: 26, False: 11] | Branch (2867:25): [True: 0, False: 26] | Branch (2867:46): [True: 0, False: 26] ------------------ 2868| 0| --i; 2869| 37| nmdef[i] = '\0'; 2870| 37| } 2871| | 2872| 37| ndinstal( nmstr, nmdef ); 2873| 37| didadef = true; ------------------ | | 83| 37|# define true 1 ------------------ 2874| 37| } 2875| 37| YY_BREAK ------------------ | | 2393| 37|#define YY_BREAK /*LINTED*/break; ------------------ 2876| 5|case 51: ------------------ | Branch (2876:1): [True: 5, False: 6.57M] ------------------ 2877| |/* rule 51 can match eol */ 2878| 5|YY_RULE_SETUP ------------------ | | 2397| 5| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 5, False: 0] | | ------------------ | | 2398| 5| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 5|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 5| (yytext[yyleng - 1] == '\n'); \ | | 2400| 5| YY_USER_ACTION ------------------ 2879| 5|#line 344 "scan.l" 2880| 5|{ 2881| 5| if ( ! didadef ) ------------------ | Branch (2881:9): [True: 0, False: 5] ------------------ 2882| 0| synerr( _( "incomplete name definition" ) ); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 2883| 5| BEGIN(INITIAL); ------------------ | | 120| 5|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 2185| 5|#define INITIAL 0 ------------------ 2884| 5| ++linenum; 2885| 5| } 2886| 5| YY_BREAK ------------------ | | 2393| 5|#define YY_BREAK /*LINTED*/break; ------------------ 2887| | 2888| | 2889| 0|case 52: ------------------ | Branch (2889:1): [True: 0, False: 6.57M] ------------------ 2890| |/* rule 52 can match eol */ 2891| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2892| 0|#line 354 "scan.l" 2893| 0|++linenum; BEGIN(INITIAL); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ ++linenum; BEGIN(INITIAL); ------------------ | | 2185| 0|#define INITIAL 0 ------------------ 2894| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2895| 0|case 53: ------------------ | Branch (2895:1): [True: 0, False: 6.57M] ------------------ 2896| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2897| 0|#line 355 "scan.l" 2898| 0|option_sense = true; ------------------ | | 83| 0|# define true 1 ------------------ 2899| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2900| 0|case 54: ------------------ | Branch (2900:1): [True: 0, False: 6.57M] ------------------ 2901| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2902| 0|#line 357 "scan.l" 2903| 0|return '='; 2904| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2905| 0|case 55: ------------------ | Branch (2905:1): [True: 0, False: 6.57M] ------------------ 2906| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2907| 0|#line 358 "scan.l" 2908| 0|{nmval = atoi(yytext); return TOK_NUMERIC;} ------------------ | | 125| 0|#define TOK_NUMERIC 274 ------------------ 2909| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2910| 0|case 56: ------------------ | Branch (2910:1): [True: 0, False: 6.57M] ------------------ 2911| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2912| 0|#line 360 "scan.l" 2913| 0|option_sense = ! option_sense; 2914| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2915| 0|case 57: ------------------ | Branch (2915:1): [True: 0, False: 6.57M] ------------------ 2916| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2917| 0|#line 362 "scan.l" 2918| 0|ctrl.csize = option_sense ? 128 : 256; ------------------ | Branch (2918:14): [True: 0, False: 0] ------------------ 2919| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2920| 0|case 58: ------------------ | Branch (2920:1): [True: 0, False: 6.57M] ------------------ 2921| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2922| 0|#line 363 "scan.l" 2923| 0|ctrl.csize = option_sense ? 256 : 128; ------------------ | Branch (2923:14): [True: 0, False: 0] ------------------ 2924| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2925| 0|case 59: ------------------ | Branch (2925:1): [True: 0, False: 6.57M] ------------------ 2926| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2927| 0|#line 365 "scan.l" 2928| 0|ctrl.long_align = option_sense; 2929| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2930| 0|case 60: ------------------ | Branch (2930:1): [True: 0, False: 6.57M] ------------------ 2931| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2932| 0|#line 366 "scan.l" 2933| 0|{ 2934| 0| ctrl.always_interactive = option_sense; 2935| 0| ctrl.interactive = (trit)option_sense; 2936| 0| } 2937| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2938| 0|case 61: ------------------ | Branch (2938:1): [True: 0, False: 6.57M] ------------------ 2939| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2940| 0|#line 370 "scan.l" 2941| 0|ctrl.yytext_is_array = option_sense; 2942| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2943| 0|case 62: ------------------ | Branch (2943:1): [True: 0, False: 6.57M] ------------------ 2944| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2945| 0|#line 371 "scan.l" 2946| 0|env.backing_up_report = option_sense; 2947| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2948| 0|case 63: ------------------ | Branch (2948:1): [True: 0, False: 6.57M] ------------------ 2949| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2950| 0|#line 372 "scan.l" 2951| 0|ctrl.interactive = (trit)!option_sense; 2952| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2953| 0|case 64: ------------------ | Branch (2953:1): [True: 0, False: 6.57M] ------------------ 2954| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2955| 0|#line 373 "scan.l" 2956| 0|ctrl.bison_bridge_lval = option_sense; 2957| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2958| 0|case 65: ------------------ | Branch (2958:1): [True: 0, False: 6.57M] ------------------ 2959| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2960| 0|#line 374 "scan.l" 2961| 0|{ if((ctrl.bison_bridge_lloc = option_sense)) ------------------ | Branch (2961:6): [True: 0, False: 0] ------------------ 2962| 0| ctrl.bison_bridge_lval = true; ------------------ | | 83| 0|# define true 1 ------------------ 2963| 0| } 2964| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2965| 0|case 66: ------------------ | Branch (2965:1): [True: 0, False: 6.57M] ------------------ 2966| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2967| 0|#line 377 "scan.l" 2968| 0|ctrl.C_plus_plus = option_sense; 2969| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2970| 0|case 67: ------------------ | Branch (2970:1): [True: 0, False: 6.57M] ------------------ 2971| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2972| 0|#line 378 "scan.l" 2973| 0|sf_set_case_ins(!option_sense); ------------------ | | 1188| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1188:34): [True: 0, False: 0] | | ------------------ ------------------ 2974| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2975| 0|case 68: ------------------ | Branch (2975:1): [True: 0, False: 6.57M] ------------------ 2976| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2977| 0|#line 379 "scan.l" 2978| 0|sf_set_case_ins(option_sense); ------------------ | | 1188| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1188:34): [True: 0, False: 0] | | ------------------ ------------------ 2979| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2980| 0|case 69: ------------------ | Branch (2980:1): [True: 0, False: 6.57M] ------------------ 2981| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2982| 0|#line 380 "scan.l" 2983| 0|ctrl.ddebug = option_sense; 2984| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2985| 0|case 70: ------------------ | Branch (2985:1): [True: 0, False: 6.57M] ------------------ 2986| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2987| 0|#line 381 "scan.l" 2988| 0|ctrl.spprdflt = ! option_sense; 2989| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2990| 0|case 71: ------------------ | Branch (2990:1): [True: 0, False: 6.57M] ------------------ 2991| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2992| 0|#line 382 "scan.l" 2993| 0|ctrl.useecs = option_sense; 2994| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2995| 0|case 72: ------------------ | Branch (2995:1): [True: 0, False: 6.57M] ------------------ 2996| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 2997| 0|#line 383 "scan.l" 2998| 0|{ 2999| 0| ctrl.useecs = ctrl.usemecs = false; ------------------ | | 82| 0|# define false 0 ------------------ 3000| 0| ctrl.use_read = ctrl.fullspd = true; ------------------ | | 83| 0|# define true 1 ------------------ 3001| 0| } 3002| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3003| 0|case 73: ------------------ | Branch (3003:1): [True: 0, False: 6.57M] ------------------ 3004| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3005| 0|#line 387 "scan.l" 3006| 0|{ 3007| 0| ctrl.useecs = ctrl.usemecs = false; ------------------ | | 82| 0|# define false 0 ------------------ 3008| 0| ctrl.use_read = ctrl.fulltbl = true; ------------------ | | 83| 0|# define true 1 ------------------ 3009| 0| } 3010| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3011| 0|case 74: ------------------ | Branch (3011:1): [True: 0, False: 6.57M] ------------------ 3012| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3013| 0|#line 391 "scan.l" 3014| 0|ctrl.no_yyinput = ! option_sense; 3015| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3016| 0|case 75: ------------------ | Branch (3016:1): [True: 0, False: 6.57M] ------------------ 3017| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3018| 0|#line 392 "scan.l" 3019| 0|ctrl.no_yyinput = ! option_sense; 3020| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3021| 0|case 76: ------------------ | Branch (3021:1): [True: 0, False: 6.57M] ------------------ 3022| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3023| 0|#line 393 "scan.l" 3024| 0|ctrl.interactive = (trit)option_sense; 3025| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3026| 0|case 77: ------------------ | Branch (3026:1): [True: 0, False: 6.57M] ------------------ 3027| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3028| 0|#line 394 "scan.l" 3029| 0|ctrl.lex_compat = option_sense; 3030| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3031| 0|case 78: ------------------ | Branch (3031:1): [True: 0, False: 6.57M] ------------------ 3032| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3033| 0|#line 395 "scan.l" 3034| 0|ctrl.posix_compat = option_sense; 3035| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3036| 0|case 79: ------------------ | Branch (3036:1): [True: 0, False: 6.57M] ------------------ 3037| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3038| 0|#line 396 "scan.l" 3039| 0|ctrl.gen_line_dirs = option_sense; 3040| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3041| 0|case 80: ------------------ | Branch (3041:1): [True: 0, False: 6.57M] ------------------ 3042| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3043| 0|#line 397 "scan.l" 3044| 0|{ 3045| 0| ctrl.do_main = option_sense; 3046| | /* Override yywrap */ 3047| 0| if (option_sense) ------------------ | Branch (3047:8): [True: 0, False: 0] ------------------ 3048| 0| ctrl.do_yywrap = false; ------------------ | | 82| 0|# define false 0 ------------------ 3049| 0| } 3050| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3051| 0|case 81: ------------------ | Branch (3051:1): [True: 0, False: 6.57M] ------------------ 3052| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3053| 0|#line 403 "scan.l" 3054| 0|ctrl.usemecs = option_sense; 3055| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3056| 0|case 82: ------------------ | Branch (3056:1): [True: 0, False: 6.57M] ------------------ 3057| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3058| 0|#line 404 "scan.l" 3059| 0|{ 3060| 0| ctrl.never_interactive = option_sense; 3061| 0| ctrl.interactive = (trit)!option_sense; 3062| 0| } 3063| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3064| 0|case 83: ------------------ | Branch (3064:1): [True: 0, False: 6.57M] ------------------ 3065| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3066| 0|#line 408 "scan.l" 3067| 0|env.performance_hint += option_sense ? 1 : -1; ------------------ | Branch (3067:25): [True: 0, False: 0] ------------------ 3068| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3069| 0|case 84: ------------------ | Branch (3069:1): [True: 0, False: 6.57M] ------------------ 3070| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3071| 0|#line 409 "scan.l" 3072| 0|ctrl.yytext_is_array = ! option_sense; 3073| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3074| 0|case 85: ------------------ | Branch (3074:1): [True: 0, False: 6.57M] ------------------ 3075| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3076| 0|#line 410 "scan.l" 3077| 0|ctrl.use_read = option_sense; 3078| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3079| 0|case 86: ------------------ | Branch (3079:1): [True: 0, False: 6.57M] ------------------ 3080| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3081| 0|#line 411 "scan.l" 3082| 0|ctrl.reentrant = option_sense; 3083| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3084| 0|case 87: ------------------ | Branch (3084:1): [True: 0, False: 6.57M] ------------------ 3085| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3086| 0|#line 412 "scan.l" 3087| 0|ctrl.reject_really_used = option_sense; 3088| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3089| 0|case 88: ------------------ | Branch (3089:1): [True: 0, False: 6.57M] ------------------ 3090| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3091| 0|#line 413 "scan.l" 3092| 0|ctrl.rewrite = option_sense; 3093| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3094| 0|case 89: ------------------ | Branch (3094:1): [True: 0, False: 6.57M] ------------------ 3095| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3096| 0|#line 414 "scan.l" 3097| 0|ctrl.stack_used = option_sense; 3098| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3099| 0|case 90: ------------------ | Branch (3099:1): [True: 0, False: 6.57M] ------------------ 3100| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3101| 0|#line 415 "scan.l" 3102| 0|ctrl.do_stdinit = option_sense; 3103| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3104| 0|case 91: ------------------ | Branch (3104:1): [True: 0, False: 6.57M] ------------------ 3105| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3106| 0|#line 416 "scan.l" 3107| 0|env.use_stdout = option_sense; 3108| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3109| 0|case 92: ------------------ | Branch (3109:1): [True: 0, False: 6.57M] ------------------ 3110| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3111| 0|#line 417 "scan.l" 3112| 0|ctrl.no_unistd = ! option_sense; 3113| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3114| 0|case 93: ------------------ | Branch (3114:1): [True: 0, False: 6.57M] ------------------ 3115| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3116| 0|#line 418 "scan.l" 3117| 0|ctrl.no_yyunput = ! option_sense; 3118| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3119| 0|case 94: ------------------ | Branch (3119:1): [True: 0, False: 6.57M] ------------------ 3120| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3121| 0|#line 419 "scan.l" 3122| 0|ctrl.no_yyunput = ! option_sense; 3123| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3124| 0|case 95: ------------------ | Branch (3124:1): [True: 0, False: 6.57M] ------------------ 3125| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3126| 0|#line 420 "scan.l" 3127| 0|env.printstats = option_sense; 3128| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3129| 0|case 96: ------------------ | Branch (3129:1): [True: 0, False: 6.57M] ------------------ 3130| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3131| 0|#line 421 "scan.l" 3132| 0|env.nowarn = ! option_sense; 3133| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3134| 0|case 97: ------------------ | Branch (3134:1): [True: 0, False: 6.57M] ------------------ 3135| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3136| 0|#line 422 "scan.l" 3137| 0|ctrl.do_yylineno = option_sense; 3138| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3139| 0|case 98: ------------------ | Branch (3139:1): [True: 0, False: 6.57M] ------------------ 3140| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3141| 0|#line 423 "scan.l" 3142| 0|ctrl.yymore_really_used = option_sense; 3143| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3144| 0|case 99: ------------------ | Branch (3144:1): [True: 0, False: 6.57M] ------------------ 3145| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3146| 0|#line 424 "scan.l" 3147| 0|ctrl.do_yywrap = option_sense; 3148| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3149| 0|case 100: ------------------ | Branch (3149:1): [True: 0, False: 6.57M] ------------------ 3150| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3151| 0|#line 425 "scan.l" 3152| 0|ctrl.noyyread = !option_sense; 3153| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3154| 0|case 101: ------------------ | Branch (3154:1): [True: 0, False: 6.57M] ------------------ 3155| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3156| 0|#line 427 "scan.l" 3157| 0|ctrl.no_yypanic = !option_sense; 3158| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3159| 0|case 102: ------------------ | Branch (3159:1): [True: 0, False: 6.57M] ------------------ 3160| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3161| 0|#line 429 "scan.l" 3162| 0|ctrl.no_yy_push_state = ! option_sense; 3163| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3164| 0|case 103: ------------------ | Branch (3164:1): [True: 0, False: 6.57M] ------------------ 3165| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3166| 0|#line 430 "scan.l" 3167| 0|ctrl.no_yy_pop_state = ! option_sense; 3168| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3169| 0|case 104: ------------------ | Branch (3169:1): [True: 0, False: 6.57M] ------------------ 3170| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3171| 0|#line 431 "scan.l" 3172| 0|ctrl.no_yy_top_state = ! option_sense; 3173| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3174| 0|case 105: ------------------ | Branch (3174:1): [True: 0, False: 6.57M] ------------------ 3175| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3176| 0|#line 433 "scan.l" 3177| 0|ctrl.no_yy_scan_buffer = ! option_sense; 3178| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3179| 0|case 106: ------------------ | Branch (3179:1): [True: 0, False: 6.57M] ------------------ 3180| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3181| 0|#line 434 "scan.l" 3182| 0|ctrl.no_yy_scan_bytes = ! option_sense; 3183| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3184| 0|case 107: ------------------ | Branch (3184:1): [True: 0, False: 6.57M] ------------------ 3185| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3186| 0|#line 435 "scan.l" 3187| 0|ctrl.no_yy_scan_string = ! option_sense; 3188| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3189| 0|case 108: ------------------ | Branch (3189:1): [True: 0, False: 6.57M] ------------------ 3190| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3191| 0|#line 437 "scan.l" 3192| 0|ctrl.no_flex_alloc = ! option_sense; 3193| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3194| 0|case 109: ------------------ | Branch (3194:1): [True: 0, False: 6.57M] ------------------ 3195| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3196| 0|#line 438 "scan.l" 3197| 0|ctrl.no_flex_realloc = ! option_sense; 3198| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3199| 0|case 110: ------------------ | Branch (3199:1): [True: 0, False: 6.57M] ------------------ 3200| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3201| 0|#line 439 "scan.l" 3202| 0|ctrl.no_flex_free = ! option_sense; 3203| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3204| 0|case 111: ------------------ | Branch (3204:1): [True: 0, False: 6.57M] ------------------ 3205| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3206| 0|#line 441 "scan.l" 3207| 0|ctrl.no_get_debug = ! option_sense; 3208| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3209| 0|case 112: ------------------ | Branch (3209:1): [True: 0, False: 6.57M] ------------------ 3210| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3211| 0|#line 442 "scan.l" 3212| 0|ctrl.no_set_debug = ! option_sense; 3213| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3214| 0|case 113: ------------------ | Branch (3214:1): [True: 0, False: 6.57M] ------------------ 3215| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3216| 0|#line 443 "scan.l" 3217| 0|ctrl.no_yyget_extra = ! option_sense; 3218| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3219| 0|case 114: ------------------ | Branch (3219:1): [True: 0, False: 6.57M] ------------------ 3220| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3221| 0|#line 444 "scan.l" 3222| 0|ctrl.no_yyset_extra = ! option_sense; 3223| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3224| 0|case 115: ------------------ | Branch (3224:1): [True: 0, False: 6.57M] ------------------ 3225| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3226| 0|#line 445 "scan.l" 3227| 0|ctrl.no_yyget_leng = ! option_sense; 3228| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3229| 0|case 116: ------------------ | Branch (3229:1): [True: 0, False: 6.57M] ------------------ 3230| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3231| 0|#line 446 "scan.l" 3232| 0|ctrl.no_yyget_text = ! option_sense; 3233| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3234| 0|case 117: ------------------ | Branch (3234:1): [True: 0, False: 6.57M] ------------------ 3235| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3236| 0|#line 447 "scan.l" 3237| 0|ctrl.no_yyget_column = ! option_sense; 3238| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3239| 0|case 118: ------------------ | Branch (3239:1): [True: 0, False: 6.57M] ------------------ 3240| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3241| 0|#line 448 "scan.l" 3242| 0|ctrl.no_yyset_column = ! option_sense; 3243| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3244| 0|case 119: ------------------ | Branch (3244:1): [True: 0, False: 6.57M] ------------------ 3245| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3246| 0|#line 449 "scan.l" 3247| 0|ctrl.no_yyget_lineno = ! option_sense; 3248| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3249| 0|case 120: ------------------ | Branch (3249:1): [True: 0, False: 6.57M] ------------------ 3250| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3251| 0|#line 450 "scan.l" 3252| 0|ctrl.no_yyset_lineno = ! option_sense; 3253| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3254| 0|case 121: ------------------ | Branch (3254:1): [True: 0, False: 6.57M] ------------------ 3255| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3256| 0|#line 451 "scan.l" 3257| 0|ctrl.no_yyget_in = ! option_sense; 3258| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3259| 0|case 122: ------------------ | Branch (3259:1): [True: 0, False: 6.57M] ------------------ 3260| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3261| 0|#line 452 "scan.l" 3262| 0|ctrl.no_yyset_in = ! option_sense; 3263| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3264| 0|case 123: ------------------ | Branch (3264:1): [True: 0, False: 6.57M] ------------------ 3265| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3266| 0|#line 453 "scan.l" 3267| 0|ctrl.no_yyget_out = ! option_sense; 3268| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3269| 0|case 124: ------------------ | Branch (3269:1): [True: 0, False: 6.57M] ------------------ 3270| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3271| 0|#line 454 "scan.l" 3272| 0|ctrl.no_yyset_out = ! option_sense; 3273| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3274| 0|case 125: ------------------ | Branch (3274:1): [True: 0, False: 6.57M] ------------------ 3275| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3276| 0|#line 455 "scan.l" 3277| 0|ctrl.no_yyget_lval = ! option_sense; 3278| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3279| 0|case 126: ------------------ | Branch (3279:1): [True: 0, False: 6.57M] ------------------ 3280| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3281| 0|#line 456 "scan.l" 3282| 0|ctrl.no_yyset_lval = ! option_sense; 3283| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3284| 0|case 127: ------------------ | Branch (3284:1): [True: 0, False: 6.57M] ------------------ 3285| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3286| 0|#line 457 "scan.l" 3287| 0|ctrl.no_yyget_lloc = ! option_sense; 3288| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3289| 0|case 128: ------------------ | Branch (3289:1): [True: 0, False: 6.57M] ------------------ 3290| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3291| 0|#line 458 "scan.l" 3292| 0|ctrl.no_yyset_lloc = ! option_sense; 3293| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3294| 0|case 129: ------------------ | Branch (3294:1): [True: 0, False: 6.57M] ------------------ 3295| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3296| 0|#line 460 "scan.l" 3297| 0|return TOK_BUFSIZE; ------------------ | | 131| 0|#define TOK_BUFSIZE 280 ------------------ 3298| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3299| 0|case 130: ------------------ | Branch (3299:1): [True: 0, False: 6.57M] ------------------ 3300| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3301| 0|#line 461 "scan.l" 3302| 0|return TOK_EMIT; ------------------ | | 130| 0|#define TOK_EMIT 279 ------------------ 3303| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3304| 0|case 131: ------------------ | Branch (3304:1): [True: 0, False: 6.57M] ------------------ 3305| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3306| 0|#line 462 "scan.l" 3307| 0|return TOK_EXTRA_TYPE; ------------------ | | 122| 0|#define TOK_EXTRA_TYPE 271 ------------------ 3308| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3309| 0|case 132: ------------------ | Branch (3309:1): [True: 0, False: 6.57M] ------------------ 3310| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3311| 0|#line 463 "scan.l" 3312| 0|return TOK_OUTFILE; ------------------ | | 118| 0|#define TOK_OUTFILE 267 ------------------ 3313| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3314| 0|case 133: ------------------ | Branch (3314:1): [True: 0, False: 6.57M] ------------------ 3315| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3316| 0|#line 464 "scan.l" 3317| 0|return TOK_PREFIX; ------------------ | | 119| 0|#define TOK_PREFIX 268 ------------------ 3318| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3319| 0|case 134: ------------------ | Branch (3319:1): [True: 0, False: 6.57M] ------------------ 3320| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3321| 0|#line 465 "scan.l" 3322| 0|return TOK_YYCLASS; ------------------ | | 120| 0|#define TOK_YYCLASS 269 ------------------ 3323| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3324| 0|case 135: ------------------ | Branch (3324:1): [True: 0, False: 6.57M] ------------------ 3325| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3326| 0|#line 466 "scan.l" 3327| 0|return TOK_YYLMAX; ------------------ | | 124| 0|#define TOK_YYLMAX 273 ------------------ 3328| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3329| 0|case 136: ------------------ | Branch (3329:1): [True: 0, False: 6.57M] ------------------ 3330| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3331| 0|#line 467 "scan.l" 3332| 0|return TOK_YYDECL; ------------------ | | 126| 0|#define TOK_YYDECL 275 ------------------ 3333| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3334| 0|case 137: ------------------ | Branch (3334:1): [True: 0, False: 6.57M] ------------------ 3335| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3336| 0|#line 468 "scan.l" 3337| 0|return TOK_YYTERMINATE; ------------------ | | 132| 0|#define TOK_YYTERMINATE 281 ------------------ 3338| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3339| 0|case 138: ------------------ | Branch (3339:1): [True: 0, False: 6.57M] ------------------ 3340| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3341| 0|#line 469 "scan.l" 3342| 0|return TOK_PREACTION; ------------------ | | 127| 0|#define TOK_PREACTION 276 ------------------ 3343| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3344| 0|case 139: ------------------ | Branch (3344:1): [True: 0, False: 6.57M] ------------------ 3345| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3346| 0|#line 470 "scan.l" 3347| 0|return TOK_POSTACTION; ------------------ | | 128| 0|#define TOK_POSTACTION 277 ------------------ 3348| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3349| 0|case 140: ------------------ | Branch (3349:1): [True: 0, False: 6.57M] ------------------ 3350| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3351| 0|#line 471 "scan.l" 3352| 0|return TOK_USERINIT; ------------------ | | 129| 0|#define TOK_USERINIT 278 ------------------ 3353| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3354| 0|case 141: ------------------ | Branch (3354:1): [True: 0, False: 6.57M] ------------------ 3355| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3356| 0|#line 472 "scan.l" 3357| 0|return TOK_HEADER_FILE; ------------------ | | 121| 0|#define TOK_HEADER_FILE 270 ------------------ 3358| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3359| 0|case 142: ------------------ | Branch (3359:1): [True: 0, False: 6.57M] ------------------ 3360| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3361| 0|#line 473 "scan.l" 3362| 0|return TOK_TABLES_FILE; ------------------ | | 123| 0|#define TOK_TABLES_FILE 272 ------------------ 3363| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3364| 0|case 143: ------------------ | Branch (3364:1): [True: 0, False: 6.57M] ------------------ 3365| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3366| 0|#line 474 "scan.l" 3367| 0|{ 3368| 0| tablesverify = option_sense; 3369| 0| if (!tablesext && option_sense) ------------------ | Branch (3369:25): [True: 0, False: 0] | Branch (3369:39): [True: 0, False: 0] ------------------ 3370| 0| tablesext = true; ------------------ | | 83| 0|# define true 1 ------------------ 3371| 0| } 3372| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3373| 0|case 144: ------------------ | Branch (3373:1): [True: 0, False: 6.57M] ------------------ 3374| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3375| 0|#line 481 "scan.l" 3376| 0|{ 3377| 0| if(yyleng-1 < MAXLINE) ------------------ | | 114| 0|#define MAXLINE 2048 ------------------ | Branch (3377:7): [True: 0, False: 0] ------------------ 3378| 0| { 3379| 0| strncpy( nmstr, yytext + 1, sizeof(nmstr) ); 3380| 0| } 3381| 0| else 3382| 0| { 3383| 0| synerr( _("Option line too long\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 3384| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 3385| 0| } 3386| 0| nmstr[strlen( nmstr ) - 1] = '\0'; 3387| 0| return NAME; ------------------ | | 114| 0|#define NAME 263 ------------------ 3388| 0| } 3389| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3390| 0|case 145: ------------------ | Branch (3390:1): [True: 0, False: 6.57M] ------------------ 3391| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3392| 0|#line 495 "scan.l" 3393| 0|{ 3394| 0| format_synerr( _( "unrecognized %%option: %s" ), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 3395| 0| yytext ); 3396| 0| BEGIN(RECOVER); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(RECOVER); ------------------ | | 2198| 0|#define RECOVER 13 ------------------ 3397| 0| } 3398| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3399| | 3400| 0|case 146: ------------------ | Branch (3400:1): [True: 0, False: 6.57M] ------------------ 3401| |/* rule 146 can match eol */ 3402| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3403| 0|#line 502 "scan.l" 3404| 0|++linenum; BEGIN(INITIAL); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ ++linenum; BEGIN(INITIAL); ------------------ | | 2185| 0|#define INITIAL 0 ------------------ 3405| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3406| | 3407| 0|case 147: ------------------ | Branch (3407:1): [True: 0, False: 6.57M] ------------------ 3408| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3409| 0|#line 506 "scan.l" 3410| 0|++bracelevel; yyless( 2 ); /* eat only %{ */ ------------------ | | 173| 0| do \ | | 174| 0| { \ | | 175| 0| /* Undo effects of setting up yytext. */ \ | | 176| 0| int yyless_macro_arg = (n); \ | | 177| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 178| 0| *yy_cp = (yy_hold_char); \ | | 179| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 180| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2067| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 181| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 352| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 341| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 354| 0| (yy_hold_char) = *yy_cp; \ | | | | 355| 0| *yy_cp = '\0'; \ | | | | 356| 0| (yy_c_buf_p) = yy_cp; | | ------------------ | | 182| 0| } \ | | 183| 0| while ( 0 ) | | ------------------ | | | Branch (183:10): [Folded, False: 0] | | ------------------ ------------------ 3411| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3412| 0|case 148: ------------------ | Branch (3412:1): [True: 0, False: 6.57M] ------------------ 3413| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3414| 0|#line 507 "scan.l" 3415| 0|--bracelevel; yyless( 2 ); /* eat only %} */ ------------------ | | 173| 0| do \ | | 174| 0| { \ | | 175| 0| /* Undo effects of setting up yytext. */ \ | | 176| 0| int yyless_macro_arg = (n); \ | | 177| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 178| 0| *yy_cp = (yy_hold_char); \ | | 179| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 180| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2067| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 181| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 352| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 341| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 354| 0| (yy_hold_char) = *yy_cp; \ | | | | 355| 0| *yy_cp = '\0'; \ | | | | 356| 0| (yy_c_buf_p) = yy_cp; | | ------------------ | | 182| 0| } \ | | 183| 0| while ( 0 ) | | ------------------ | | | Branch (183:10): [Folded, False: 0] | | ------------------ ------------------ 3416| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3417| 0|case 149: ------------------ | Branch (3417:1): [True: 0, False: 6.57M] ------------------ 3418| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3419| 0|#line 509 "scan.l" 3420| 0|START_CODEBLOCK(true); /* indented code in prolog */ ------------------ | | 2159| 0|#define START_CODEBLOCK(x) do { \ | | 2160| 0| /* Emit the needed line directive... */\ | | 2161| 0| if (indented_code == false) { \ | | ------------------ | | | | 82| 0|# define false 0 | | ------------------ | | | Branch (2161:9): [True: 0, False: 0] | | ------------------ | | 2162| 0| if (!x) linenum++; \ | | ------------------ | | | Branch (2162:13): [Folded, False: 0] | | ------------------ | | 2163| 0| line_directive_out(NULL, infilename, linenum); \ | | 2164| 0| } \ | | 2165| 0| add_action(M4QSTART); \ | | ------------------ | | | | 2110| 0|#define M4QSTART "[""[" | | ------------------ | | 2166| 0| yy_push_state(CODEBLOCK); \ | | ------------------ | | | | 2189| 0|#define CODEBLOCK 4 | | ------------------ | | 2167| 0| if ((indented_code = x)) ACTION_ECHO; \ | | ------------------ | | | | 2116| 0|#define ACTION_ECHO add_action( yytext ) | | ------------------ | | | Branch (2167:9): [True: 0, False: 0] | | ------------------ | | 2168| 0|} while(0) | | ------------------ | | | Branch (2168:9): [Folded, False: 0] | | ------------------ ------------------ 3421| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3422| 1|case 150: ------------------ | Branch (3422:1): [True: 1, False: 6.57M] ------------------ 3423| 1|YY_RULE_SETUP ------------------ | | 2397| 1| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 1, False: 0] | | ------------------ | | 2398| 1| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 1| (yytext[yyleng - 1] == '\n'); \ | | 2400| 1| YY_USER_ACTION ------------------ 3424| 1|#line 511 "scan.l" 3425| 1|{ 3426| | /* non-indented code */ 3427| 1| if ( bracelevel <= 0 ) { ------------------ | Branch (3427:8): [True: 1, False: 0] ------------------ 3428| | /* not in %{ ... %} */ 3429| 1| yyless( 0 ); /* put it all back */ ------------------ | | 173| 1| do \ | | 174| 1| { \ | | 175| 1| /* Undo effects of setting up yytext. */ \ | | 176| 1| int yyless_macro_arg = (n); \ | | 177| 1| YY_LESS_LINENO(yyless_macro_arg);\ | | 178| 1| *yy_cp = (yy_hold_char); \ | | 179| 1| YY_RESTORE_YY_MORE_OFFSET \ | | 180| 1| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2067| 1|#define YY_MORE_ADJ 0 | | ------------------ | | 181| 1| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 352| 1| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 341| 1|#define yytext_ptr yytext | | | | ------------------ | | | | 353| 1| yyleng = (int) (yy_cp - yy_bp); \ | | | | 354| 1| (yy_hold_char) = *yy_cp; \ | | | | 355| 1| *yy_cp = '\0'; \ | | | | 356| 1| (yy_c_buf_p) = yy_cp; | | ------------------ | | 182| 1| } \ | | 183| 1| while ( 0 ) | | ------------------ | | | Branch (183:10): [Folded, False: 1] | | ------------------ ------------------ 3430| 1| yy_set_bol( 1 ); ------------------ | | 317| 1| { \ | | 318| 1| if ( ! YY_CURRENT_BUFFER ){\ | | ------------------ | | | | 262| 1|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | | | ------------------ | | | | | Branch (262:29): [True: 1, False: 0] | | | | ------------------ | | | | 263| 1| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | | | 264| 1| : NULL) | | ------------------ | | | Branch (318:7): [True: 0, False: 1] | | ------------------ | | 319| 0| yyensure_buffer_stack (); \ | | 320| 0| YY_CURRENT_BUFFER_LVALUE = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 321| 0| yy_create_buffer( yyin, YY_BUF_SIZE ); \ | | ------------------ | | | | 142| 0|#define YY_BUF_SIZE 16384 | | ------------------ | | 322| 0| } \ | | 323| 1| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ | | ------------------ | | | | 268| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 324| 1| } ------------------ 3431| 1| mark_prolog(); 3432| 1| BEGIN(SECT2); ------------------ | | 120| 1|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 1|#define SECT2 1 ------------------ 3433| 1| } else { 3434| 0| START_CODEBLOCK(true); ------------------ | | 2159| 0|#define START_CODEBLOCK(x) do { \ | | 2160| 0| /* Emit the needed line directive... */\ | | 2161| 0| if (indented_code == false) { \ | | ------------------ | | | | 82| 0|# define false 0 | | ------------------ | | | Branch (2161:9): [True: 0, False: 0] | | ------------------ | | 2162| 0| if (!x) linenum++; \ | | ------------------ | | | Branch (2162:13): [Folded, False: 0] | | ------------------ | | 2163| 0| line_directive_out(NULL, infilename, linenum); \ | | 2164| 0| } \ | | 2165| 0| add_action(M4QSTART); \ | | ------------------ | | | | 2110| 0|#define M4QSTART "[""[" | | ------------------ | | 2166| 0| yy_push_state(CODEBLOCK); \ | | ------------------ | | | | 2189| 0|#define CODEBLOCK 4 | | ------------------ | | 2167| 0| if ((indented_code = x)) ACTION_ECHO; \ | | ------------------ | | | | 2116| 0|#define ACTION_ECHO add_action( yytext ) | | ------------------ | | | Branch (2167:9): [True: 0, False: 0] | | ------------------ | | 2168| 0|} while(0) | | ------------------ | | | Branch (2168:9): [Folded, False: 0] | | ------------------ ------------------ 3435| 0| } 3436| 1| } 3437| 1| YY_BREAK ------------------ | | 2393| 1|#define YY_BREAK /*LINTED*/break; ------------------ 3438| 0|case 151: ------------------ | Branch (3438:1): [True: 0, False: 6.57M] ------------------ 3439| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3440| 0|#line 524 "scan.l" 3441| 0|ACTION_ECHO; ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 3442| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3443| 0|case 152: ------------------ | Branch (3443:1): [True: 0, False: 6.57M] ------------------ 3444| |/* rule 152 can match eol */ 3445| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3446| 0|#line 525 "scan.l" 3447| 0|++linenum; ACTION_ECHO; ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 3448| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3449| 1|case YY_STATE_EOF(SECT2PROLOG): ------------------ | | 128| 1|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 1|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (3449:1): [True: 1, False: 6.57M] ------------------ 3450| 1|#line 527 "scan.l" 3451| 1|{ 3452| 1| mark_prolog(); 3453| 1| sectnum = 0; 3454| 1| return YY_NULL; /* to stop the parser */ ------------------ | | 109| 1|#define YY_NULL 0 ------------------ 3455| 0| } 3456| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3457| | 3458| | 3459| 31|case 153: ------------------ | Branch (3459:1): [True: 31, False: 6.57M] ------------------ 3460| |/* rule 153 can match eol */ 3461| 31|YY_RULE_SETUP ------------------ | | 2397| 31| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 31, False: 0] | | ------------------ | | 2398| 31| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 31|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 31| (yytext[yyleng - 1] == '\n'); \ | | 2400| 31| YY_USER_ACTION ------------------ 3462| 31|#line 535 "scan.l" 3463| 31|++linenum; /* allow blank lines in section 2 */ 3464| 31| YY_BREAK ------------------ | | 2393| 31|#define YY_BREAK /*LINTED*/break; ------------------ 3465| 2|case 154: ------------------ | Branch (3465:1): [True: 2, False: 6.57M] ------------------ 3466| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 3467| 2|#line 537 "scan.l" 3468| 2|{ 3469| 2| indented_code = false; ------------------ | | 82| 2|# define false 0 ------------------ 3470| 2| doing_codeblock = true; ------------------ | | 83| 2|# define true 1 ------------------ 3471| 2| bracelevel = 1; 3472| 2| BEGIN(PERCENT_BRACE_ACTION); ------------------ | | 120| 2|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(PERCENT_BRACE_ACTION); ------------------ | | 2201| 2|#define PERCENT_BRACE_ACTION 16 ------------------ 3473| 2| } 3474| 2| YY_BREAK ------------------ | | 2393| 2|#define YY_BREAK /*LINTED*/break; ------------------ 3475| 0|case 155: ------------------ | Branch (3475:1): [True: 0, False: 6.57M] ------------------ 3476| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3477| 0|#line 544 "scan.l" 3478| 0|{ 3479| | /* Allow "<" to appear in (?x) patterns. */ 3480| 0| if (!sf_skip_ws()) ------------------ | | 1187| 0|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1183| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ ------------------ | Branch (3480:29): [True: 0, False: 0] ------------------ 3481| 0| BEGIN(SC); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SC); ------------------ | | 2191| 0|#define SC 6 ------------------ 3482| 0| return '<'; 3483| 0| } 3484| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3485| 2|case 156: ------------------ | Branch (3485:1): [True: 2, False: 6.57M] ------------------ 3486| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 3487| 2|#line 550 "scan.l" 3488| 2|return '^'; 3489| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3490| 10|case 157: ------------------ | Branch (3490:1): [True: 10, False: 6.57M] ------------------ 3491| 10|YY_RULE_SETUP ------------------ | | 2397| 10| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 10, False: 0] | | ------------------ | | 2398| 10| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 10|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 10| (yytext[yyleng - 1] == '\n'); \ | | 2400| 10| YY_USER_ACTION ------------------ 3492| 10|#line 551 "scan.l" 3493| 10|BEGIN(QUOTE); return '"'; ------------------ | | 120| 10|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(QUOTE); return '"'; ------------------ | | 2194| 10|#define QUOTE 9 ------------------ 3494| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3495| 0|case 158: ------------------ | Branch (3495:1): [True: 0, False: 6.57M] ------------------ 3496| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 3497| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 3498| 0|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 352| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 354| 0| (yy_hold_char) = *yy_cp; \ | | 355| 0| *yy_cp = '\0'; \ | | 356| 0| (yy_c_buf_p) = yy_cp; ------------------ 3499| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3500| 0|#line 552 "scan.l" 3501| 0|{ 3502| 0| BEGIN(NUM); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(NUM); ------------------ | | 2193| 0|#define NUM 8 ------------------ 3503| 0| if ( ctrl.lex_compat || ctrl.posix_compat ) ------------------ | Branch (3503:9): [True: 0, False: 0] | Branch (3503:28): [True: 0, False: 0] ------------------ 3504| 0| return BEGIN_REPEAT_POSIX; ------------------ | | 159| 0|#define BEGIN_REPEAT_POSIX 308 ------------------ 3505| 0| else 3506| 0| return BEGIN_REPEAT_FLEX; ------------------ | | 161| 0|#define BEGIN_REPEAT_FLEX 310 ------------------ 3507| 0| } 3508| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3509| 0|case 159: ------------------ | Branch (3509:1): [True: 0, False: 6.57M] ------------------ 3510| |/* rule 159 can match eol */ 3511| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 3512| 0|YY_LINENO_REWIND_TO(yy_bp + 1); 3513| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 3514| 0|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 352| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 354| 0| (yy_hold_char) = *yy_cp; \ | | 355| 0| *yy_cp = '\0'; \ | | 356| 0| (yy_c_buf_p) = yy_cp; ------------------ 3515| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3516| 0|#line 559 "scan.l" 3517| 0|return '$'; 3518| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3519| 0|case 160: ------------------ | Branch (3519:1): [True: 0, False: 6.57M] ------------------ 3520| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3521| 0|#line 561 "scan.l" 3522| 0|{ 3523| 0| bracelevel = 1; 3524| 0| BEGIN(PERCENT_BRACE_ACTION); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(PERCENT_BRACE_ACTION); ------------------ | | 2201| 0|#define PERCENT_BRACE_ACTION 16 ------------------ 3525| | 3526| 0| if ( in_rule ) ------------------ | Branch (3526:9): [True: 0, False: 0] ------------------ 3527| 0| { 3528| 0| doing_rule_action = true; ------------------ | | 83| 0|# define true 1 ------------------ 3529| 0| in_rule = false; ------------------ | | 82| 0|# define false 0 ------------------ 3530| 0| return '\n'; 3531| 0| } 3532| 0| } 3533| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3534| 0|case 161: ------------------ | Branch (3534:1): [True: 0, False: 6.57M] ------------------ 3535| |/* rule 161 can match eol */ 3536| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3537| 0|#line 572 "scan.l" 3538| 0|{ 3539| 0| if (sf_skip_ws()){ ------------------ | | 1187| 0|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1183| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1187:28): [True: 0, False: 0] | | ------------------ ------------------ 3540| | /* We're in the middle of a (?x: ) pattern. */ 3541| | /* Push back everything starting at the "|" */ 3542| 0| int amt = (int) (strchr (yytext, '|') - yytext); 3543| 0| yyless(amt); ------------------ | | 173| 0| do \ | | 174| 0| { \ | | 175| 0| /* Undo effects of setting up yytext. */ \ | | 176| 0| int yyless_macro_arg = (n); \ | | 177| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 178| 0| *yy_cp = (yy_hold_char); \ | | 179| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 180| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2067| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 181| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 352| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 341| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 354| 0| (yy_hold_char) = *yy_cp; \ | | | | 355| 0| *yy_cp = '\0'; \ | | | | 356| 0| (yy_c_buf_p) = yy_cp; | | ------------------ | | 182| 0| } \ | | 183| 0| while ( 0 ) | | ------------------ | | | Branch (183:10): [Folded, False: 0] | | ------------------ ------------------ 3544| 0| } 3545| 0| else { 3546| 0| add_action("]""]"); 3547| 0| continued_action = true; ------------------ | | 83| 0|# define true 1 ------------------ 3548| 0| ++linenum; 3549| 0| return '\n'; 3550| 0| } 3551| 0| } 3552| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3553| 0|case 162: ------------------ | Branch (3553:1): [True: 0, False: 6.57M] ------------------ 3554| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3555| 0|#line 587 "scan.l" 3556| 0|{ 3557| | 3558| 0| if (sf_skip_ws()){ ------------------ | | 1187| 0|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1183| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1187:28): [True: 0, False: 0] | | ------------------ ------------------ 3559| | /* We're in the middle of a (?x: ) pattern. */ 3560| 0| yy_push_state(COMMENT_DISCARD); ------------------ | | 2208| 0|#define COMMENT_DISCARD 23 ------------------ 3561| 0| } 3562| 0| else{ 3563| 0| yyless( yyleng - 2 ); /* put back '/', '*' */ ------------------ | | 173| 0| do \ | | 174| 0| { \ | | 175| 0| /* Undo effects of setting up yytext. */ \ | | 176| 0| int yyless_macro_arg = (n); \ | | 177| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 178| 0| *yy_cp = (yy_hold_char); \ | | 179| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 180| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2067| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 181| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 352| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 341| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 354| 0| (yy_hold_char) = *yy_cp; \ | | | | 355| 0| *yy_cp = '\0'; \ | | | | 356| 0| (yy_c_buf_p) = yy_cp; | | ------------------ | | 182| 0| } \ | | 183| 0| while ( 0 ) | | ------------------ | | | Branch (183:10): [Folded, False: 0] | | ------------------ ------------------ 3564| 0| bracelevel = 0; 3565| 0| continued_action = false; ------------------ | | 82| 0|# define false 0 ------------------ 3566| 0| BEGIN(ACTION); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(ACTION); ------------------ | | 2197| 0|#define ACTION 12 ------------------ 3567| 0| } 3568| 0| } 3569| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3570| 2|case 163: ------------------ | Branch (3570:1): [True: 2, False: 6.57M] ------------------ 3571| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 3572| 2|#line 601 "scan.l" 3573| 2|/* allow indented rules */ ; 3574| 2| YY_BREAK ------------------ | | 2393| 2|#define YY_BREAK /*LINTED*/break; ------------------ 3575| 8|case 164: ------------------ | Branch (3575:1): [True: 8, False: 6.57M] ------------------ 3576| 8|YY_RULE_SETUP ------------------ | | 2397| 8| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 8, False: 0] | | ------------------ | | 2398| 8| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 8|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 8| (yytext[yyleng - 1] == '\n'); \ | | 2400| 8| YY_USER_ACTION ------------------ 3577| 8|#line 603 "scan.l" 3578| 8|{ 3579| 8| if (sf_skip_ws()){ ------------------ | | 1187| 8|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1184| 8|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1183| 8|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1187:28): [True: 0, False: 8] | | ------------------ ------------------ 3580| | /* We're in the middle of a (?x: ) pattern. */ 3581| 0| } 3582| 8| else{ 3583| | /* This rule is separate from the one below because 3584| | * otherwise we get variable trailing context, so 3585| | * we can't build the scanner using -{f,F}. 3586| | */ 3587| 8| bracelevel = 0; 3588| 8| continued_action = false; ------------------ | | 82| 8|# define false 0 ------------------ 3589| 8| BEGIN(ACTION); ------------------ | | 120| 8|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(ACTION); ------------------ | | 2197| 8|#define ACTION 12 ------------------ 3590| | 3591| 8| if ( in_rule ) ------------------ | Branch (3591:22): [True: 0, False: 8] ------------------ 3592| 0| { 3593| 0| doing_rule_action = true; ------------------ | | 83| 0|# define true 1 ------------------ 3594| 0| in_rule = false; ------------------ | | 82| 0|# define false 0 ------------------ 3595| 0| return '\n'; 3596| 0| } 3597| 8| } 3598| 8| } 3599| 8| YY_BREAK ------------------ | | 2393| 8|#define YY_BREAK /*LINTED*/break; ------------------ 3600| 30|case 165: ------------------ | Branch (3600:1): [True: 30, False: 6.57M] ------------------ 3601| |/* rule 165 can match eol */ 3602| 30|YY_RULE_SETUP ------------------ | | 2397| 30| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 30, False: 0] | | ------------------ | | 2398| 30| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 30|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 30| (yytext[yyleng - 1] == '\n'); \ | | 2400| 30| YY_USER_ACTION ------------------ 3603| 30|#line 625 "scan.l" 3604| 30|{ 3605| 30| if (sf_skip_ws()){ ------------------ | | 1187| 30|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1184| 30|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1183| 30|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1187:28): [True: 0, False: 30] | | ------------------ ------------------ 3606| | /* We're in the middle of a (?x: ) pattern. */ 3607| 0| ++linenum; 3608| 0| } 3609| 30| else{ 3610| 30| bracelevel = 0; 3611| 30| continued_action = false; ------------------ | | 82| 30|# define false 0 ------------------ 3612| 30| BEGIN(ACTION); ------------------ | | 120| 30|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(ACTION); ------------------ | | 2197| 30|#define ACTION 12 ------------------ 3613| 30| unput( '\n' ); /* so sees it */ ------------------ | | 184| 30|#define unput(c) yyunput( c, (yytext_ptr) ) | | ------------------ | | | | 341| 30|#define yytext_ptr yytext | | ------------------ ------------------ 3614| | 3615| 30| if ( in_rule ) ------------------ | Branch (3615:22): [True: 0, False: 30] ------------------ 3616| 0| { 3617| 0| doing_rule_action = true; ------------------ | | 83| 0|# define true 1 ------------------ 3618| 0| in_rule = false; ------------------ | | 82| 0|# define false 0 ------------------ 3619| 0| return '\n'; 3620| 0| } 3621| 30| } 3622| 30| } 3623| 30| YY_BREAK ------------------ | | 2393| 30|#define YY_BREAK /*LINTED*/break; ------------------ 3624| 30|case 166: ------------------ | Branch (3624:1): [True: 0, False: 6.57M] ------------------ 3625| 0|#line 646 "scan.l" 3626| 0|case 167: ------------------ | Branch (3626:1): [True: 0, False: 6.57M] ------------------ 3627| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3628| 0|#line 646 "scan.l" 3629| 0|return EOF_OP; ------------------ | | 116| 0|#define EOF_OP 265 ------------------ 3630| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3631| 1|case 168: ------------------ | Branch (3631:1): [True: 1, False: 6.57M] ------------------ 3632| 1|YY_RULE_SETUP ------------------ | | 2397| 1| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 1, False: 0] | | ------------------ | | 2398| 1| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 1| (yytext[yyleng - 1] == '\n'); \ | | 2400| 1| YY_USER_ACTION ------------------ 3633| 1|#line 648 "scan.l" 3634| 1|{ 3635| 1| sectnum = 3; 3636| 1| BEGIN(ctrl.no_section3_escape ? SECT3_NOESCAPE : SECT3); ------------------ | | 120| 1|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(ctrl.no_section3_escape ? SECT3_NOESCAPE : SECT3); ------------------ | | 2210| 0|#define SECT3_NOESCAPE 25 ------------------ BEGIN(ctrl.no_section3_escape ? SECT3_NOESCAPE : SECT3); ------------------ | | 2188| 1|#define SECT3 3 ------------------ | Branch (3636:10): [True: 0, False: 1] ------------------ 3637| 1| yyterminate(); /* to stop the parser */ ------------------ | | 2358| 1|#define yyterminate() return YY_NULL | | ------------------ | | | | 109| 1|#define YY_NULL 0 | | ------------------ ------------------ 3638| | 3639| 0| } 3640| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3641| 10|case 169: ------------------ | Branch (3641:1): [True: 10, False: 6.57M] ------------------ 3642| 10|YY_RULE_SETUP ------------------ | | 2397| 10| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 10, False: 0] | | ------------------ | | 2398| 10| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 10|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 10| (yytext[yyleng - 1] == '\n'); \ | | 2400| 10| YY_USER_ACTION ------------------ 3643| 10|#line 655 "scan.l" 3644| 10|{ 3645| 10| int cclval; 3646| | 3647| 10| if(yyleng < MAXLINE) ------------------ | | 114| 10|#define MAXLINE 2048 ------------------ | Branch (3647:7): [True: 10, False: 0] ------------------ 3648| 10| { 3649| 10| strncpy( nmstr, yytext, sizeof(nmstr) ); 3650| 10| } 3651| 0| else 3652| 0| { 3653| 0| synerr( _("Input line too long\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 3654| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 3655| 0| } 3656| | 3657| | /* Check to see if we've already encountered this 3658| | * ccl. 3659| | */ 3660| 10| if (0 /* <--- This "0" effectively disables the reuse of a ------------------ | Branch (3660:8): [Folded, False: 10] ------------------ 3661| | * character class (purely based on its source text). 3662| | * The reason it was disabled is so yacc/bison can parse 3663| | * ccl operations, such as ccl difference and union. 3664| | */ 3665| 0| && (cclval = ccllookup( nmstr )) != 0 ) ------------------ | Branch (3665:21): [True: 0, False: 0] ------------------ 3666| 0| { 3667| | /* Dead code removed */ 3668| 0| } 3669| 10| else 3670| 10| { 3671| | /* We fudge a bit. We know that this ccl will 3672| | * soon be numbered as lastccl + 1 by cclinit. 3673| | */ 3674| 10| cclinstal( nmstr, lastccl + 1 ); 3675| | 3676| | /* Push back everything but the leading bracket 3677| | * so the ccl can be rescanned. 3678| | */ 3679| 10| yyless( 1 ); ------------------ | | 173| 10| do \ | | 174| 10| { \ | | 175| 10| /* Undo effects of setting up yytext. */ \ | | 176| 10| int yyless_macro_arg = (n); \ | | 177| 10| YY_LESS_LINENO(yyless_macro_arg);\ | | 178| 10| *yy_cp = (yy_hold_char); \ | | 179| 10| YY_RESTORE_YY_MORE_OFFSET \ | | 180| 10| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2067| 10|#define YY_MORE_ADJ 0 | | ------------------ | | 181| 10| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 352| 10| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 341| 10|#define yytext_ptr yytext | | | | ------------------ | | | | 353| 10| yyleng = (int) (yy_cp - yy_bp); \ | | | | 354| 10| (yy_hold_char) = *yy_cp; \ | | | | 355| 10| *yy_cp = '\0'; \ | | | | 356| 10| (yy_c_buf_p) = yy_cp; | | ------------------ | | 182| 10| } \ | | 183| 10| while ( 0 ) | | ------------------ | | | Branch (183:10): [Folded, False: 10] | | ------------------ ------------------ 3680| | 3681| 10| BEGIN(FIRSTCCL); ------------------ | | 120| 10|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(FIRSTCCL); ------------------ | | 2195| 10|#define FIRSTCCL 10 ------------------ 3682| 10| return '['; 3683| 10| } 3684| 10| } 3685| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3686| 0|case 170: ------------------ | Branch (3686:1): [True: 0, False: 6.57M] ------------------ 3687| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3688| 0|#line 696 "scan.l" 3689| 0|return CCL_OP_DIFF; ------------------ | | 157| 0|#define CCL_OP_DIFF 306 ------------------ 3690| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3691| 0|case 171: ------------------ | Branch (3691:1): [True: 0, False: 6.57M] ------------------ 3692| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3693| 0|#line 697 "scan.l" 3694| 0|return CCL_OP_UNION; ------------------ | | 158| 0|#define CCL_OP_UNION 307 ------------------ 3695| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3696| |/* Check for :space: at the end of the rule so we don't 3697| | * wrap the expanded regex in '(' ')' -- breaking trailing 3698| | * context. 3699| | */ 3700| 0|case 172: ------------------ | Branch (3700:1): [True: 0, False: 6.57M] ------------------ 3701| |/* rule 172 can match eol */ 3702| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3703| 0|#line 704 "scan.l" 3704| 0|{ 3705| 0| char *nmdefptr; 3706| 0| int end_is_ws, end_ch; 3707| | 3708| 0| end_ch = yytext[yyleng-1]; 3709| 0| end_is_ws = end_ch != '}' ? 1 : 0; ------------------ | Branch (3709:25): [True: 0, False: 0] ------------------ 3710| | 3711| 0| if(yyleng-1 < MAXLINE) ------------------ | | 114| 0|#define MAXLINE 2048 ------------------ | Branch (3711:8): [True: 0, False: 0] ------------------ 3712| 0| { 3713| 0| strncpy( nmstr, yytext + 1, sizeof(nmstr) ); 3714| 0| } 3715| 0| else 3716| 0| { 3717| 0| synerr( _("Input line too long\n")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 3718| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 3719| 0| } 3720| 0|nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */ 3721| | 3722| 0| if ( (nmdefptr = ndlookup( nmstr )) == 0 ) ------------------ | Branch (3722:9): [True: 0, False: 0] ------------------ 3723| 0| format_synerr( 3724| 0| _( "undefined definition {%s}" ), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 3725| 0| nmstr ); 3726| | 3727| 0| else 3728| 0| { /* push back name surrounded by ()'s */ 3729| 0| size_t len = strlen( nmdefptr ); 3730| 0| if (end_is_ws) ------------------ | Branch (3730:21): [True: 0, False: 0] ------------------ 3731| 0| unput(end_ch); ------------------ | | 184| 0|#define unput(c) yyunput( c, (yytext_ptr) ) | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ ------------------ 3732| | 3733| 0| if ( ctrl.lex_compat || nmdefptr[0] == '^' || ------------------ | Branch (3733:10): [True: 0, False: 0] | Branch (3733:29): [True: 0, False: 0] ------------------ 3734| 0| (len > 0 && nmdefptr[len - 1] == '$') ------------------ | Branch (3734:11): [True: 0, False: 0] | Branch (3734:22): [True: 0, False: 0] ------------------ 3735| 0| || (end_is_ws && trlcontxt && !sf_skip_ws())) ------------------ | | 1187| 0|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1183| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ ------------------ | Branch (3735:26): [True: 0, False: 0] | Branch (3735:39): [True: 0, False: 0] | Branch (3735:52): [True: 0, False: 0] ------------------ 3736| 0| { /* don't use ()'s after all */ 3737| 0| PUT_BACK_STRING(nmdefptr, 0); ------------------ | | 2142| 0| { size_t i = strlen( str ); \ | | 2143| 0| while ( i > start ) \ | | ------------------ | | | Branch (2143:12): [True: 0, False: 0] | | ------------------ | | 2144| 0| unput((str)[--i]); \ | | ------------------ | | | | 184| 0|#define unput(c) yyunput( c, (yytext_ptr) ) | | | | ------------------ | | | | | | 341| 0|#define yytext_ptr yytext | | | | ------------------ | | ------------------ | | 2145| 0| } ------------------ 3738| | 3739| 0| if ( nmdefptr[0] == '^' ) ------------------ | Branch (3739:11): [True: 0, False: 0] ------------------ 3740| 0| BEGIN(CARETISBOL); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CARETISBOL); ------------------ | | 2192| 0|#define CARETISBOL 7 ------------------ 3741| 0| } 3742| | 3743| 0| else 3744| 0| { 3745| 0| unput(')'); ------------------ | | 184| 0|#define unput(c) yyunput( c, (yytext_ptr) ) | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ ------------------ 3746| 0| PUT_BACK_STRING(nmdefptr, 0); ------------------ | | 2142| 0| { size_t i = strlen( str ); \ | | 2143| 0| while ( i > start ) \ | | ------------------ | | | Branch (2143:12): [True: 0, False: 0] | | ------------------ | | 2144| 0| unput((str)[--i]); \ | | ------------------ | | | | 184| 0|#define unput(c) yyunput( c, (yytext_ptr) ) | | | | ------------------ | | | | | | 341| 0|#define yytext_ptr yytext | | | | ------------------ | | ------------------ | | 2145| 0| } ------------------ 3747| 0| unput('('); ------------------ | | 184| 0|#define unput(c) yyunput( c, (yytext_ptr) ) | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ ------------------ 3748| 0| } 3749| 0| } 3750| 0| } 3751| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3752| 2|case 173: ------------------ | Branch (3752:1): [True: 2, False: 6.57M] ------------------ 3753| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 3754| 2|#line 752 "scan.l" 3755| 2|{ 3756| 2| if (sf_skip_ws()) ------------------ | | 1187| 2|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1184| 2|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1183| 2|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1187:28): [True: 0, False: 2] | | ------------------ ------------------ 3757| 0| yy_push_state(COMMENT_DISCARD); ------------------ | | 2208| 0|#define COMMENT_DISCARD 23 ------------------ 3758| 2| else{ 3759| | /* Push back the "*" and return "/" as usual. */ 3760| 2| yyless(1); ------------------ | | 173| 2| do \ | | 174| 2| { \ | | 175| 2| /* Undo effects of setting up yytext. */ \ | | 176| 2| int yyless_macro_arg = (n); \ | | 177| 2| YY_LESS_LINENO(yyless_macro_arg);\ | | 178| 2| *yy_cp = (yy_hold_char); \ | | 179| 2| YY_RESTORE_YY_MORE_OFFSET \ | | 180| 2| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2067| 2|#define YY_MORE_ADJ 0 | | ------------------ | | 181| 2| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 352| 2| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 341| 2|#define yytext_ptr yytext | | | | ------------------ | | | | 353| 2| yyleng = (int) (yy_cp - yy_bp); \ | | | | 354| 2| (yy_hold_char) = *yy_cp; \ | | | | 355| 2| *yy_cp = '\0'; \ | | | | 356| 2| (yy_c_buf_p) = yy_cp; | | ------------------ | | 182| 2| } \ | | 183| 2| while ( 0 ) | | ------------------ | | | Branch (183:10): [Folded, False: 2] | | ------------------ ------------------ 3761| 2| return '/'; 3762| 2| } 3763| 2| } 3764| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3765| 0|case 174: ------------------ | Branch (3765:1): [True: 0, False: 6.57M] ------------------ 3766| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3767| 0|#line 762 "scan.l" 3768| 0|{ 3769| 0| if (ctrl.lex_compat || ctrl.posix_compat){ ------------------ | Branch (3769:25): [True: 0, False: 0] | Branch (3769:44): [True: 0, False: 0] ------------------ 3770| | /* Push back the "?#" and treat it like a normal parens. */ 3771| 0| yyless(1); ------------------ | | 173| 0| do \ | | 174| 0| { \ | | 175| 0| /* Undo effects of setting up yytext. */ \ | | 176| 0| int yyless_macro_arg = (n); \ | | 177| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 178| 0| *yy_cp = (yy_hold_char); \ | | 179| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 180| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2067| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 181| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 352| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 341| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 354| 0| (yy_hold_char) = *yy_cp; \ | | | | 355| 0| *yy_cp = '\0'; \ | | | | 356| 0| (yy_c_buf_p) = yy_cp; | | ------------------ | | 182| 0| } \ | | 183| 0| while ( 0 ) | | ------------------ | | | Branch (183:10): [Folded, False: 0] | | ------------------ ------------------ 3772| 0| sf_push(); 3773| 0| return '('; 3774| 0| } 3775| 0| else 3776| 0| yy_push_state(EXTENDED_COMMENT); ------------------ | | 2207| 0|#define EXTENDED_COMMENT 22 ------------------ 3777| 0| } 3778| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3779| 0|case 175: ------------------ | Branch (3779:1): [True: 0, False: 6.57M] ------------------ 3780| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3781| 0|#line 772 "scan.l" 3782| 0|{ 3783| 0| sf_push(); 3784| 0| if (ctrl.lex_compat || ctrl.posix_compat) ------------------ | Branch (3784:25): [True: 0, False: 0] | Branch (3784:44): [True: 0, False: 0] ------------------ 3785| | /* Push back the "?" and treat it like a normal parens. */ 3786| 0| yyless(1); ------------------ | | 173| 0| do \ | | 174| 0| { \ | | 175| 0| /* Undo effects of setting up yytext. */ \ | | 176| 0| int yyless_macro_arg = (n); \ | | 177| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 178| 0| *yy_cp = (yy_hold_char); \ | | 179| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 180| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2067| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 181| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 352| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 341| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 354| 0| (yy_hold_char) = *yy_cp; \ | | | | 355| 0| *yy_cp = '\0'; \ | | | | 356| 0| (yy_c_buf_p) = yy_cp; | | ------------------ | | 182| 0| } \ | | 183| 0| while ( 0 ) | | ------------------ | | | Branch (183:10): [Folded, False: 0] | | ------------------ ------------------ 3787| 0| else 3788| 0| BEGIN(GROUP_WITH_PARAMS); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(GROUP_WITH_PARAMS); ------------------ | | 2205| 0|#define GROUP_WITH_PARAMS 20 ------------------ 3789| 0| return '('; 3790| 0| } 3791| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3792| 0|case 176: ------------------ | Branch (3792:1): [True: 0, False: 6.57M] ------------------ 3793| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3794| 0|#line 781 "scan.l" 3795| 0|sf_push(); return '('; 3796| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3797| 0|case 177: ------------------ | Branch (3797:1): [True: 0, False: 6.57M] ------------------ 3798| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3799| 0|#line 782 "scan.l" 3800| 0|{ 3801| 0| if (_sf_top_ix > 0) { ------------------ | Branch (3801:25): [True: 0, False: 0] ------------------ 3802| 0| sf_pop(); 3803| 0| return ')'; 3804| 0| } else 3805| 0| synerr(_("unbalanced parenthesis")); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 3806| 0| } 3807| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3808| 27|case 178: ------------------ | Branch (3808:1): [True: 27, False: 6.57M] ------------------ 3809| 27|YY_RULE_SETUP ------------------ | | 2397| 27| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 27, False: 0] | | ------------------ | | 2398| 27| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 27|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 27| (yytext[yyleng - 1] == '\n'); \ | | 2400| 27| YY_USER_ACTION ------------------ 3810| 27|#line 790 "scan.l" 3811| 27|return (unsigned char) yytext[0]; 3812| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3813| 431|case 179: ------------------ | Branch (3813:1): [True: 431, False: 6.57M] ------------------ 3814| 431|YY_RULE_SETUP ------------------ | | 2397| 431| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 431, False: 0] | | ------------------ | | 2398| 431| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 431|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 431| (yytext[yyleng - 1] == '\n'); \ | | 2400| 431| YY_USER_ACTION ------------------ 3815| 431|#line 791 "scan.l" 3816| 431|RETURNCHAR; ------------------ | | 2126| 431| yylval = (unsigned char) yytext[0]; \ | | 2127| 431| return CHAR; | | ------------------ | | | | 109| 431|#define CHAR 258 | | ------------------ ------------------ 3817| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3818| | 3819| | 3820| 0|case 180: ------------------ | Branch (3820:1): [True: 0, False: 6.57M] ------------------ 3821| |/* rule 180 can match eol */ 3822| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3823| 0|#line 796 "scan.l" 3824| 0|++linenum; /* Allow blank lines & continuations */ 3825| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3826| 0|case 181: ------------------ | Branch (3826:1): [True: 0, False: 6.57M] ------------------ 3827| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3828| 0|#line 797 "scan.l" 3829| 0|return (unsigned char) yytext[0]; 3830| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3831| 0|case 182: ------------------ | Branch (3831:1): [True: 0, False: 6.57M] ------------------ 3832| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3833| 0|#line 798 "scan.l" 3834| 0|BEGIN(SECT2); return '>'; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); return '>'; ------------------ | | 2186| 0|#define SECT2 1 ------------------ 3835| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3836| 0|case 183: ------------------ | Branch (3836:1): [True: 0, False: 6.57M] ------------------ 3837| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 3838| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 3839| 0|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 352| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 354| 0| (yy_hold_char) = *yy_cp; \ | | 355| 0| *yy_cp = '\0'; \ | | 356| 0| (yy_c_buf_p) = yy_cp; ------------------ 3840| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3841| 0|#line 799 "scan.l" 3842| 0|BEGIN(CARETISBOL); return '>'; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CARETISBOL); return '>'; ------------------ | | 2192| 0|#define CARETISBOL 7 ------------------ 3843| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3844| 0|case 184: ------------------ | Branch (3844:1): [True: 0, False: 6.57M] ------------------ 3845| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3846| 0|#line 800 "scan.l" 3847| 0|RETURNNAME; ------------------ | | 2130| 0| if(yyleng < MAXLINE) \ | | ------------------ | | | | 114| 0|#define MAXLINE 2048 | | ------------------ | | | Branch (2130:5): [True: 0, False: 0] | | ------------------ | | 2131| 0| { \ | | 2132| 0| strncpy( nmstr, yytext, sizeof(nmstr) ); \ | | 2133| 0| return NAME; \ | | ------------------ | | | | 114| 0|#define NAME 263 | | ------------------ | | 2134| 0| } \ | | 2135| 0| else \ | | 2136| 0| do { \ | | 2137| 0| synerr(_("Input line too long\n")); \ | | ------------------ | | | | 102| 0|#define _(STRING) STRING | | ------------------ | | 2138| 0| FLEX_EXIT(EXIT_FAILURE); \ | | ------------------ | | | | 1107| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) | | ------------------ | | 2139| 0| } while (0) | | ------------------ | | | Branch (2139:12): [Folded, False: 0] | | ------------------ ------------------ 3848| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3849| 0|case 185: ------------------ | Branch (3849:1): [True: 0, False: 6.57M] ------------------ 3850| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3851| 0|#line 801 "scan.l" 3852| 0|{ 3853| 0| format_synerr( _( "bad : %s" ), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 3854| 0| yytext ); 3855| 0| } 3856| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3857| | 3858| 0|case 186: ------------------ | Branch (3858:1): [True: 0, False: 6.57M] ------------------ 3859| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3860| 0|#line 807 "scan.l" 3861| 0|BEGIN(SECT2); return '^'; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); return '^'; ------------------ | | 2186| 0|#define SECT2 1 ------------------ 3862| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3863| | 3864| 100|case 187: ------------------ | Branch (3864:1): [True: 100, False: 6.57M] ------------------ 3865| 100|YY_RULE_SETUP ------------------ | | 2397| 100| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 100, False: 0] | | ------------------ | | 2398| 100| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 100|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 100| (yytext[yyleng - 1] == '\n'); \ | | 2400| 100| YY_USER_ACTION ------------------ 3866| 100|#line 811 "scan.l" 3867| 100|RETURNCHAR; ------------------ | | 2126| 100| yylval = (unsigned char) yytext[0]; \ | | 2127| 100| return CHAR; | | ------------------ | | | | 109| 100|#define CHAR 258 | | ------------------ ------------------ 3868| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3869| 8|case 188: ------------------ | Branch (3869:1): [True: 8, False: 6.57M] ------------------ 3870| 8|YY_RULE_SETUP ------------------ | | 2397| 8| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 8, False: 0] | | ------------------ | | 2398| 8| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 8|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 8| (yytext[yyleng - 1] == '\n'); \ | | 2400| 8| YY_USER_ACTION ------------------ 3871| 8|#line 812 "scan.l" 3872| 8|BEGIN(SECT2); return '"'; ------------------ | | 120| 8|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); return '"'; ------------------ | | 2186| 8|#define SECT2 1 ------------------ 3873| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3874| 2|case 189: ------------------ | Branch (3874:1): [True: 2, False: 6.57M] ------------------ 3875| |/* rule 189 can match eol */ 3876| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 3877| 2|#line 814 "scan.l" 3878| 2|{ 3879| 2| synerr( _( "missing quote" ) ); ------------------ | | 102| 2|#define _(STRING) STRING ------------------ 3880| 2| BEGIN(SECT2); ------------------ | | 120| 2|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 2|#define SECT2 1 ------------------ 3881| 2| ++linenum; 3882| 2| return '"'; 3883| 0| } 3884| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3885| | 3886| | 3887| 0|case 190: ------------------ | Branch (3887:1): [True: 0, False: 6.57M] ------------------ 3888| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3889| 0|#line 823 "scan.l" 3890| 0|BEGIN(SECT2); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 0|#define SECT2 1 ------------------ 3891| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3892| 0|case 191: ------------------ | Branch (3892:1): [True: 0, False: 6.57M] ------------------ 3893| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3894| 0|#line 824 "scan.l" 3895| 0|BEGIN(GROUP_MINUS_PARAMS); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(GROUP_MINUS_PARAMS); ------------------ | | 2206| 0|#define GROUP_MINUS_PARAMS 21 ------------------ 3896| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3897| 0|case 192: ------------------ | Branch (3897:1): [True: 0, False: 6.57M] ------------------ 3898| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3899| 0|#line 825 "scan.l" 3900| 0|sf_set_case_ins(1); ------------------ | | 1188| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1188:34): [True: 0, Folded] | | ------------------ ------------------ 3901| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3902| 0|case 193: ------------------ | Branch (3902:1): [True: 0, False: 6.57M] ------------------ 3903| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3904| 0|#line 826 "scan.l" 3905| 0|sf_set_dot_all(1); ------------------ | | 1189| 0|#define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1182| 0|#define _SF_DOT_ALL ((scanflags_t) 0x0002) | | ------------------ | | #define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1182| 0|#define _SF_DOT_ALL ((scanflags_t) 0x0002) | | ------------------ | | | Branch (1189:34): [True: 0, Folded] | | ------------------ ------------------ 3906| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3907| 0|case 194: ------------------ | Branch (3907:1): [True: 0, False: 6.57M] ------------------ 3908| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3909| 0|#line 827 "scan.l" 3910| 0|sf_set_skip_ws(1); ------------------ | | 1190| 0|#define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1183| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | #define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1183| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1190:34): [True: 0, Folded] | | ------------------ ------------------ 3911| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3912| | 3913| | 3914| 0|case 195: ------------------ | Branch (3914:1): [True: 0, False: 6.57M] ------------------ 3915| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3916| 0|#line 830 "scan.l" 3917| 0|BEGIN(SECT2); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 0|#define SECT2 1 ------------------ 3918| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3919| 0|case 196: ------------------ | Branch (3919:1): [True: 0, False: 6.57M] ------------------ 3920| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3921| 0|#line 831 "scan.l" 3922| 0|sf_set_case_ins(0); ------------------ | | 1188| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1181| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1188:34): [Folded, False: 0] | | ------------------ ------------------ 3923| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3924| 0|case 197: ------------------ | Branch (3924:1): [True: 0, False: 6.57M] ------------------ 3925| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3926| 0|#line 832 "scan.l" 3927| 0|sf_set_dot_all(0); ------------------ | | 1189| 0|#define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1182| 0|#define _SF_DOT_ALL ((scanflags_t) 0x0002) | | ------------------ | | #define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1182| 0|#define _SF_DOT_ALL ((scanflags_t) 0x0002) | | ------------------ | | | Branch (1189:34): [Folded, False: 0] | | ------------------ ------------------ 3928| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3929| 0|case 198: ------------------ | Branch (3929:1): [True: 0, False: 6.57M] ------------------ 3930| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3931| 0|#line 833 "scan.l" 3932| 0|sf_set_skip_ws(0); ------------------ | | 1190| 0|#define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1183| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | #define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1184| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1183| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1190:34): [Folded, False: 0] | | ------------------ ------------------ 3933| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3934| | 3935| | 3936| 0|case 199: ------------------ | Branch (3936:1): [True: 0, False: 6.57M] ------------------ 3937| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 3938| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 3939| 0|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 352| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 354| 0| (yy_hold_char) = *yy_cp; \ | | 355| 0| *yy_cp = '\0'; \ | | 356| 0| (yy_c_buf_p) = yy_cp; ------------------ 3940| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3941| 0|#line 837 "scan.l" 3942| 0|BEGIN(CCL); return '^'; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return '^'; ------------------ | | 2196| 0|#define CCL 11 ------------------ 3943| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3944| 0|case 200: ------------------ | Branch (3944:1): [True: 0, False: 6.57M] ------------------ 3945| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 3946| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 3947| 0|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 352| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 354| 0| (yy_hold_char) = *yy_cp; \ | | 355| 0| *yy_cp = '\0'; \ | | 356| 0| (yy_c_buf_p) = yy_cp; ------------------ 3948| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3949| 0|#line 838 "scan.l" 3950| 0|return '^'; 3951| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3952| 9|case 201: ------------------ | Branch (3952:1): [True: 9, False: 6.57M] ------------------ 3953| 9|YY_RULE_SETUP ------------------ | | 2397| 9| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 9, False: 0] | | ------------------ | | 2398| 9| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 9|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 9| (yytext[yyleng - 1] == '\n'); \ | | 2400| 9| YY_USER_ACTION ------------------ 3954| 9|#line 839 "scan.l" 3955| 9|BEGIN(CCL); RETURNCHAR; ------------------ | | 120| 9|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); RETURNCHAR; ------------------ | | 2196| 9|#define CCL 11 ------------------ BEGIN(CCL); RETURNCHAR; ------------------ | | 2126| 9| yylval = (unsigned char) yytext[0]; \ | | 2127| 9| return CHAR; | | ------------------ | | | | 109| 9|#define CHAR 258 | | ------------------ ------------------ 3956| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3957| | 3958| | 3959| 0|case 202: ------------------ | Branch (3959:1): [True: 0, False: 6.57M] ------------------ 3960| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 3961| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 3962| 0|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 352| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 354| 0| (yy_hold_char) = *yy_cp; \ | | 355| 0| *yy_cp = '\0'; \ | | 356| 0| (yy_c_buf_p) = yy_cp; ------------------ 3963| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3964| 0|#line 843 "scan.l" 3965| 0|return '-'; 3966| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3967| 690|case 203: ------------------ | Branch (3967:1): [True: 690, False: 6.57M] ------------------ 3968| 690|YY_RULE_SETUP ------------------ | | 2397| 690| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 690, False: 0] | | ------------------ | | 2398| 690| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 690|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 690| (yytext[yyleng - 1] == '\n'); \ | | 2400| 690| YY_USER_ACTION ------------------ 3969| 690|#line 844 "scan.l" 3970| 690|RETURNCHAR; ------------------ | | 2126| 690| yylval = (unsigned char) yytext[0]; \ | | 2127| 690| return CHAR; | | ------------------ | | | | 109| 690|#define CHAR 258 | | ------------------ ------------------ 3971| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3972| 0|case 204: ------------------ | Branch (3972:1): [True: 0, False: 6.57M] ------------------ 3973| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3974| 0|#line 845 "scan.l" 3975| 0|BEGIN(SECT2); return ']'; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); return ']'; ------------------ | | 2186| 0|#define SECT2 1 ------------------ 3976| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3977| 10|case 205: ------------------ | Branch (3977:1): [True: 10, False: 6.57M] ------------------ 3978| |/* rule 205 can match eol */ 3979| 10|YY_RULE_SETUP ------------------ | | 2397| 10| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 10, False: 0] | | ------------------ | | 2398| 10| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 10|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 10| (yytext[yyleng - 1] == '\n'); \ | | 2400| 10| YY_USER_ACTION ------------------ 3980| 10|#line 846 "scan.l" 3981| 10|{ 3982| 10| synerr( _( "bad character class" ) ); ------------------ | | 102| 10|#define _(STRING) STRING ------------------ 3983| 10| BEGIN(SECT2); ------------------ | | 120| 10|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 10|#define SECT2 1 ------------------ 3984| 10| return ']'; 3985| 0| } 3986| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3987| | 3988| | 3989| 0|case 206: ------------------ | Branch (3989:1): [True: 0, False: 6.57M] ------------------ 3990| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3991| 0|#line 854 "scan.l" 3992| 0|BEGIN(CCL); return CCE_ALNUM; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_ALNUM; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_ALNUM; ------------------ | | 133| 0|#define CCE_ALNUM 282 ------------------ 3993| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3994| 0|case 207: ------------------ | Branch (3994:1): [True: 0, False: 6.57M] ------------------ 3995| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 3996| 0|#line 855 "scan.l" 3997| 0|BEGIN(CCL); return CCE_ALPHA; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_ALPHA; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_ALPHA; ------------------ | | 134| 0|#define CCE_ALPHA 283 ------------------ 3998| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3999| 0|case 208: ------------------ | Branch (3999:1): [True: 0, False: 6.57M] ------------------ 4000| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4001| 0|#line 856 "scan.l" 4002| 0|BEGIN(CCL); return CCE_BLANK; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_BLANK; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_BLANK; ------------------ | | 135| 0|#define CCE_BLANK 284 ------------------ 4003| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4004| 0|case 209: ------------------ | Branch (4004:1): [True: 0, False: 6.57M] ------------------ 4005| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4006| 0|#line 857 "scan.l" 4007| 0|BEGIN(CCL); return CCE_CNTRL; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_CNTRL; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_CNTRL; ------------------ | | 136| 0|#define CCE_CNTRL 285 ------------------ 4008| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4009| 0|case 210: ------------------ | Branch (4009:1): [True: 0, False: 6.57M] ------------------ 4010| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4011| 0|#line 858 "scan.l" 4012| 0|BEGIN(CCL); return CCE_DIGIT; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_DIGIT; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_DIGIT; ------------------ | | 137| 0|#define CCE_DIGIT 286 ------------------ 4013| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4014| 0|case 211: ------------------ | Branch (4014:1): [True: 0, False: 6.57M] ------------------ 4015| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4016| 0|#line 859 "scan.l" 4017| 0|BEGIN(CCL); return CCE_GRAPH; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_GRAPH; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_GRAPH; ------------------ | | 138| 0|#define CCE_GRAPH 287 ------------------ 4018| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4019| 0|case 212: ------------------ | Branch (4019:1): [True: 0, False: 6.57M] ------------------ 4020| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4021| 0|#line 860 "scan.l" 4022| 0|BEGIN(CCL); return CCE_LOWER; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_LOWER; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_LOWER; ------------------ | | 139| 0|#define CCE_LOWER 288 ------------------ 4023| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4024| 0|case 213: ------------------ | Branch (4024:1): [True: 0, False: 6.57M] ------------------ 4025| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4026| 0|#line 861 "scan.l" 4027| 0|BEGIN(CCL); return CCE_PRINT; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_PRINT; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_PRINT; ------------------ | | 140| 0|#define CCE_PRINT 289 ------------------ 4028| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4029| 0|case 214: ------------------ | Branch (4029:1): [True: 0, False: 6.57M] ------------------ 4030| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4031| 0|#line 862 "scan.l" 4032| 0|BEGIN(CCL); return CCE_PUNCT; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_PUNCT; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_PUNCT; ------------------ | | 141| 0|#define CCE_PUNCT 290 ------------------ 4033| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4034| 0|case 215: ------------------ | Branch (4034:1): [True: 0, False: 6.57M] ------------------ 4035| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4036| 0|#line 863 "scan.l" 4037| 0|BEGIN(CCL); return CCE_SPACE; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_SPACE; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_SPACE; ------------------ | | 142| 0|#define CCE_SPACE 291 ------------------ 4038| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4039| 0|case 216: ------------------ | Branch (4039:1): [True: 0, False: 6.57M] ------------------ 4040| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4041| 0|#line 864 "scan.l" 4042| 0|BEGIN(CCL); return CCE_UPPER; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_UPPER; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_UPPER; ------------------ | | 143| 0|#define CCE_UPPER 292 ------------------ 4043| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4044| 0|case 217: ------------------ | Branch (4044:1): [True: 0, False: 6.57M] ------------------ 4045| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4046| 0|#line 865 "scan.l" 4047| 0|BEGIN(CCL); return CCE_XDIGIT; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_XDIGIT; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_XDIGIT; ------------------ | | 144| 0|#define CCE_XDIGIT 293 ------------------ 4048| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4049| 0|case 218: ------------------ | Branch (4049:1): [True: 0, False: 6.57M] ------------------ 4050| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4051| 0|#line 867 "scan.l" 4052| 0|BEGIN(CCL); return CCE_NEG_ALNUM; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_ALNUM; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_ALNUM; ------------------ | | 145| 0|#define CCE_NEG_ALNUM 294 ------------------ 4053| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4054| 0|case 219: ------------------ | Branch (4054:1): [True: 0, False: 6.57M] ------------------ 4055| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4056| 0|#line 868 "scan.l" 4057| 0|BEGIN(CCL); return CCE_NEG_ALPHA; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_ALPHA; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_ALPHA; ------------------ | | 146| 0|#define CCE_NEG_ALPHA 295 ------------------ 4058| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4059| 0|case 220: ------------------ | Branch (4059:1): [True: 0, False: 6.57M] ------------------ 4060| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4061| 0|#line 869 "scan.l" 4062| 0|BEGIN(CCL); return CCE_NEG_BLANK; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_BLANK; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_BLANK; ------------------ | | 147| 0|#define CCE_NEG_BLANK 296 ------------------ 4063| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4064| 0|case 221: ------------------ | Branch (4064:1): [True: 0, False: 6.57M] ------------------ 4065| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4066| 0|#line 870 "scan.l" 4067| 0|BEGIN(CCL); return CCE_NEG_CNTRL; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_CNTRL; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_CNTRL; ------------------ | | 148| 0|#define CCE_NEG_CNTRL 297 ------------------ 4068| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4069| 0|case 222: ------------------ | Branch (4069:1): [True: 0, False: 6.57M] ------------------ 4070| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4071| 0|#line 871 "scan.l" 4072| 0|BEGIN(CCL); return CCE_NEG_DIGIT; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_DIGIT; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_DIGIT; ------------------ | | 149| 0|#define CCE_NEG_DIGIT 298 ------------------ 4073| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4074| 0|case 223: ------------------ | Branch (4074:1): [True: 0, False: 6.57M] ------------------ 4075| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4076| 0|#line 872 "scan.l" 4077| 0|BEGIN(CCL); return CCE_NEG_GRAPH; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_GRAPH; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_GRAPH; ------------------ | | 150| 0|#define CCE_NEG_GRAPH 299 ------------------ 4078| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4079| 0|case 224: ------------------ | Branch (4079:1): [True: 0, False: 6.57M] ------------------ 4080| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4081| 0|#line 873 "scan.l" 4082| 0|BEGIN(CCL); return CCE_NEG_LOWER; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_LOWER; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_LOWER; ------------------ | | 151| 0|#define CCE_NEG_LOWER 300 ------------------ 4083| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4084| 0|case 225: ------------------ | Branch (4084:1): [True: 0, False: 6.57M] ------------------ 4085| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4086| 0|#line 874 "scan.l" 4087| 0|BEGIN(CCL); return CCE_NEG_PRINT; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_PRINT; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_PRINT; ------------------ | | 152| 0|#define CCE_NEG_PRINT 301 ------------------ 4088| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4089| 0|case 226: ------------------ | Branch (4089:1): [True: 0, False: 6.57M] ------------------ 4090| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4091| 0|#line 875 "scan.l" 4092| 0|BEGIN(CCL); return CCE_NEG_PUNCT; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_PUNCT; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_PUNCT; ------------------ | | 153| 0|#define CCE_NEG_PUNCT 302 ------------------ 4093| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4094| 0|case 227: ------------------ | Branch (4094:1): [True: 0, False: 6.57M] ------------------ 4095| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4096| 0|#line 876 "scan.l" 4097| 0|BEGIN(CCL); return CCE_NEG_SPACE; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_SPACE; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_SPACE; ------------------ | | 154| 0|#define CCE_NEG_SPACE 303 ------------------ 4098| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4099| 0|case 228: ------------------ | Branch (4099:1): [True: 0, False: 6.57M] ------------------ 4100| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4101| 0|#line 877 "scan.l" 4102| 0|BEGIN(CCL); return CCE_NEG_UPPER; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_UPPER; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_UPPER; ------------------ | | 155| 0|#define CCE_NEG_UPPER 304 ------------------ 4103| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4104| 0|case 229: ------------------ | Branch (4104:1): [True: 0, False: 6.57M] ------------------ 4105| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4106| 0|#line 878 "scan.l" 4107| 0|BEGIN(CCL); return CCE_NEG_XDIGIT; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_XDIGIT; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_XDIGIT; ------------------ | | 156| 0|#define CCE_NEG_XDIGIT 305 ------------------ 4108| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4109| 0|case 230: ------------------ | Branch (4109:1): [True: 0, False: 6.57M] ------------------ 4110| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4111| 0|#line 879 "scan.l" 4112| 0|{ 4113| 0| format_synerr( 4114| 0| _( "bad character class expression: %s" ), ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 4115| 0| yytext ); 4116| 0| BEGIN(CCL); return CCE_ALNUM; ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_ALNUM; ------------------ | | 2196| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_ALNUM; ------------------ | | 133| 0|#define CCE_ALNUM 282 ------------------ 4117| 0| } 4118| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4119| | 4120| | 4121| 0|case 231: ------------------ | Branch (4121:1): [True: 0, False: 6.57M] ------------------ 4122| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4123| 0|#line 888 "scan.l" 4124| 0|{ 4125| 0| yylval = myctoi( yytext ); 4126| 0| return NUMBER; ------------------ | | 110| 0|#define NUMBER 259 ------------------ 4127| 0| } 4128| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4129| 0|case 232: ------------------ | Branch (4129:1): [True: 0, False: 6.57M] ------------------ 4130| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4131| 0|#line 893 "scan.l" 4132| 0|return ','; 4133| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4134| 0|case 233: ------------------ | Branch (4134:1): [True: 0, False: 6.57M] ------------------ 4135| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4136| 0|#line 894 "scan.l" 4137| 0|{ 4138| 0| BEGIN(SECT2); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 0|#define SECT2 1 ------------------ 4139| 0| if ( ctrl.lex_compat || ctrl.posix_compat ) ------------------ | Branch (4139:9): [True: 0, False: 0] | Branch (4139:28): [True: 0, False: 0] ------------------ 4140| 0| return END_REPEAT_POSIX; ------------------ | | 160| 0|#define END_REPEAT_POSIX 309 ------------------ 4141| 0| else 4142| 0| return END_REPEAT_FLEX; ------------------ | | 162| 0|#define END_REPEAT_FLEX 311 ------------------ 4143| 0| } 4144| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4145| 0|case 234: ------------------ | Branch (4145:1): [True: 0, False: 6.57M] ------------------ 4146| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4147| 0|#line 902 "scan.l" 4148| 0|{ 4149| 0| synerr( _( "bad character inside {}'s" ) ); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 4150| 0| BEGIN(SECT2); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 0|#define SECT2 1 ------------------ 4151| 0| return '}'; 4152| 0| } 4153| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4154| 0|case 235: ------------------ | Branch (4154:1): [True: 0, False: 6.57M] ------------------ 4155| |/* rule 235 can match eol */ 4156| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4157| 0|#line 908 "scan.l" 4158| 0|{ 4159| 0| synerr( _( "missing }" ) ); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 4160| 0| BEGIN(SECT2); ------------------ | | 120| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 0|#define SECT2 1 ------------------ 4161| 0| ++linenum; 4162| 0| return '}'; 4163| 0| } 4164| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4165| | 4166| | 4167| 2|case 236: ------------------ | Branch (4167:1): [True: 2, False: 6.57M] ------------------ 4168| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 4169| 2|#line 918 "scan.l" 4170| 2|bracelevel = 0; 4171| 2| YY_BREAK ------------------ | | 2393| 2|#define YY_BREAK /*LINTED*/break; ------------------ 4172| 4|case 237: ------------------ | Branch (4172:1): [True: 4, False: 6.57M] ------------------ 4173| 4|YY_RULE_SETUP ------------------ | | 2397| 4| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 4, False: 0] | | ------------------ | | 2398| 4| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 4|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 4| (yytext[yyleng - 1] == '\n'); \ | | 2400| 4| YY_USER_ACTION ------------------ 4174| 4|#line 920 "scan.l" 4175| 4|ACTION_ECHO; yy_push_state( CODE_COMMENT ); ------------------ | | 2116| 4|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; yy_push_state( CODE_COMMENT ); ------------------ | | 2209| 4|#define CODE_COMMENT 24 ------------------ 4176| 4| YY_BREAK ------------------ | | 2393| 4|#define YY_BREAK /*LINTED*/break; ------------------ 4177| | 4178| 0|case 238: ------------------ | Branch (4178:1): [True: 0, False: 6.57M] ------------------ 4179| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4180| 0|#line 923 "scan.l" 4181| 0|{ 4182| 0| ACTION_ECHO; ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4183| 0| CHECK_REJECT(yytext); ------------------ | | 2148| 0| if ( all_upper( str ) ) \ | | ------------------ | | | Branch (2148:7): [True: 0, False: 0] | | ------------------ | | 2149| 0| reject = true; | | ------------------ | | | | 83| 0|# define true 1 | | ------------------ ------------------ 4184| 0| } 4185| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4186| 0|case 239: ------------------ | Branch (4186:1): [True: 0, False: 6.57M] ------------------ 4187| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4188| 0|#line 927 "scan.l" 4189| 0|{ 4190| 0| add_action("]""]M4_HOOK_REJECT[""["); 4191| 0| CHECK_YYREJECT(yytext); ------------------ | | 2152| 0| if ( all_lower( str ) ) \ | | ------------------ | | | Branch (2152:7): [True: 0, False: 0] | | ------------------ | | 2153| 0| reject = true; | | ------------------ | | | | 83| 0|# define true 1 | | ------------------ ------------------ 4192| 0| } 4193| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4194| 0|case 240: ------------------ | Branch (4194:1): [True: 0, False: 6.57M] ------------------ 4195| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4196| 0|#line 931 "scan.l" 4197| 0|{ 4198| 0| yymore_used = true; ------------------ | | 83| 0|# define true 1 ------------------ 4199| 0| if (ctrl.rewrite) ------------------ | Branch (4199:8): [True: 0, False: 0] ------------------ 4200| 0| context_call(yytext); 4201| 0| else 4202| 0| ACTION_ECHO; ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4203| 0| } 4204| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4205| | 4206| 441|case 241: ------------------ | Branch (4206:1): [True: 441, False: 6.57M] ------------------ 4207| 441|YY_RULE_SETUP ------------------ | | 2397| 441| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 441, False: 0] | | ------------------ | | 2398| 441| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 441|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 441| (yytext[yyleng - 1] == '\n'); \ | | 2400| 441| YY_USER_ACTION ------------------ 4208| 441|#line 940 "scan.l" 4209| 441|ACTION_ECHO; ------------------ | | 2116| 441|#define ACTION_ECHO add_action( yytext ) ------------------ 4210| 441| YY_BREAK ------------------ | | 2393| 441|#define YY_BREAK /*LINTED*/break; ------------------ 4211| 21|case 242: ------------------ | Branch (4211:1): [True: 21, False: 6.57M] ------------------ 4212| |/* rule 242 can match eol */ 4213| 21|YY_RULE_SETUP ------------------ | | 2397| 21| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 21, False: 0] | | ------------------ | | 2398| 21| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 21|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 21| (yytext[yyleng - 1] == '\n'); \ | | 2400| 21| YY_USER_ACTION ------------------ 4214| 21|#line 941 "scan.l" 4215| 21|{ 4216| 21| ++linenum; 4217| 21| ACTION_ECHO; ------------------ | | 2116| 21|#define ACTION_ECHO add_action( yytext ) ------------------ 4218| 21| if (bracelevel <= 0 || (doing_codeblock && indented_code)) { ------------------ | Branch (4218:7): [True: 2, False: 19] | Branch (4218:27): [True: 19, False: 0] | Branch (4218:46): [True: 0, False: 19] ------------------ 4219| 2| if ( doing_rule_action ) ------------------ | Branch (4219:18): [True: 0, False: 2] ------------------ 4220| 0| add_action( "\t]""]M4_HOOK_STATE_CASE_BREAK\n" ); 4221| | 4222| 2| doing_rule_action = doing_codeblock = false; ------------------ | | 82| 2|# define false 0 ------------------ 4223| 2| BEGIN(SECT2); ------------------ | | 120| 2|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 2|#define SECT2 1 ------------------ 4224| 2| } 4225| 21| } 4226| 21| YY_BREAK ------------------ | | 2393| 21|#define YY_BREAK /*LINTED*/break; ------------------ 4227| | 4228| |/* yyreject and yymore() are checked for above, in PERCENT_BRACE_ACTION */ 4229| | 4230| 9|case 243: ------------------ | Branch (4230:1): [True: 9, False: 6.57M] ------------------ 4231| 9|YY_RULE_SETUP ------------------ | | 2397| 9| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 9, False: 0] | | ------------------ | | 2398| 9| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 9|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 9| (yytext[yyleng - 1] == '\n'); \ | | 2400| 9| YY_USER_ACTION ------------------ 4232| 9|#line 957 "scan.l" 4233| 9|ACTION_ECHO; ++bracelevel; ------------------ | | 2116| 9|#define ACTION_ECHO add_action( yytext ) ------------------ 4234| 9| YY_BREAK ------------------ | | 2393| 9|#define YY_BREAK /*LINTED*/break; ------------------ 4235| 9|case 244: ------------------ | Branch (4235:1): [True: 9, False: 6.57M] ------------------ 4236| 9|YY_RULE_SETUP ------------------ | | 2397| 9| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 9, False: 0] | | ------------------ | | 2398| 9| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 9|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 9| (yytext[yyleng - 1] == '\n'); \ | | 2400| 9| YY_USER_ACTION ------------------ 4237| 9|#line 958 "scan.l" 4238| 9|ACTION_ECHO; --bracelevel; ------------------ | | 2116| 9|#define ACTION_ECHO add_action( yytext ) ------------------ 4239| 9| YY_BREAK ------------------ | | 2393| 9|#define YY_BREAK /*LINTED*/break; ------------------ 4240| 0|case 245: ------------------ | Branch (4240:1): [True: 0, False: 6.57M] ------------------ 4241| |/* rule 245 can match eol */ 4242| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4243| 0|#line 959 "scan.l" 4244| 0|{ 4245| 0| if (ctrl.rewrite) ------------------ | Branch (4245:8): [True: 0, False: 0] ------------------ 4246| 0| context_call(yytext); 4247| 0| else 4248| 0| ACTION_ECHO; ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4249| 0| } 4250| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4251| 0|case 246: ------------------ | Branch (4251:1): [True: 0, False: 6.57M] ------------------ 4252| |/* rule 246 can match eol */ 4253| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4254| 0|#line 965 "scan.l" 4255| 0|{ 4256| 0| add_action("]""]"); 4257| 0| add_action(yytext); 4258| 0| add_action("[""["); 4259| 0| } 4260| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4261| 0|case 247: ------------------ | Branch (4261:1): [True: 0, False: 6.57M] ------------------ 4262| |/* rule 247 can match eol */ 4263| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4264| 0|YY_LINENO_REWIND_TO(yy_cp - 1); 4265| 0|(yy_c_buf_p) = yy_cp -= 1; 4266| 0|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 352| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 354| 0| (yy_hold_char) = *yy_cp; \ | | 355| 0| *yy_cp = '\0'; \ | | 356| 0| (yy_c_buf_p) = yy_cp; ------------------ 4267| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4268| 0|#line 970 "scan.l" 4269| 0|{ 4270| 0| if (ctrl.rewrite) ------------------ | Branch (4270:8): [True: 0, False: 0] ------------------ 4271| 0| context_member(yytext, "M4_PROPERTY_CONTEXT_FORMAT"); 4272| 0| else 4273| 0| ACTION_ECHO; ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4274| 0| } 4275| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4276| 0|case 248: ------------------ | Branch (4276:1): [True: 0, False: 6.57M] ------------------ 4277| |/* rule 248 can match eol */ 4278| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4279| 0|YY_LINENO_REWIND_TO(yy_cp - 1); 4280| 0|(yy_c_buf_p) = yy_cp -= 1; 4281| 0|YY_DO_BEFORE_ACTION; /* set up yytext again */ ------------------ | | 352| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 341| 0|#define yytext_ptr yytext | | ------------------ | | 353| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 354| 0| (yy_hold_char) = *yy_cp; \ | | 355| 0| *yy_cp = '\0'; \ | | 356| 0| (yy_c_buf_p) = yy_cp; ------------------ 4282| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4283| 0|#line 976 "scan.l" 4284| 0|{ 4285| 0| if (ctrl.rewrite) ------------------ | Branch (4285:8): [True: 0, False: 0] ------------------ 4286| 0| context_member(yytext, "M4_PROPERTY_BUFFERSTACK_CONTEXT_FORMAT"); 4287| 0| else 4288| 0| ACTION_ECHO; ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4289| 0| } 4290| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4291| 240|case 249: ------------------ | Branch (4291:1): [True: 240, False: 6.57M] ------------------ 4292| 240|YY_RULE_SETUP ------------------ | | 2397| 240| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 240, False: 0] | | ------------------ | | 2398| 240| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 240|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 240| (yytext[yyleng - 1] == '\n'); \ | | 2400| 240| YY_USER_ACTION ------------------ 4293| 240|#line 982 "scan.l" 4294| 240|ACTION_ECHO; ------------------ | | 2116| 240|#define ACTION_ECHO add_action( yytext ) ------------------ 4295| 240| YY_BREAK ------------------ | | 2393| 240|#define YY_BREAK /*LINTED*/break; ------------------ 4296| 62|case 250: ------------------ | Branch (4296:1): [True: 62, False: 6.57M] ------------------ 4297| 62|YY_RULE_SETUP ------------------ | | 2397| 62| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 62, False: 0] | | ------------------ | | 2398| 62| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 62|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 62| (yytext[yyleng - 1] == '\n'); \ | | 2400| 62| YY_USER_ACTION ------------------ 4298| 62|#line 983 "scan.l" 4299| 62|ACTION_ECHO; ------------------ | | 2116| 62|#define ACTION_ECHO add_action( yytext ) ------------------ 4300| 62| YY_BREAK ------------------ | | 2393| 62|#define YY_BREAK /*LINTED*/break; ------------------ 4301| 0|case 251: ------------------ | Branch (4301:1): [True: 0, False: 6.57M] ------------------ 4302| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4303| 0|#line 984 "scan.l" 4304| 0|ACTION_ECHO; /* character constant */ ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4305| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4306| 10|case 252: ------------------ | Branch (4306:1): [True: 10, False: 6.57M] ------------------ 4307| 10|YY_RULE_SETUP ------------------ | | 2397| 10| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 10, False: 0] | | ------------------ | | 2398| 10| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 10|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 10| (yytext[yyleng - 1] == '\n'); \ | | 2400| 10| YY_USER_ACTION ------------------ 4308| 10|#line 985 "scan.l" 4309| 10|ACTION_ECHO; BEGIN(CHARACTER_CONSTANT); ------------------ | | 2116| 10|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; BEGIN(CHARACTER_CONSTANT); ------------------ | | 120| 10|#define BEGIN (yy_start) = 1 + 2 * ------------------ ACTION_ECHO; BEGIN(CHARACTER_CONSTANT); ------------------ | | 2211| 10|#define CHARACTER_CONSTANT 26 ------------------ 4310| 10| YY_BREAK ------------------ | | 2393| 10|#define YY_BREAK /*LINTED*/break; ------------------ 4311| 19|case 253: ------------------ | Branch (4311:1): [True: 19, False: 6.57M] ------------------ 4312| 19|YY_RULE_SETUP ------------------ | | 2397| 19| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 19, False: 0] | | ------------------ | | 2398| 19| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 19|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 19| (yytext[yyleng - 1] == '\n'); \ | | 2400| 19| YY_USER_ACTION ------------------ 4313| 19|#line 986 "scan.l" 4314| 19|ACTION_ECHO; BEGIN(ACTION_STRING); ------------------ | | 2116| 19|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; BEGIN(ACTION_STRING); ------------------ | | 120| 19|#define BEGIN (yy_start) = 1 + 2 * ------------------ ACTION_ECHO; BEGIN(ACTION_STRING); ------------------ | | 2200| 19|#define ACTION_STRING 15 ------------------ 4315| 19| YY_BREAK ------------------ | | 2393| 19|#define YY_BREAK /*LINTED*/break; ------------------ 4316| 168|case 254: ------------------ | Branch (4316:1): [True: 168, False: 6.57M] ------------------ 4317| |/* rule 254 can match eol */ 4318| 168|YY_RULE_SETUP ------------------ | | 2397| 168| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 168, False: 0] | | ------------------ | | 2398| 168| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 168|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 168| (yytext[yyleng - 1] == '\n'); \ | | 2400| 168| YY_USER_ACTION ------------------ 4319| 168|#line 987 "scan.l" 4320| 168|{ 4321| 168| ++linenum; 4322| 168| ACTION_ECHO; ------------------ | | 2116| 168|#define ACTION_ECHO add_action( yytext ) ------------------ 4323| 168| if (bracelevel <= 0) { ------------------ | Branch (4323:21): [True: 35, False: 133] ------------------ 4324| 35| if ( doing_rule_action ) ------------------ | Branch (4324:25): [True: 0, False: 35] ------------------ 4325| 0| add_action( "\t]""]M4_HOOK_STATE_CASE_BREAK\n" ); 4326| | 4327| 35| doing_rule_action = false; ------------------ | | 82| 35|# define false 0 ------------------ 4328| 35| BEGIN(SECT2); ------------------ | | 120| 35|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2186| 35|#define SECT2 1 ------------------ 4329| 35| } 4330| 168| } 4331| 168| YY_BREAK ------------------ | | 2393| 168|#define YY_BREAK /*LINTED*/break; ------------------ 4332| 185|case 255: ------------------ | Branch (4332:1): [True: 185, False: 6.57M] ------------------ 4333| 185|YY_RULE_SETUP ------------------ | | 2397| 185| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 185, False: 0] | | ------------------ | | 2398| 185| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 185|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 185| (yytext[yyleng - 1] == '\n'); \ | | 2400| 185| YY_USER_ACTION ------------------ 4334| 185|#line 998 "scan.l" 4335| 185|ACTION_ECHO; ------------------ | | 2116| 185|#define ACTION_ECHO add_action( yytext ) ------------------ 4336| 185| YY_BREAK ------------------ | | 2393| 185|#define YY_BREAK /*LINTED*/break; ------------------ 4337| | 4338| | 4339| 29|case 256: ------------------ | Branch (4339:1): [True: 29, False: 6.57M] ------------------ 4340| 29|YY_RULE_SETUP ------------------ | | 2397| 29| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 29, False: 0] | | ------------------ | | 2398| 29| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 29|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 29| (yytext[yyleng - 1] == '\n'); \ | | 2400| 29| YY_USER_ACTION ------------------ 4341| 29|#line 1002 "scan.l" 4342| 29|ACTION_ECHO; ------------------ | | 2116| 29|#define ACTION_ECHO add_action( yytext ) ------------------ 4343| 29| YY_BREAK ------------------ | | 2393| 29|#define YY_BREAK /*LINTED*/break; ------------------ 4344| 13|case 257: ------------------ | Branch (4344:1): [True: 13, False: 6.57M] ------------------ 4345| 13|YY_RULE_SETUP ------------------ | | 2397| 13| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 13, False: 0] | | ------------------ | | 2398| 13| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 13|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 13| (yytext[yyleng - 1] == '\n'); \ | | 2400| 13| YY_USER_ACTION ------------------ 4346| 13|#line 1003 "scan.l" 4347| 13|ACTION_ECHO; BEGIN(ACTION); ------------------ | | 2116| 13|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; BEGIN(ACTION); ------------------ | | 120| 13|#define BEGIN (yy_start) = 1 + 2 * ------------------ ACTION_ECHO; BEGIN(ACTION); ------------------ | | 2197| 13|#define ACTION 12 ------------------ 4348| 13| YY_BREAK ------------------ | | 2393| 13|#define YY_BREAK /*LINTED*/break; ------------------ 4349| | 4350| | 4351| 7|case 258: ------------------ | Branch (4351:1): [True: 7, False: 6.57M] ------------------ 4352| 7|YY_RULE_SETUP ------------------ | | 2397| 7| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 7, False: 0] | | ------------------ | | 2398| 7| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 7|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 7| (yytext[yyleng - 1] == '\n'); \ | | 2400| 7| YY_USER_ACTION ------------------ 4353| 7|#line 1006 "scan.l" 4354| 7|ACTION_ECHO; ------------------ | | 2116| 7|#define ACTION_ECHO add_action( yytext ) ------------------ 4355| 7| YY_BREAK ------------------ | | 2393| 7|#define YY_BREAK /*LINTED*/break; ------------------ 4356| 5|case 259: ------------------ | Branch (4356:1): [True: 5, False: 6.57M] ------------------ 4357| 5|YY_RULE_SETUP ------------------ | | 2397| 5| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 5, False: 0] | | ------------------ | | 2398| 5| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 5|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 5| (yytext[yyleng - 1] == '\n'); \ | | 2400| 5| YY_USER_ACTION ------------------ 4358| 5|#line 1007 "scan.l" 4359| 5|ACTION_ECHO; BEGIN(ACTION); ------------------ | | 2116| 5|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; BEGIN(ACTION); ------------------ | | 120| 5|#define BEGIN (yy_start) = 1 + 2 * ------------------ ACTION_ECHO; BEGIN(ACTION); ------------------ | | 2197| 5|#define ACTION 12 ------------------ 4360| 5| YY_BREAK ------------------ | | 2393| 5|#define YY_BREAK /*LINTED*/break; ------------------ 4361| | 4362| | 4363| 0|case 260: ------------------ | Branch (4363:1): [True: 0, False: 6.57M] ------------------ 4364| |/* rule 260 can match eol */ 4365| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4366| 0|#line 1010 "scan.l" 4367| 0|ACTION_ECHO; ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4368| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4369| 0|case 261: ------------------ | Branch (4369:1): [True: 0, False: 6.57M] ------------------ 4370| |/* rule 261 can match eol */ 4371| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4372| 0|#line 1011 "scan.l" 4373| 0|ACTION_ECHO; ------------------ | | 2116| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4374| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4375| 11|case 262: ------------------ | Branch (4375:1): [True: 11, False: 6.57M] ------------------ 4376| |/* rule 262 can match eol */ 4377| 11|YY_RULE_SETUP ------------------ | | 2397| 11| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 11, False: 0] | | ------------------ | | 2398| 11| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 11|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 11| (yytext[yyleng - 1] == '\n'); \ | | 2400| 11| YY_USER_ACTION ------------------ 4378| 11|#line 1012 "scan.l" 4379| 11|++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 2116| 11|#define ACTION_ECHO add_action( yytext ) ------------------ ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 120| 3|#define BEGIN (yy_start) = 1 + 2 * ------------------ ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 2186| 3|#define SECT2 1 ------------------ ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 120| 8|#define BEGIN (yy_start) = 1 + 2 * ------------------ ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 2197| 8|#define ACTION 12 ------------------ | Branch (4379:29): [True: 3, False: 8] ------------------ 4380| 11| YY_BREAK ------------------ | | 2393| 11|#define YY_BREAK /*LINTED*/break; ------------------ 4381| 13|case 263: ------------------ | Branch (4381:1): [True: 13, False: 6.57M] ------------------ 4382| 13|YY_RULE_SETUP ------------------ | | 2397| 13| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 13, False: 0] | | ------------------ | | 2398| 13| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 13|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 13| (yytext[yyleng - 1] == '\n'); \ | | 2400| 13| YY_USER_ACTION ------------------ 4383| 13|#line 1013 "scan.l" 4384| 13|ACTION_ECHO; ------------------ | | 2116| 13|#define ACTION_ECHO add_action( yytext ) ------------------ 4385| 13| YY_BREAK ------------------ | | 2393| 13|#define YY_BREAK /*LINTED*/break; ------------------ 4386| | 4387| 0|case YY_STATE_EOF(COMMENT): ------------------ | | 128| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4387:1): [True: 0, False: 6.57M] ------------------ 4388| 55|case YY_STATE_EOF(CODE_COMMENT): ------------------ | | 128| 55|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 55|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4388:1): [True: 55, False: 6.57M] ------------------ 4389| 55|case YY_STATE_EOF(COMMENT_DISCARD): ------------------ | | 128| 55|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 55|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4389:1): [True: 0, False: 6.57M] ------------------ 4390| 98|case YY_STATE_EOF(ACTION): ------------------ | | 128| 98|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 98|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4390:1): [True: 43, False: 6.57M] ------------------ 4391| 102|case YY_STATE_EOF(ACTION_STRING): ------------------ | | 128| 102|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 102|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4391:1): [True: 4, False: 6.57M] ------------------ 4392| 103|case YY_STATE_EOF(CHARACTER_CONSTANT): ------------------ | | 128| 103|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 103|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4392:1): [True: 1, False: 6.57M] ------------------ 4393| 103|#line 1016 "scan.l" 4394| 103|{ 4395| 103| synerr( _( "EOF encountered inside an action" ) ); ------------------ | | 102| 103|#define _(STRING) STRING ------------------ 4396| 103| yyterminate(); ------------------ | | 2358| 103|#define yyterminate() return YY_NULL | | ------------------ | | | | 109| 103|#define YY_NULL 0 | | ------------------ ------------------ 4397| 102| } 4398| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4399| 0|case YY_STATE_EOF(EXTENDED_COMMENT): ------------------ | | 128| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4399:1): [True: 0, False: 6.57M] ------------------ 4400| 0|case YY_STATE_EOF(GROUP_WITH_PARAMS): ------------------ | | 128| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4400:1): [True: 0, False: 6.57M] ------------------ 4401| 0|case YY_STATE_EOF(GROUP_MINUS_PARAMS): ------------------ | | 128| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4401:1): [True: 0, False: 6.57M] ------------------ 4402| 0|#line 1021 "scan.l" 4403| 0|{ 4404| 0| synerr( _( "EOF encountered inside pattern" ) ); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 4405| 0| yyterminate(); ------------------ | | 2358| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 109| 0|#define YY_NULL 0 | | ------------------ ------------------ 4406| 0| } 4407| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4408| 2|case 264: ------------------ | Branch (4408:1): [True: 2, False: 6.57M] ------------------ 4409| 2|YY_RULE_SETUP ------------------ | | 2397| 2| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 2, False: 0] | | ------------------ | | 2398| 2| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 2| (yytext[yyleng - 1] == '\n'); \ | | 2400| 2| YY_USER_ACTION ------------------ 4410| 2|#line 1026 "scan.l" 4411| 2|{ 4412| 2| yylval = myesc( (unsigned char *) yytext ); 4413| | 4414| 2| if ( YY_START == FIRSTCCL ) ------------------ | | 125| 2|#define YY_START (((yy_start) - 1) / 2) ------------------ if ( YY_START == FIRSTCCL ) ------------------ | | 2195| 2|#define FIRSTCCL 10 ------------------ | Branch (4414:9): [True: 1, False: 1] ------------------ 4415| 1| BEGIN(CCL); ------------------ | | 120| 1|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); ------------------ | | 2196| 1|#define CCL 11 ------------------ 4416| | 4417| 2| return CHAR; ------------------ | | 109| 2|#define CHAR 258 ------------------ 4418| 0| } 4419| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4420| | 4421| 1.70M|case 265: ------------------ | Branch (4421:1): [True: 1.70M, False: 4.86M] ------------------ 4422| 1.70M|YY_RULE_SETUP ------------------ | | 2397| 1.70M| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 1.70M, False: 0] | | ------------------ | | 2398| 1.70M| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 1.70M|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 1.70M| (yytext[yyleng - 1] == '\n'); \ | | 2400| 1.70M| YY_USER_ACTION ------------------ 4423| 1.70M|#line 1036 "scan.l" 4424| 1.70M|fputs(escaped_qstart, yyout); 4425| 1.70M| YY_BREAK ------------------ | | 2393| 1.70M|#define YY_BREAK /*LINTED*/break; ------------------ 4426| 292k|case 266: ------------------ | Branch (4426:1): [True: 292k, False: 6.28M] ------------------ 4427| 292k|YY_RULE_SETUP ------------------ | | 2397| 292k| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 292k, False: 0] | | ------------------ | | 2398| 292k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 292k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 292k| (yytext[yyleng - 1] == '\n'); \ | | 2400| 292k| YY_USER_ACTION ------------------ 4428| 292k|#line 1037 "scan.l" 4429| 292k|fputs(escaped_qend, yyout); 4430| 292k| YY_BREAK ------------------ | | 2393| 292k|#define YY_BREAK /*LINTED*/break; ------------------ 4431| 566k|case 267: ------------------ | Branch (4431:1): [True: 566k, False: 6.00M] ------------------ 4432| |/* rule 267 can match eol */ 4433| 566k|YY_RULE_SETUP ------------------ | | 2397| 566k| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 566k, False: 0] | | ------------------ | | 2398| 566k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 566k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 566k| (yytext[yyleng - 1] == '\n'); \ | | 2400| 566k| YY_USER_ACTION ------------------ 4434| 566k|#line 1038 "scan.l" 4435| 566k|ECHO; ------------------ | | 2314| 566k|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | Branch (2314:23): [True: 566k, False: 0] | | | Branch (2314:80): [Folded, False: 566k] | | ------------------ ------------------ 4436| 566k| YY_BREAK ------------------ | | 2393| 566k|#define YY_BREAK /*LINTED*/break; ------------------ 4437| 510k|case 268: ------------------ | Branch (4437:1): [True: 510k, False: 6.06M] ------------------ 4438| 510k|YY_RULE_SETUP ------------------ | | 2397| 510k| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 510k, False: 0] | | ------------------ | | 2398| 510k| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 510k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 510k| (yytext[yyleng - 1] == '\n'); \ | | 2400| 510k| YY_USER_ACTION ------------------ 4439| 510k|#line 1039 "scan.l" 4440| 510k|ECHO; ------------------ | | 2314| 510k|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | Branch (2314:23): [True: 510k, False: 0] | | | Branch (2314:80): [Folded, False: 510k] | | ------------------ ------------------ 4441| 510k| YY_BREAK ------------------ | | 2393| 510k|#define YY_BREAK /*LINTED*/break; ------------------ 4442| 546|case YY_STATE_EOF(SECT3): ------------------ | | 128| 546|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 546|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4442:1): [True: 546, False: 6.57M] ------------------ 4443| 546|#line 1040 "scan.l" 4444| 546|{ 4445| 546| sectnum = 0; 4446| 546| yyterminate(); ------------------ | | 2358| 546|#define yyterminate() return YY_NULL | | ------------------ | | | | 109| 546|#define YY_NULL 0 | | ------------------ ------------------ 4447| 0| } 4448| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4449| | 4450| | 4451| 0|case 269: ------------------ | Branch (4451:1): [True: 0, False: 6.57M] ------------------ 4452| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4453| 0|#line 1046 "scan.l" 4454| 0|fprintf(yyout, "[""[%s]""]", escaped_qstart); 4455| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4456| 0|case 270: ------------------ | Branch (4456:1): [True: 0, False: 6.57M] ------------------ 4457| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4458| 0|#line 1047 "scan.l" 4459| 0|fprintf(yyout, "[""[%s]""]", escaped_qend); 4460| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4461| 0|case 271: ------------------ | Branch (4461:1): [True: 0, False: 6.57M] ------------------ 4462| |/* rule 271 can match eol */ 4463| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4464| 0|#line 1048 "scan.l" 4465| 0|ECHO; ------------------ | | 2314| 0|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | Branch (2314:23): [True: 0, False: 0] | | | Branch (2314:80): [Folded, False: 0] | | ------------------ ------------------ 4466| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4467| 0|case 272: ------------------ | Branch (4467:1): [True: 0, False: 6.57M] ------------------ 4468| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4469| 0|#line 1049 "scan.l" 4470| 0|ECHO; ------------------ | | 2314| 0|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | Branch (2314:23): [True: 0, False: 0] | | | Branch (2314:80): [Folded, False: 0] | | ------------------ ------------------ 4471| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4472| 0|case YY_STATE_EOF(SECT3_NOESCAPE): ------------------ | | 128| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4472:1): [True: 0, False: 6.57M] ------------------ 4473| 0|#line 1050 "scan.l" 4474| 0|{ 4475| 0| sectnum = 0; 4476| 0| yyterminate(); ------------------ | | 2358| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 109| 0|#define YY_NULL 0 | | ------------------ ------------------ 4477| 0| } 4478| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4479| | 4480| 23|case 273: ------------------ | Branch (4480:1): [True: 23, False: 6.57M] ------------------ 4481| |/* rule 273 can match eol */ 4482| 23|YY_RULE_SETUP ------------------ | | 2397| 23| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 23, False: 0] | | ------------------ | | 2398| 23| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 23|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 23| (yytext[yyleng - 1] == '\n'); \ | | 2400| 23| YY_USER_ACTION ------------------ 4483| 23|#line 1055 "scan.l" 4484| 23|format_synerr( _( "bad character: %s" ), yytext ); ------------------ | | 102| 23|#define _(STRING) STRING ------------------ 4485| 23| YY_BREAK ------------------ | | 2393| 23|#define YY_BREAK /*LINTED*/break; ------------------ 4486| 0|case 274: ------------------ | Branch (4486:1): [True: 0, False: 6.57M] ------------------ 4487| 0|YY_RULE_SETUP ------------------ | | 2397| 0| if ( yyleng > 0 ) \ | | ------------------ | | | Branch (2397:7): [True: 0, False: 0] | | ------------------ | | 2398| 0| YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ | | ------------------ | | | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2399| 0| (yytext[yyleng - 1] == '\n'); \ | | 2400| 0| YY_USER_ACTION ------------------ 4488| 0|#line 1057 "scan.l" 4489| 0|YY_FATAL_ERROR( "flex scanner jammed" ); ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 4490| 0| YY_BREAK ------------------ | | 2393| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4491| 0|#line 4492 "scan.c" 4492| 19|case YY_STATE_EOF(INITIAL): ------------------ | | 128| 19|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 19|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4492:1): [True: 19, False: 6.57M] ------------------ 4493| 32|case YY_STATE_EOF(SECT2): ------------------ | | 128| 32|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 32|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4493:1): [True: 13, False: 6.57M] ------------------ 4494| 37|case YY_STATE_EOF(CODEBLOCK): ------------------ | | 128| 37|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 37|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4494:1): [True: 5, False: 6.57M] ------------------ 4495| 74|case YY_STATE_EOF(PICKUPDEF): ------------------ | | 128| 74|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 74|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4495:1): [True: 37, False: 6.57M] ------------------ 4496| 74|case YY_STATE_EOF(SC): ------------------ | | 128| 74|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 74|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4496:1): [True: 0, False: 6.57M] ------------------ 4497| 74|case YY_STATE_EOF(CARETISBOL): ------------------ | | 128| 74|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 74|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4497:1): [True: 0, False: 6.57M] ------------------ 4498| 74|case YY_STATE_EOF(NUM): ------------------ | | 128| 74|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 74|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4498:1): [True: 0, False: 6.57M] ------------------ 4499| 79|case YY_STATE_EOF(QUOTE): ------------------ | | 128| 79|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 79|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4499:1): [True: 5, False: 6.57M] ------------------ 4500| 79|case YY_STATE_EOF(FIRSTCCL): ------------------ | | 128| 79|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 79|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4500:1): [True: 0, False: 6.57M] ------------------ 4501| 86|case YY_STATE_EOF(CCL): ------------------ | | 128| 86|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 86|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4501:1): [True: 7, False: 6.57M] ------------------ 4502| 86|case YY_STATE_EOF(RECOVER): ------------------ | | 128| 86|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 86|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4502:1): [True: 0, False: 6.57M] ------------------ 4503| 127|case YY_STATE_EOF(PERCENT_BRACE_ACTION): ------------------ | | 128| 127|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 127|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4503:1): [True: 41, False: 6.57M] ------------------ 4504| 127|case YY_STATE_EOF(OPTION): ------------------ | | 128| 127|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 127|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4504:1): [True: 0, False: 6.57M] ------------------ 4505| 127|case YY_STATE_EOF(LINEDIR): ------------------ | | 128| 127|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 127|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (4505:1): [True: 0, False: 6.57M] ------------------ 4506| 127| yyterminate(); ------------------ | | 2358| 127|#define yyterminate() return YY_NULL | | ------------------ | | | | 109| 127|#define YY_NULL 0 | | ------------------ ------------------ 4507| | 4508| 3.49M| case YY_END_OF_BUFFER: ------------------ | | 358| 3.49M|#define YY_END_OF_BUFFER 275 ------------------ | Branch (4508:2): [True: 3.49M, False: 3.07M] ------------------ 4509| 3.49M| { 4510| | /* Amount of text matched not including the EOB char. */ 4511| 3.49M| int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; ------------------ | | 341| 3.49M|#define yytext_ptr yytext ------------------ 4512| | 4513| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 4514| 3.49M| *yy_cp = (yy_hold_char); 4515| 3.49M| YY_RESTORE_YY_MORE_OFFSET 4516| | 4517| 3.49M| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 268| 3.49M|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 234| 3.49M|#define YY_BUFFER_NEW 0 ------------------ | Branch (4517:8): [True: 777, False: 3.49M] ------------------ 4518| 777| { 4519| | /* We're scanning a new file or input source. It's 4520| | * possible that this happened because the user 4521| | * just pointed yyin at a new source and called 4522| | * yylex(). If so, then we have to assure 4523| | * consistency between YY_CURRENT_BUFFER and our 4524| | * globals. Here is the right place to do so, because 4525| | * this is the first action (other than possibly a 4526| | * back-up) that will match for the new input source. 4527| | */ 4528| 777| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 268| 777|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4529| 777| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 268| 777|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4530| 777| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 268| 777|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 235| 777|#define YY_BUFFER_NORMAL 1 ------------------ 4531| 777| } 4532| | 4533| | /* Note that here we test for yy_c_buf_p "<=" to the position 4534| | * of the first EOB in the buffer, since yy_c_buf_p will 4535| | * already have been incremented past the NUL character 4536| | * (since all states make transitions on EOB to the 4537| | * end-of-buffer state). Contrast this with the test 4538| | * in input(). 4539| | */ 4540| 3.49M| if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) ------------------ | | 268| 3.49M|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (4540:8): [True: 3.48M, False: 6.53k] ------------------ 4541| 3.48M| { /* This was really a NUL. */ 4542| 3.48M| yy_state_type yy_next_state; 4543| | 4544| 3.48M| (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; ------------------ | | 341| 3.48M|#define yytext_ptr yytext ------------------ 4545| | 4546| 3.48M| yy_current_state = yy_get_previous_state( ); 4547| | 4548| | /* Okay, we're now positioned to make the NUL 4549| | * transition. We couldn't have 4550| | * yy_get_previous_state() go ahead and do it 4551| | * for us because it doesn't know how to deal 4552| | * with the possibility of jamming (and we don't 4553| | * want to build jamming into it because then it 4554| | * will run more slowly). 4555| | */ 4556| | 4557| 3.48M| yy_next_state = yy_try_NUL_trans( yy_current_state ); 4558| | 4559| 3.48M| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 341| 3.48M|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 2067| 3.48M|#define YY_MORE_ADJ 0 ------------------ 4560| | 4561| 3.48M| if ( yy_next_state ) ------------------ | Branch (4561:9): [True: 3.40M, False: 84.1k] ------------------ 4562| 3.40M| { 4563| | /* Consume the NUL. */ 4564| 3.40M| yy_cp = ++(yy_c_buf_p); 4565| 3.40M| yy_current_state = yy_next_state; 4566| 3.40M| goto yy_match; 4567| 3.40M| } 4568| | 4569| 84.1k| else 4570| 84.1k| { 4571| 84.1k| yy_cp = (yy_c_buf_p); 4572| 84.1k| goto yy_find_action; 4573| 84.1k| } 4574| 3.48M| } 4575| | 4576| 6.53k| else switch ( yy_get_next_buffer( ) ) ------------------ | Branch (4576:17): [True: 6.53k, False: 0] ------------------ 4577| 6.53k| { 4578| 777| case EOB_ACT_END_OF_FILE: ------------------ | | 165| 777|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (4578:4): [True: 777, False: 5.75k] ------------------ 4579| 777| { 4580| 777| (yy_did_buffer_switch_on_eof) = 0; 4581| | 4582| 777| if ( yywrap( ) ) ------------------ | Branch (4582:10): [True: 777, False: 0] ------------------ 4583| 777| { 4584| | /* Note: because we've taken care in 4585| | * yy_get_next_buffer() to have set up 4586| | * yytext, we can now set up 4587| | * yy_c_buf_p so that if some total 4588| | * hoser (like flex itself) wants to 4589| | * call the scanner after we return the 4590| | * YY_NULL, it'll still work - another 4591| | * YY_NULL will get returned. 4592| | */ 4593| 777| (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 341| 777|#define yytext_ptr yytext ------------------ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 2067| 777|#define YY_MORE_ADJ 0 ------------------ 4594| | 4595| 777| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 128| 777|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 358| 777|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ 4596| 777| goto do_action; 4597| 777| } 4598| | 4599| 0| else 4600| 0| { 4601| 0| if ( ! (yy_did_buffer_switch_on_eof) ) ------------------ | Branch (4601:11): [True: 0, False: 0] ------------------ 4602| 0| YY_NEW_FILE; ------------------ | | 130| 0|#define YY_NEW_FILE yyrestart( yyin ) ------------------ 4603| 0| } 4604| 0| break; 4605| 777| } 4606| | 4607| 5.04k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 164| 5.04k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (4607:4): [True: 5.04k, False: 1.48k] ------------------ 4608| 5.04k| (yy_c_buf_p) = 4609| 5.04k| (yytext_ptr) + yy_amount_of_matched_text; ------------------ | | 341| 5.04k|#define yytext_ptr yytext ------------------ 4610| | 4611| 5.04k| yy_current_state = yy_get_previous_state( ); 4612| | 4613| 5.04k| yy_cp = (yy_c_buf_p); 4614| 5.04k| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 341| 5.04k|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 2067| 5.04k|#define YY_MORE_ADJ 0 ------------------ 4615| 5.04k| goto yy_match; 4616| | 4617| 706| case EOB_ACT_LAST_MATCH: ------------------ | | 166| 706|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (4617:4): [True: 706, False: 5.82k] ------------------ 4618| 706| (yy_c_buf_p) = 4619| 706| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; ------------------ | | 268| 706|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4620| | 4621| 706| yy_current_state = yy_get_previous_state( ); 4622| | 4623| 706| yy_cp = (yy_c_buf_p); 4624| 706| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 341| 706|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 2067| 706|#define YY_MORE_ADJ 0 ------------------ 4625| 706| goto yy_find_action; 4626| 6.53k| } 4627| 0| break; 4628| 3.49M| } 4629| | 4630| 0| default: ------------------ | Branch (4630:2): [True: 0, False: 6.57M] ------------------ 4631| 0| YY_FATAL_ERROR( ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 4632| 6.57M| "fatal flex scanner internal error--no action found" ); 4633| 6.57M| } /* end of action switch */ 4634| 6.57M| } /* end of scanning one token */ 4635| 2.08k| } /* end of user's declarations */ 4636| 2.08k|} /* end of yylex */ yyrestart: 4962| 777|{ 4963| | 4964| 777| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 262| 777|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (262:29): [True: 777, False: 0] | | ------------------ | | 263| 777| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 264| 777| : NULL) ------------------ | Branch (4964:7): [True: 0, False: 777] ------------------ 4965| 0| yyensure_buffer_stack (); 4966| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4967| 0| yy_create_buffer( yyin, YY_BUF_SIZE ); ------------------ | | 142| 0|#define YY_BUF_SIZE 16384 ------------------ 4968| 0| } 4969| | 4970| | yy_init_buffer( YY_CURRENT_BUFFER, input_file ); ------------------ | | 262| 777|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (262:29): [True: 777, False: 0] | | ------------------ | | 263| 777| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 264| 777| : NULL) ------------------ 4971| 777| yy_load_buffer_state( ); 4972| 777|} yy_create_buffer: 5024| 1|{ 5025| 1| YY_BUFFER_STATE b; 5026| | 5027| 1| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); 5028| 1| if ( ! b ) ------------------ | Branch (5028:7): [True: 0, False: 1] ------------------ 5029| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 5030| | 5031| 1| b->yy_buf_size = size; 5032| | 5033| | /* yy_ch_buf has to be 2 characters longer than the size given because 5034| | * we need to put in 2 end-of-buffer characters. 5035| | */ 5036| 1| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); 5037| 1| if ( ! b->yy_ch_buf ) ------------------ | Branch (5037:7): [True: 0, False: 1] ------------------ 5038| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 5039| | 5040| 1| b->yy_is_our_buffer = 1; 5041| | 5042| 1| yy_init_buffer( b, file ); 5043| | 5044| 1| return b; 5045| 1|} yy_flush_buffer: 5099| 778|{ 5100| 778| if ( ! b ) ------------------ | Branch (5100:11): [True: 0, False: 778] ------------------ 5101| 0| return; 5102| | 5103| 778| b->yy_n_chars = 0; 5104| | 5105| | /* We always need two end-of-buffer characters. The first causes 5106| | * a transition to the end-of-buffer state. The second causes 5107| | * a jam in that state. 5108| | */ 5109| 778| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 131| 778|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 5110| 778| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 131| 778|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 5111| | 5112| 778| b->yy_buf_pos = &b->yy_ch_buf[0]; 5113| | 5114| 778| b->yy_at_bol = 1; 5115| 778| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 234| 778|#define YY_BUFFER_NEW 0 ------------------ 5116| | 5117| 778| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 262| 778|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (262:29): [True: 778, False: 0] | | ------------------ | | 263| 778| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 264| 778| : NULL) ------------------ | Branch (5117:7): [True: 777, False: 1] ------------------ 5118| 777| yy_load_buffer_state( ); 5119| 778|} yyalloc: 5529| 4|{ 5530| 4| return malloc(size); 5531| 4|} yyrealloc: 5534| 7|{ 5535| | 5536| | /* The cast to (char *) in the following accommodates both 5537| | * implementations that use char* generic pointers, and those 5538| | * that use void* generic pointers. It works with the latter 5539| | * because both ANSI C and C++ allow castless assignment from 5540| | * any pointer type to void*, and deal with argument conversions 5541| | * as though doing an assignment. 5542| | */ 5543| 7| return realloc(ptr, size); 5544| 7|} yywrap: 5558| 777| { 5559| 777| if ( --num_input_files > 0 ) ------------------ | Branch (5559:7): [True: 0, False: 777] ------------------ 5560| 0| { 5561| 0| set_input_file( *++input_files ); 5562| 0| return 0; 5563| 0| } 5564| | 5565| 777| else 5566| 777| return 1; 5567| 777| } set_input_file: 5573| 778| { 5574| 778| if ( file && strcmp( file, "-" ) ) ------------------ | Branch (5574:7): [True: 778, False: 0] | Branch (5574:15): [True: 778, False: 0] ------------------ 5575| 778| { 5576| 778| infilename = xstrdup(file); 5577| 778| yyin = fopen( infilename, "r" ); 5578| | 5579| 778| if ( yyin == NULL ) ------------------ | Branch (5579:8): [True: 0, False: 778] ------------------ 5580| 0| lerr( _( "can't open %s: %s" ), file, strerror(errno)); ------------------ | | 102| 0|#define _(STRING) STRING ------------------ 5581| 778| } 5582| | 5583| 0| else 5584| 0| { 5585| 0| yyin = stdin; 5586| 0| infilename = xstrdup(""); 5587| 0| } 5588| | 5589| 778| linenum = 1; 5590| 778| } scan.c:yy_get_next_buffer: 4646| 6.53k|{ 4647| 6.53k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 268| 6.53k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4648| 6.53k| char *source = (yytext_ptr); ------------------ | | 341| 6.53k|#define yytext_ptr yytext ------------------ 4649| 6.53k| int number_to_move, i; 4650| 6.53k| int ret_val; 4651| | 4652| 6.53k| if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) ------------------ | | 268| 6.53k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (4652:7): [True: 0, False: 6.53k] ------------------ 4653| 0| YY_FATAL_ERROR( ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 4654| 6.53k| "fatal flex scanner internal error--end of buffer missed" ); 4655| | 4656| 6.53k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 268| 6.53k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (4656:7): [True: 0, False: 6.53k] ------------------ 4657| 0| { /* Don't try to fill the buffer, so this is an EOF. */ 4658| 0| if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) ------------------ | | 341| 0|#define yytext_ptr yytext ------------------ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) ------------------ | | 2067| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (4658:8): [True: 0, False: 0] ------------------ 4659| 0| { 4660| | /* We matched a single character, the EOB, so 4661| | * treat this as a final EOF. 4662| | */ 4663| 0| return EOB_ACT_END_OF_FILE; ------------------ | | 165| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 4664| 0| } 4665| | 4666| 0| else 4667| 0| { 4668| | /* We matched some text prior to the EOB, first 4669| | * process it. 4670| | */ 4671| 0| return EOB_ACT_LAST_MATCH; ------------------ | | 166| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 4672| 0| } 4673| 0| } 4674| | 4675| | /* Try to read more data. */ 4676| | 4677| | /* First move last chars to start of buffer. */ 4678| 6.53k| number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); ------------------ | | 341| 6.53k|#define yytext_ptr yytext ------------------ 4679| | 4680| 188M| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (4680:15): [True: 188M, False: 6.53k] ------------------ 4681| 188M| *(dest++) = *(source++); 4682| | 4683| 6.53k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 268| 6.53k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 246| 6.53k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (4683:7): [True: 706, False: 5.82k] ------------------ 4684| | /* don't do the read, it's not guaranteed to return an EOF, 4685| | * just force an EOF 4686| | */ 4687| 706| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; ------------------ | | 268| 706|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4688| | 4689| 5.82k| else 4690| 5.82k| { 4691| 5.82k| int num_to_read = 4692| 5.82k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 268| 5.82k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4693| | 4694| 5.83k| while ( num_to_read <= 0 ) ------------------ | Branch (4694:11): [True: 7, False: 5.82k] ------------------ 4695| 7| { /* Not enough room in the buffer - grow it. */ 4696| | 4697| | /* just a shorter name for the current buffer */ 4698| 7| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 268| 7|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4699| | 4700| 7| int yy_c_buf_p_offset = 4701| 7| (int) ((yy_c_buf_p) - b->yy_ch_buf); 4702| | 4703| 7| if ( b->yy_is_our_buffer ) ------------------ | Branch (4703:9): [True: 7, False: 0] ------------------ 4704| 7| { 4705| 7| int new_size = b->yy_buf_size * 2; 4706| | 4707| 7| if ( new_size <= 0 ) ------------------ | Branch (4707:10): [True: 0, False: 7] ------------------ 4708| 0| b->yy_buf_size += b->yy_buf_size / 8; 4709| 7| else 4710| 7| b->yy_buf_size *= 2; 4711| | 4712| 7| b->yy_ch_buf = (char *) 4713| | /* Include room in for 2 EOB chars. */ 4714| 7| yyrealloc( (void *) b->yy_ch_buf, 4715| 7| (yy_size_t) (b->yy_buf_size + 2) ); 4716| 7| } 4717| 0| else 4718| | /* Can't grow it, we don't own it. */ 4719| 0| b->yy_ch_buf = NULL; 4720| | 4721| 7| if ( ! b->yy_ch_buf ) ------------------ | Branch (4721:9): [True: 0, False: 7] ------------------ 4722| 0| YY_FATAL_ERROR( ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 4723| 7| "fatal error - scanner input buffer overflow" ); 4724| | 4725| 7| (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 4726| | 4727| 7| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 268| 7|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4728| 7| number_to_move - 1; 4729| | 4730| 7| } 4731| | 4732| 5.82k| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 2305| 5.82k|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (4732:8): [True: 5.79k, False: 30] ------------------ 4733| 5.79k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 2305| 5.79k|#define YY_READ_BUF_SIZE 8192 ------------------ 4734| | 4735| | /* Read in more data. */ 4736| 5.82k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 2322| 5.82k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 268| 5.82k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | | Branch (2322:7): [True: 0, False: 5.82k] | | ------------------ | | 2323| 5.82k| { \ | | 2324| 0| int c = '*'; \ | | 2325| 0| int n; \ | | 2326| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (2326:16): [True: 0, False: 0] | | ------------------ | | 2327| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | Branch (2327:9): [True: 0, False: 0] | | | Branch (2327:38): [True: 0, False: 0] | | ------------------ | | 2328| 0| buf[n] = (char) c; \ | | 2329| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (2329:8): [True: 0, False: 0] | | ------------------ | | 2330| 0| buf[n++] = (char) c; \ | | 2331| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | Branch (2331:8): [True: 0, False: 0] | | | Branch (2331:20): [True: 0, False: 0] | | ------------------ | | 2332| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) | | ------------------ | | 2333| 0| result = n; \ | | 2334| 0| } \ | | 2335| 5.82k| else \ | | 2336| 5.82k| { \ | | 2337| 5.82k| errno=0; \ | | 2338| 5.82k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | Branch (2338:11): [True: 777, False: 5.04k] | | | Branch (2338:78): [True: 0, False: 777] | | ------------------ | | 2339| 5.82k| { \ | | 2340| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (2340:8): [True: 0, False: 0] | | ------------------ | | 2341| 0| { \ | | 2342| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) | | ------------------ | | 2343| 0| break; \ | | 2344| 0| } \ | | 2345| 0| errno=0; \ | | 2346| 0| clearerr(yyin); \ | | 2347| 0| } \ | | 2348| 5.82k| }\ ------------------ 4737| 5.82k| (yy_n_chars), num_to_read ); 4738| | 4739| 5.82k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ------------------ | | 268| 5.82k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4740| 5.82k| } 4741| | 4742| 6.53k| if ( (yy_n_chars) == 0 ) ------------------ | Branch (4742:7): [True: 1.48k, False: 5.04k] ------------------ 4743| 1.48k| { 4744| 1.48k| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 2067| 1.48k|#define YY_MORE_ADJ 0 ------------------ | Branch (4744:8): [True: 777, False: 706] ------------------ 4745| 777| { 4746| 777| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 165| 777|#define EOB_ACT_END_OF_FILE 1 ------------------ 4747| 777| yyrestart( yyin ); 4748| 777| } 4749| | 4750| 706| else 4751| 706| { 4752| 706| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 166| 706|#define EOB_ACT_LAST_MATCH 2 ------------------ 4753| 706| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 268| 706|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4754| 706| YY_BUFFER_EOF_PENDING; ------------------ | | 246| 706|#define YY_BUFFER_EOF_PENDING 2 ------------------ 4755| 706| } 4756| 1.48k| } 4757| | 4758| 5.04k| else 4759| 5.04k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 164| 5.04k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 4760| | 4761| 6.53k| if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 268| 6.53k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (4761:6): [True: 0, False: 6.53k] ------------------ 4762| | /* Extend the array by 50%, plus the number we really need. */ 4763| 0| int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 4764| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4765| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4766| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (4766:8): [True: 0, False: 0] ------------------ 4767| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 4768| | /* "- 2" to take care of EOB's */ 4769| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4770| 0| } 4771| | 4772| 6.53k| (yy_n_chars) += number_to_move; 4773| 6.53k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ------------------ | | 268| 6.53k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ------------------ | | 131| 6.53k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4774| 6.53k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 268| 6.53k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 131| 6.53k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4775| | 4776| 6.53k| (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 341| 6.53k|#define yytext_ptr yytext ------------------ (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 268| 6.53k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4777| | 4778| 6.53k| return ret_val; 4779| 6.53k|} scan.c:yy_get_previous_state: 4784| 3.49M|{ 4785| 3.49M| yy_state_type yy_current_state; 4786| 3.49M| char *yy_cp; 4787| | 4788| 3.49M| yy_current_state = (yy_start); 4789| 3.49M| yy_current_state += YY_AT_BOL(); ------------------ | | 325| 3.49M|#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) | | ------------------ | | | | 268| 3.49M|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ ------------------ 4790| | 4791| 35.1G| for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) ------------------ | | 341| 3.49M|#define yytext_ptr yytext ------------------ for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) ------------------ | | 2067| 3.49M|#define YY_MORE_ADJ 0 ------------------ | Branch (4791:44): [True: 35.1G, False: 3.49M] ------------------ 4792| 35.1G| { 4793| 35.1G| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 114| 649M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (4793:19): [True: 649M, False: 34.4G] ------------------ 4794| 35.1G| if ( yy_accept[yy_current_state] ) ------------------ | Branch (4794:8): [True: 35.1G, False: 920] ------------------ 4795| 35.1G| { 4796| 35.1G| (yy_last_accepting_state) = yy_current_state; 4797| 35.1G| (yy_last_accepting_cpos) = yy_cp; 4798| 35.1G| } 4799| 70.2G| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (4799:11): [True: 35.1G, False: 35.1G] ------------------ 4800| 35.1G| { 4801| 35.1G| yy_current_state = (int) yy_def[yy_current_state]; 4802| 35.1G| if ( yy_current_state >= 1336 ) ------------------ | Branch (4802:9): [True: 35.1G, False: 209] ------------------ 4803| 35.1G| yy_c = yy_meta[yy_c]; 4804| 35.1G| } 4805| 35.1G| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 4806| 35.1G| } 4807| | 4808| 3.49M| return yy_current_state; 4809| 3.49M|} scan.c:yy_try_NUL_trans: 4817| 3.48M|{ 4818| 3.48M| int yy_is_jam; 4819| 3.48M| char *yy_cp = (yy_c_buf_p); 4820| | 4821| 3.48M| YY_CHAR yy_c = 1; 4822| 3.48M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (4822:7): [True: 3.48M, False: 394] ------------------ 4823| 3.48M| { 4824| 3.48M| (yy_last_accepting_state) = yy_current_state; 4825| 3.48M| (yy_last_accepting_cpos) = yy_cp; 4826| 3.48M| } 4827| 6.97M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (4827:10): [True: 3.48M, False: 3.48M] ------------------ 4828| 3.48M| { 4829| 3.48M| yy_current_state = (int) yy_def[yy_current_state]; 4830| 3.48M| if ( yy_current_state >= 1336 ) ------------------ | Branch (4830:8): [True: 3.40M, False: 84.1k] ------------------ 4831| 3.40M| yy_c = yy_meta[yy_c]; 4832| 3.48M| } 4833| 3.48M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 4834| 3.48M| yy_is_jam = (yy_current_state == 1335); 4835| | 4836| 3.48M| return yy_is_jam ? 0 : yy_current_state; ------------------ | Branch (4836:10): [True: 84.1k, False: 3.40M] ------------------ 4837| 3.48M|} scan.c:yyunput: 4842| 30|{ 4843| 30| char *yy_cp; 4844| | 4845| 30| yy_cp = (yy_c_buf_p); 4846| | 4847| | /* undo effects of setting up yytext */ 4848| 30| *yy_cp = (yy_hold_char); 4849| | 4850| 30| if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) ------------------ | | 268| 30|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (4850:7): [True: 0, False: 30] ------------------ 4851| 0| { /* need to shift things up to make room */ 4852| | /* +2 for EOB chars. */ 4853| 0| int number_to_move = (yy_n_chars) + 2; 4854| 0| char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4855| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4856| 0| char *source = 4857| 0| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4858| | 4859| 0| while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (4859:11): [True: 0, False: 0] ------------------ 4860| 0| *--dest = *--source; 4861| | 4862| 0| yy_cp += (int) (dest - source); 4863| 0| yy_bp += (int) (dest - source); 4864| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4865| 0| (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 4866| | 4867| 0| if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) ------------------ | | 268| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (4867:8): [True: 0, False: 0] ------------------ 4868| 0| YY_FATAL_ERROR( "flex scanner push-back overflow" ); ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 4869| 0| } 4870| | 4871| 30| *--yy_cp = (char) c; 4872| | 4873| 30| (yytext_ptr) = yy_bp; ------------------ | | 341| 30|#define yytext_ptr yytext ------------------ 4874| 30| (yy_hold_char) = *yy_cp; 4875| 30| (yy_c_buf_p) = yy_cp; 4876| 30|} scan.c:yy_load_buffer_state: 5010| 1.55k|{ 5011| 1.55k| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 268| 1.55k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5012| 1.55k| (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 341| 1.55k|#define yytext_ptr yytext ------------------ (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 268| 1.55k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5013| 1.55k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 268| 1.55k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5014| 1.55k| (yy_hold_char) = *(yy_c_buf_p); 5015| 1.55k|} scan.c:yy_init_buffer: 5072| 778|{ 5073| 778| int oerrno = errno; 5074| | 5075| 778| yy_flush_buffer( b ); 5076| | 5077| 778| b->yy_input_file = file; 5078| 778| b->yy_fill_buffer = 1; 5079| | 5080| | /* If b is the current buffer, then yy_init_buffer was _probably_ 5081| | * called from yyrestart() or through yy_get_next_buffer. 5082| | * In that case, we don't want to reset the lineno or column. 5083| | */ 5084| 778| if (b != YY_CURRENT_BUFFER){ ------------------ | | 262| 778|#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ | | ------------------ | | | Branch (262:29): [True: 778, False: 0] | | ------------------ | | 263| 778| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 264| 778| : NULL) ------------------ | Branch (5084:9): [True: 1, False: 777] ------------------ 5085| 1| b->yy_bs_lineno = 1; 5086| 1| b->yy_bs_column = 0; 5087| 1| } 5088| | 5089| 778| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ------------------ | Branch (5089:32): [True: 778, False: 0] ------------------ 5090| | 5091| | errno = oerrno; 5092| 778|} scan.c:yyensure_buffer_stack: 5177| 1|{ 5178| 1| yy_size_t num_to_alloc; 5179| | 5180| 1| if (!(yy_buffer_stack)) { ------------------ | Branch (5180:6): [True: 1, False: 0] ------------------ 5181| | 5182| | /* First allocation is just for 2 elements, since we don't know if this 5183| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 5184| | * immediate realloc on the next call. 5185| | */ 5186| 1| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 5187| 1| (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 5188| 1| (num_to_alloc * sizeof(struct yy_buffer_state*) 5189| 1| ); 5190| 1| if ( ! (yy_buffer_stack) ) ------------------ | Branch (5190:8): [True: 0, False: 1] ------------------ 5191| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 5192| | 5193| 1| memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 5194| | 5195| 1| (yy_buffer_stack_max) = num_to_alloc; 5196| 1| (yy_buffer_stack_top) = 0; 5197| 1| return; 5198| 1| } 5199| | 5200| 0| if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ ------------------ | Branch (5200:6): [True: 0, False: 0] ------------------ 5201| | 5202| | /* Increase the buffer to prepare for a possible push. */ 5203| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 5204| | 5205| 0| num_to_alloc = (yy_buffer_stack_max) + grow_size; 5206| 0| (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 5207| 0| ((yy_buffer_stack), 5208| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 5209| 0| ); 5210| 0| if ( ! (yy_buffer_stack) ) ------------------ | Branch (5210:8): [True: 0, False: 0] ------------------ 5211| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 5212| | 5213| | /* zero only the new slots.*/ 5214| 0| memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 5215| 0| (yy_buffer_stack_max) = num_to_alloc; 5216| 0| } 5217| 0|} scan.c:yy_push_state: 5306| 6|{ 5307| 6| if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) ) ------------------ | Branch (5307:11): [True: 1, False: 5] ------------------ 5308| 1| { 5309| 1| yy_size_t new_size; 5310| | 5311| 1| (yy_start_stack_depth) += YY_START_STACK_INCR; ------------------ | | 2363| 1|#define YY_START_STACK_INCR 25 ------------------ 5312| 1| new_size = (yy_size_t) (yy_start_stack_depth) * sizeof( int ); 5313| | 5314| 1| if ( ! (yy_start_stack) ) ------------------ | Branch (5314:8): [True: 1, False: 0] ------------------ 5315| 1| (yy_start_stack) = (int *) yyalloc( new_size ); 5316| | 5317| 0| else 5318| 0| (yy_start_stack) = (int *) yyrealloc( 5319| 0| (void *) (yy_start_stack), new_size ); 5320| | 5321| 1| if ( ! (yy_start_stack) ) ------------------ | Branch (5321:8): [True: 0, False: 1] ------------------ 5322| 0| YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 5323| 1| } 5324| | 5325| 6| (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START; ------------------ | | 125| 6|#define YY_START (((yy_start) - 1) / 2) ------------------ 5326| | 5327| 6| BEGIN(_new_state); ------------------ | | 120| 6|#define BEGIN (yy_start) = 1 + 2 * ------------------ 5328| 6|} scan.c:yy_pop_state: 5331| 6|{ 5332| 6| if ( --(yy_start_stack_ptr) < 0 ) ------------------ | Branch (5332:11): [True: 0, False: 6] ------------------ 5333| 0| YY_FATAL_ERROR( "start-condition stack underflow" ); ------------------ | | 2368| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ------------------ 5334| | 5335| 6| BEGIN((yy_start_stack)[(yy_start_stack_ptr)]); ------------------ | | 120| 6|#define BEGIN (yy_start) = 1 + 2 * ------------------ 5336| 6|} sf_init: 64| 778|{ 65| 778| assert(_sf_stk == NULL); 66| 778| _sf_max = 32; 67| 778| _sf_top_ix = 0; 68| 778| _sf_stk = malloc(sizeof(scanflags_t) * _sf_max); 69| 778| if (!_sf_stk) ------------------ | Branch (69:9): [True: 0, False: 778] ------------------ 70| 0| lerr_fatal(_("Unable to allocate %zu of stack"), sizeof(scanflags_t)); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 71| 778| _sf_stk[_sf_top_ix] = 0; 72| 778|} scanopt_init: 140| 778|{ 141| 778| int i; 142| 778| struct _scanopt_t *s; 143| 778| s = malloc(sizeof (struct _scanopt_t)); 144| | 145| 778| s->options = options; 146| 778| s->optc = 0; 147| 778| s->argc = argc; 148| 778| s->argv = (char **) argv; 149| 778| s->index = 1; 150| 778| s->subscript = 0; 151| 778| s->no_err_msg = (flags & SCANOPT_NO_ERR_MSG); 152| 778| s->has_long = 0; 153| 778| s->has_short = 0; 154| | 155| | /* Determine option count. (Find entry with all zeros). */ 156| 778| s->optc = 0; 157| 97.2k| while (options[s->optc].opt_fmt ------------------ | Branch (157:9): [True: 96.4k, False: 778] ------------------ 158| 778| || options[s->optc].r_val || options[s->optc].desc) ------------------ | Branch (158:12): [True: 0, False: 778] | Branch (158:38): [True: 0, False: 778] ------------------ 159| 96.4k| s->optc++; 160| | 161| | /* Build auxiliary data */ 162| 778| s->aux = malloc((size_t) s->optc * sizeof (struct _aux)); 163| | 164| 97.2k| for (i = 0; i < s->optc; i++) { ------------------ | Branch (164:14): [True: 96.4k, False: 778] ------------------ 165| 96.4k| const unsigned char *p, *pname; 166| 96.4k| const struct optspec_t *opt; 167| 96.4k| struct _aux *aux; 168| | 169| 96.4k| opt = s->options + i; 170| 96.4k| aux = s->aux + i; 171| | 172| 96.4k| aux->flags = ARG_NONE; ------------------ | | 42| 96.4k|#define ARG_NONE 0x01 ------------------ 173| | 174| 96.4k| if (opt->opt_fmt[0] == '-' && opt->opt_fmt[1] == '-') { ------------------ | Branch (174:7): [True: 96.4k, False: 0] | Branch (174:33): [True: 72.3k, False: 24.1k] ------------------ 175| 72.3k| aux->flags |= IS_LONG; ------------------ | | 45| 72.3k|#define IS_LONG 0x08 ------------------ 176| 72.3k| pname = (const unsigned char *)(opt->opt_fmt + 2); 177| 72.3k| s->has_long = 1; 178| 72.3k| } 179| 24.1k| else { 180| 24.1k| pname = (const unsigned char *)(opt->opt_fmt + 1); 181| 24.1k| s->has_short = 1; 182| 24.1k| } 183| 96.4k| aux->printlen = (int) strlen (opt->opt_fmt); 184| | 185| 96.4k| aux->namelen = 0; 186| 735k| for (p = pname + 1; *p; p++) { ------------------ | Branch (186:23): [True: 641k, False: 94.1k] ------------------ 187| | /* detect required arg */ 188| 641k| if (*p == '=' || isspace ((unsigned char)*p) ------------------ | Branch (188:8): [True: 5.44k, False: 635k] | Branch (188:21): [True: 3.11k, False: 632k] ------------------ 189| 632k| || !(aux->flags & IS_LONG)) { ------------------ | | 45| 632k|#define IS_LONG 0x08 ------------------ | Branch (189:11): [True: 18.6k, False: 613k] ------------------ 190| 27.2k| if (aux->namelen == 0) ------------------ | Branch (190:9): [True: 10.1k, False: 17.1k] ------------------ 191| 10.1k| aux->namelen = (int) (p - pname); 192| 27.2k| aux->flags |= ARG_REQ; ------------------ | | 43| 27.2k|#define ARG_REQ 0x02 ------------------ 193| 27.2k| aux->flags &= ~ARG_NONE; ------------------ | | 42| 27.2k|#define ARG_NONE 0x01 ------------------ 194| 27.2k| } 195| | /* detect optional arg. This overrides required arg. */ 196| 641k| if (*p == '[') { ------------------ | Branch (196:8): [True: 2.33k, False: 638k] ------------------ 197| 2.33k| if (aux->namelen == 0) ------------------ | Branch (197:9): [True: 1.55k, False: 778] ------------------ 198| 1.55k| aux->namelen = (int) (p - pname); 199| 2.33k| aux->flags &= ~(ARG_REQ | ARG_NONE); ------------------ | | 43| 2.33k|#define ARG_REQ 0x02 ------------------ aux->flags &= ~(ARG_REQ | ARG_NONE); ------------------ | | 42| 2.33k|#define ARG_NONE 0x01 ------------------ 200| 2.33k| aux->flags |= ARG_OPT; ------------------ | | 44| 2.33k|#define ARG_OPT 0x04 ------------------ 201| 2.33k| break; 202| 2.33k| } 203| 641k| } 204| 96.4k| if (aux->namelen == 0) ------------------ | Branch (204:7): [True: 84.8k, False: 11.6k] ------------------ 205| 84.8k| aux->namelen = (int) (p - pname); 206| 96.4k| } 207| 778| return (scanopt_t *) s; 208| 778|} scanopt: 617| 778|{ 618| 778| char *optname = NULL, *optarg = NULL, *pstart; 619| 778| int namelen = 0, arglen = 0; 620| 778| int errcode = 0, has_next; 621| 778| const optspec_t *optp; 622| 778| struct _scanopt_t *s; 623| 778| struct _aux *auxp; 624| 778| int is_short; 625| 778| int opt_offset = -1; 626| | 627| 778| s = (struct _scanopt_t *) svoid; 628| | 629| | /* Normalize return-parameters. */ 630| 778| SAFE_ASSIGN (arg, NULL); ------------------ | | 127| 778| do{ \ | | 128| 778| if((ptr)!=NULL) \ | | ------------------ | | | Branch (128:12): [True: 778, False: 0] | | ------------------ | | 129| 778| *(ptr) = val; \ | | 130| 778| }while(0) | | ------------------ | | | Branch (130:12): [Folded, False: 778] | | ------------------ ------------------ 631| 778| SAFE_ASSIGN (optindex, s->index); ------------------ | | 127| 778| do{ \ | | 128| 778| if((ptr)!=NULL) \ | | ------------------ | | | Branch (128:12): [True: 778, False: 0] | | ------------------ | | 129| 778| *(ptr) = val; \ | | 130| 778| }while(0) | | ------------------ | | | Branch (130:12): [Folded, False: 778] | | ------------------ ------------------ 632| | 633| 778| if (s->index >= s->argc) ------------------ | Branch (633:6): [True: 0, False: 778] ------------------ 634| 0| return 0; 635| | 636| | /* pstart always points to the start of our current scan. */ 637| 778| pstart = s->argv[s->index] + s->subscript; 638| 778| if (!pstart) ------------------ | Branch (638:6): [True: 0, False: 778] ------------------ 639| 0| return 0; 640| | 641| 778| if (s->subscript == 0) { ------------------ | Branch (641:6): [True: 778, False: 0] ------------------ 642| | 643| | /* test for exact match of "--" */ 644| 778| if (pstart[0] == '-' && pstart[1] == '-' && !pstart[2]) { ------------------ | Branch (644:7): [True: 0, False: 778] | Branch (644:27): [True: 0, False: 0] | Branch (644:47): [True: 0, False: 0] ------------------ 645| 0| SAFE_ASSIGN (optindex, s->index + 1); ------------------ | | 127| 0| do{ \ | | 128| 0| if((ptr)!=NULL) \ | | ------------------ | | | Branch (128:12): [True: 0, False: 0] | | ------------------ | | 129| 0| *(ptr) = val; \ | | 130| 0| }while(0) | | ------------------ | | | Branch (130:12): [Folded, False: 0] | | ------------------ ------------------ 646| 0| INC_INDEX (s, 1); ------------------ | | 134| 0| do{ \ | | 135| 0| (s)->index += (n); \ | | 136| 0| (s)->subscript= 0; \ | | 137| 0| }while(0) | | ------------------ | | | Branch (137:12): [Folded, False: 0] | | ------------------ ------------------ 647| 0| return 0; 648| 0| } 649| | 650| | /* Match an opt. */ 651| 778| if (matchlongopt ------------------ | Branch (651:7): [True: 0, False: 778] ------------------ 652| 778| (pstart, &optname, &namelen, &optarg, &arglen)) { 653| | 654| | /* it LOOKS like an opt, but is it one?! */ 655| 0| if (!find_opt ------------------ | Branch (655:8): [True: 0, False: 0] ------------------ 656| 0| (s, 1, optname, namelen, &errcode, 657| 0| &opt_offset)) { 658| 0| scanopt_err (s, 0, errcode); 659| 0| return errcode; 660| 0| } 661| | /* We handle this below. */ 662| 0| is_short = 0; 663| | 664| | /* Check for short opt. */ 665| 0| } 666| 778| else if (pstart[0] == '-' && pstart[1]) { ------------------ | Branch (666:12): [True: 0, False: 778] | Branch (666:32): [True: 0, False: 0] ------------------ 667| | /* Pass through to below. */ 668| 0| is_short = 1; 669| 0| s->subscript++; 670| 0| pstart++; 671| 0| } 672| | 673| 778| else { 674| | /* It's not an option. We're done. */ 675| 778| return 0; 676| 778| } 677| 778| } 678| | 679| | /* We have to re-check the subscript status because it 680| | * may have changed above. */ 681| | 682| 0| if (s->subscript != 0) { ------------------ | Branch (682:6): [True: 0, False: 0] ------------------ 683| | 684| | /* we are somewhere in a run of short opts, 685| | * e.g., at the 'z' in `tar -xzf` */ 686| | 687| 0| optname = pstart; 688| 0| namelen = 1; 689| 0| is_short = 1; 690| | 691| 0| if (!find_opt ------------------ | Branch (691:7): [True: 0, False: 0] ------------------ 692| 0| (s, 0, pstart, namelen, &errcode, &opt_offset)) { 693| 0| scanopt_err(s, 1, errcode); 694| 0| return errcode; 695| 0| } 696| | 697| 0| optarg = pstart + 1; 698| 0| if (!*optarg) { ------------------ | Branch (698:7): [True: 0, False: 0] ------------------ 699| 0| optarg = NULL; 700| 0| arglen = 0; 701| 0| } 702| 0| else 703| 0| arglen = (int) strlen (optarg); 704| 0| } 705| | 706| | /* At this point, we have a long or short option matched at opt_offset into 707| | * the s->options array (and corresponding aux array). 708| | * A trailing argument is in {optarg,arglen}, if any. 709| | */ 710| | 711| | /* Look ahead in argv[] to see if there is something 712| | * that we can use as an argument (if needed). */ 713| 0| has_next = s->index + 1 < s->argc; 714| | 715| 0| optp = s->options + opt_offset; 716| 0| auxp = s->aux + opt_offset; 717| | 718| | /* case: no args allowed */ 719| 0| if (auxp->flags & ARG_NONE) { ------------------ | | 42| 0|#define ARG_NONE 0x01 ------------------ | Branch (719:6): [True: 0, False: 0] ------------------ 720| 0| if (optarg && !is_short) { ------------------ | Branch (720:7): [True: 0, False: 0] | Branch (720:17): [True: 0, False: 0] ------------------ 721| 0| scanopt_err(s, is_short, SCANOPT_ERR_ARG_NOT_ALLOWED); 722| 0| INC_INDEX (s, 1); ------------------ | | 134| 0| do{ \ | | 135| 0| (s)->index += (n); \ | | 136| 0| (s)->subscript= 0; \ | | 137| 0| }while(0) | | ------------------ | | | Branch (137:12): [Folded, False: 0] | | ------------------ ------------------ 723| 0| return SCANOPT_ERR_ARG_NOT_ALLOWED; 724| 0| } 725| 0| else if (!optarg) ------------------ | Branch (725:12): [True: 0, False: 0] ------------------ 726| 0| INC_INDEX (s, 1); ------------------ | | 134| 0| do{ \ | | 135| 0| (s)->index += (n); \ | | 136| 0| (s)->subscript= 0; \ | | 137| 0| }while(0) | | ------------------ | | | Branch (137:12): [Folded, False: 0] | | ------------------ ------------------ 727| 0| else 728| 0| s->subscript++; 729| 0| return optp->r_val; 730| 0| } 731| | 732| | /* case: required */ 733| 0| if (auxp->flags & ARG_REQ) { ------------------ | | 43| 0|#define ARG_REQ 0x02 ------------------ | Branch (733:6): [True: 0, False: 0] ------------------ 734| 0| if (!optarg && !has_next) { ------------------ | Branch (734:7): [True: 0, False: 0] | Branch (734:18): [True: 0, False: 0] ------------------ 735| 0| scanopt_err(s, is_short, SCANOPT_ERR_ARG_NOT_FOUND); 736| 0| return SCANOPT_ERR_ARG_NOT_FOUND; 737| 0| } 738| | 739| 0| if (!optarg) { ------------------ | Branch (739:7): [True: 0, False: 0] ------------------ 740| | /* Let the next argv element become the argument. */ 741| 0| SAFE_ASSIGN (arg, s->argv[s->index + 1]); ------------------ | | 127| 0| do{ \ | | 128| 0| if((ptr)!=NULL) \ | | ------------------ | | | Branch (128:12): [True: 0, False: 0] | | ------------------ | | 129| 0| *(ptr) = val; \ | | 130| 0| }while(0) | | ------------------ | | | Branch (130:12): [Folded, False: 0] | | ------------------ ------------------ 742| 0| INC_INDEX (s, 2); ------------------ | | 134| 0| do{ \ | | 135| 0| (s)->index += (n); \ | | 136| 0| (s)->subscript= 0; \ | | 137| 0| }while(0) | | ------------------ | | | Branch (137:12): [Folded, False: 0] | | ------------------ ------------------ 743| 0| } 744| 0| else { 745| 0| SAFE_ASSIGN (arg, (char *) optarg); ------------------ | | 127| 0| do{ \ | | 128| 0| if((ptr)!=NULL) \ | | ------------------ | | | Branch (128:12): [True: 0, False: 0] | | ------------------ | | 129| 0| *(ptr) = val; \ | | 130| 0| }while(0) | | ------------------ | | | Branch (130:12): [Folded, False: 0] | | ------------------ ------------------ 746| 0| INC_INDEX (s, 1); ------------------ | | 134| 0| do{ \ | | 135| 0| (s)->index += (n); \ | | 136| 0| (s)->subscript= 0; \ | | 137| 0| }while(0) | | ------------------ | | | Branch (137:12): [Folded, False: 0] | | ------------------ ------------------ 747| 0| } 748| 0| return optp->r_val; 749| 0| } 750| | 751| | /* case: optional */ 752| 0| if (auxp->flags & ARG_OPT) { ------------------ | | 44| 0|#define ARG_OPT 0x04 ------------------ | Branch (752:6): [True: 0, False: 0] ------------------ 753| 0| SAFE_ASSIGN (arg, optarg); ------------------ | | 127| 0| do{ \ | | 128| 0| if((ptr)!=NULL) \ | | ------------------ | | | Branch (128:12): [True: 0, False: 0] | | ------------------ | | 129| 0| *(ptr) = val; \ | | 130| 0| }while(0) | | ------------------ | | | Branch (130:12): [Folded, False: 0] | | ------------------ ------------------ 754| 0| INC_INDEX (s, 1); ------------------ | | 134| 0| do{ \ | | 135| 0| (s)->index += (n); \ | | 136| 0| (s)->subscript= 0; \ | | 137| 0| }while(0) | | ------------------ | | | Branch (137:12): [Folded, False: 0] | | ------------------ ------------------ 755| 0| return optp->r_val; 756| 0| } 757| | 758| | 759| | /* Should not reach here. */ 760| 0| return 0; 761| 0|} scanopt_destroy: 765| 778|{ 766| 778| struct _scanopt_t *s; 767| | 768| 778| s = (struct _scanopt_t *) svoid; 769| 778| if (s != NULL) { ------------------ | Branch (769:6): [True: 778, False: 0] ------------------ 770| 778| free(s->aux); 771| 778| free(s); 772| 778| } 773| 778| return 0; 774| 778|} scanopt.c:matchlongopt: 517| 778|{ 518| 778| char *p; 519| | 520| 778| *optname = *arg = NULL; 521| 778| *optlen = *arglen = 0; 522| | 523| | /* Match regex /--./ */ 524| 778| p = str; 525| 778| if (p[0] != '-' || p[1] != '-' || !p[2]) ------------------ | Branch (525:6): [True: 778, False: 0] | Branch (525:21): [True: 0, False: 0] | Branch (525:36): [True: 0, False: 0] ------------------ 526| 778| return 0; 527| | 528| 0| p += 2; 529| 0| *optname = p; 530| | 531| | /* find the end of optname */ 532| 0| while (*p && *p != '=') ------------------ | Branch (532:9): [True: 0, False: 0] | Branch (532:15): [True: 0, False: 0] ------------------ 533| 0| ++p; 534| | 535| 0| *optlen = (int) (p - *optname); 536| | 537| 0| if (!*p) ------------------ | Branch (537:6): [True: 0, False: 0] ------------------ 538| | /* an option with no '=...' part. */ 539| 0| return 1; 540| | 541| | 542| | /* We saw an '=' char. The rest of p is the arg. */ 543| 0| p++; 544| 0| *arg = p; 545| 0| while (*p) ------------------ | Branch (545:9): [True: 0, False: 0] ------------------ 546| 0| ++p; 547| 0| *arglen = (int) (p - *arg); 548| | 549| 0| return 1; 550| 0|} is_default_backend: 80| 231|{ 81| 231| return backend == &backends[0]; 82| 231|} suffix: 133| 231|{ 134| 231| const char *suffix; 135| | 136| 231| if (is_default_backend()) { ------------------ | Branch (136:6): [True: 231, False: 0] ------------------ 137| 231| if (ctrl.C_plus_plus) ------------------ | Branch (137:7): [True: 0, False: 231] ------------------ 138| 0| suffix = "cc"; 139| 231| else 140| 231| suffix = "c"; 141| 231| } else { 142| 0| suffix = skel_property("M4_PROPERTY_SOURCE_SUFFIX"); 143| 0| } 144| | 145| 231| return suffix; 146| 231|} cclinstal: 113| 10|{ 114| | /* We don't bother checking the return status because we are not 115| | * called unless the symbol is new. 116| | */ 117| | 118| 10| (void) addsym(ccltxt, NULL, cclnum, ccltab, CCL_HASH_SIZE); ------------------ | | 55| 10|#define CCL_HASH_SIZE 101 ------------------ 119| 10|} ndinstal: 175| 37|{ 176| 37| if (addsym(name, definition, 0, ndtbl, NAME_TABLE_HASH_SIZE)) { ------------------ | | 53| 37|#define NAME_TABLE_HASH_SIZE 101 ------------------ | Branch (176:6): [True: 32, False: 5] ------------------ 177| | synerr (_("name defined twice")); ------------------ | | 100| 32|#define _(String) gettext (String) ------------------ 178| 32| } 179| 37|} scinstal: 213| 778|{ 214| | 215| 778| if (++lastsc >= current_max_scs) ------------------ | Branch (215:6): [True: 0, False: 778] ------------------ 216| 0| scextend (); 217| | 218| 778| if (addsym(str, NULL, lastsc, sctbl, START_COND_HASH_SIZE)) { ------------------ | | 54| 778|#define START_COND_HASH_SIZE 101 ------------------ | Branch (218:6): [True: 777, False: 1] ------------------ 219| 777| format_pinpoint_message ( 220| 777| _("start condition %s declared twice"), str); ------------------ | | 100| 777|#define _(String) gettext (String) ------------------ 221| 777| } 222| 778| scname[lastsc] = sctbl[hashfunct(str, START_COND_HASH_SIZE)]->name; ------------------ | | 54| 778|#define START_COND_HASH_SIZE 101 ------------------ 223| | 224| 778| scset[lastsc] = mkstate (SYM_EPSILON); ------------------ | | 234| 778|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 778|#define CSIZE 256 | | ------------------ ------------------ 225| 778| scbol[lastsc] = mkstate (SYM_EPSILON); ------------------ | | 234| 778|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 106| 778|#define CSIZE 256 | | ------------------ ------------------ 226| 778| scxclu[lastsc] = sc_is_exclusive ? 1 : 0; ------------------ | Branch (226:19): [True: 0, False: 778] ------------------ 227| | sceof[lastsc] = false; 228| 778|} sym.c:addsym: 76| 825|{ 77| 825| size_t hash_val = hashfunct (sym, table_size); 78| 825| struct hash_entry *sym_entry = table[hash_val]; 79| 825| struct hash_entry *new_entry; 80| | 81| 826| while (sym_entry) { ------------------ | Branch (81:9): [True: 813, False: 13] ------------------ 82| 813| if (!strcmp (sym, sym_entry->name)) { /* entry already exists */ ------------------ | Branch (82:7): [True: 812, False: 1] ------------------ 83| 812| return -1; 84| 812| } 85| | 86| 1| sym_entry = sym_entry->next; 87| 1| } 88| | 89| | /* create new entry */ 90| 13| new_entry = malloc(sizeof(struct hash_entry)); 91| | 92| 13| if (new_entry == NULL) ------------------ | Branch (92:6): [True: 0, False: 13] ------------------ 93| 0| flexfatal (_("symbol table memory allocation failed")); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 94| | 95| 13| new_entry->next = table[hash_val]; 96| 13| new_entry->name = xstrdup(sym); 97| 13| if (str_def == NULL) { ------------------ | Branch (97:6): [True: 8, False: 5] ------------------ 98| 8| new_entry->str_val = NULL; 99| 8| } else { 100| 5| new_entry->str_val = xstrdup(str_def); 101| 5| } 102| 13| new_entry->int_val = int_def; 103| | 104| 13| table[hash_val] = new_entry; 105| | 106| 13| return 0; 107| 825|} sym.c:hashfunct: 156| 1.60k|{ 157| 1.60k| size_t hashval; 158| 1.60k| size_t locstr; 159| | 160| 1.60k| hashval = 0; 161| 1.60k| locstr = 0; 162| | 163| 12.6k| while (str[locstr] != '\0') { ------------------ | Branch (163:9): [True: 11.0k, False: 1.60k] ------------------ 164| 11.0k| hashval = (hashval << 1) + (unsigned char) str[locstr++]; 165| 11.0k| hashval %= hash_size; 166| 11.0k| } 167| | 168| 1.60k| return hashval; 169| 1.60k|} yylex: 46| 2.31k|{ 47| 2.31k| int toktype; 48| 2.31k| static int beglin = false; 49| | 50| 2.31k| if (eofseen) { ------------------ | Branch (50:6): [True: 230, False: 2.08k] ------------------ 51| 230| toktype = EOF; 52| 2.08k| } else { 53| 2.08k| toktype = flexscan (); 54| 2.08k| } 55| 2.31k| if (toktype == EOF || toktype == 0) { ------------------ | Branch (55:6): [True: 230, False: 2.08k] | Branch (55:24): [True: 778, False: 1.30k] ------------------ 56| 1.00k| eofseen = true; 57| | 58| 1.00k| if (sectnum == 1) { ------------------ | Branch (58:7): [True: 230, False: 778] ------------------ 59| 230| synerr (_("premature EOF")); ------------------ | | 100| 230|#define _(String) gettext (String) ------------------ 60| 230| sectnum = 2; 61| 230| toktype = SECTEND; ------------------ | | 111| 230|#define SECTEND 260 ------------------ 62| 230| } 63| | 64| 778| else 65| 778| toktype = 0; 66| 1.00k| } 67| | 68| 2.31k| if (env.trace) { ------------------ | Branch (68:6): [True: 0, False: 2.31k] ------------------ 69| 0| if (beglin) { ------------------ | Branch (69:7): [True: 0, False: 0] ------------------ 70| 0| fprintf (stderr, "%d\t", num_rules + 1); 71| 0| beglin = 0; 72| 0| } 73| | 74| 0| switch (toktype) { 75| 0| case '<': ------------------ | Branch (75:3): [True: 0, False: 0] ------------------ 76| 0| case '>': ------------------ | Branch (76:3): [True: 0, False: 0] ------------------ 77| 0| case '^': ------------------ | Branch (77:3): [True: 0, False: 0] ------------------ 78| 0| case '$': ------------------ | Branch (78:3): [True: 0, False: 0] ------------------ 79| 0| case '"': ------------------ | Branch (79:3): [True: 0, False: 0] ------------------ 80| 0| case '[': ------------------ | Branch (80:3): [True: 0, False: 0] ------------------ 81| 0| case ']': ------------------ | Branch (81:3): [True: 0, False: 0] ------------------ 82| 0| case '{': ------------------ | Branch (82:3): [True: 0, False: 0] ------------------ 83| 0| case '}': ------------------ | Branch (83:3): [True: 0, False: 0] ------------------ 84| 0| case '|': ------------------ | Branch (84:3): [True: 0, False: 0] ------------------ 85| 0| case '(': ------------------ | Branch (85:3): [True: 0, False: 0] ------------------ 86| 0| case ')': ------------------ | Branch (86:3): [True: 0, False: 0] ------------------ 87| 0| case '-': ------------------ | Branch (87:3): [True: 0, False: 0] ------------------ 88| 0| case '/': ------------------ | Branch (88:3): [True: 0, False: 0] ------------------ 89| 0| case '\\': ------------------ | Branch (89:3): [True: 0, False: 0] ------------------ 90| 0| case '?': ------------------ | Branch (90:3): [True: 0, False: 0] ------------------ 91| 0| case '.': ------------------ | Branch (91:3): [True: 0, False: 0] ------------------ 92| 0| case '*': ------------------ | Branch (92:3): [True: 0, False: 0] ------------------ 93| 0| case '+': ------------------ | Branch (93:3): [True: 0, False: 0] ------------------ 94| 0| case ',': ------------------ | Branch (94:3): [True: 0, False: 0] ------------------ 95| 0| (void) putc (toktype, stderr); 96| 0| break; 97| | 98| 0| case '\n': ------------------ | Branch (98:3): [True: 0, False: 0] ------------------ 99| 0| (void) putc ('\n', stderr); 100| | 101| 0| if (sectnum == 2) ------------------ | Branch (101:8): [True: 0, False: 0] ------------------ 102| 0| beglin = 1; 103| | 104| 0| break; 105| | 106| 0| case SCDECL: ------------------ | | 112| 0|#define SCDECL 261 ------------------ | Branch (106:3): [True: 0, False: 0] ------------------ 107| 0| fputs ("%s", stderr); 108| 0| break; 109| | 110| 0| case XSCDECL: ------------------ | | 113| 0|#define XSCDECL 262 ------------------ | Branch (110:3): [True: 0, False: 0] ------------------ 111| 0| fputs ("%x", stderr); 112| 0| break; 113| | 114| 0| case SECTEND: ------------------ | | 111| 0|#define SECTEND 260 ------------------ | Branch (114:3): [True: 0, False: 0] ------------------ 115| 0| fputs ("%%\n", stderr); 116| | 117| | /* We set beglin to be true so we'll start 118| | * writing out numbers as we echo rules. 119| | * flexscan() has already assigned sectnum. 120| | */ 121| 0| if (sectnum == 2) ------------------ | Branch (121:8): [True: 0, False: 0] ------------------ 122| 0| beglin = 1; 123| | 124| 0| break; 125| | 126| 0| case NAME: ------------------ | | 114| 0|#define NAME 263 ------------------ | Branch (126:3): [True: 0, False: 0] ------------------ 127| 0| fprintf (stderr, "'%s'", nmstr); 128| 0| break; 129| | 130| 0| case CHAR: ------------------ | | 109| 0|#define CHAR 258 ------------------ | Branch (130:3): [True: 0, False: 0] ------------------ 131| 0| switch (yylval) { 132| 0| case '<': ------------------ | Branch (132:4): [True: 0, False: 0] ------------------ 133| 0| case '>': ------------------ | Branch (133:4): [True: 0, False: 0] ------------------ 134| 0| case '^': ------------------ | Branch (134:4): [True: 0, False: 0] ------------------ 135| 0| case '$': ------------------ | Branch (135:4): [True: 0, False: 0] ------------------ 136| 0| case '"': ------------------ | Branch (136:4): [True: 0, False: 0] ------------------ 137| 0| case '[': ------------------ | Branch (137:4): [True: 0, False: 0] ------------------ 138| 0| case ']': ------------------ | Branch (138:4): [True: 0, False: 0] ------------------ 139| 0| case '{': ------------------ | Branch (139:4): [True: 0, False: 0] ------------------ 140| 0| case '}': ------------------ | Branch (140:4): [True: 0, False: 0] ------------------ 141| 0| case '|': ------------------ | Branch (141:4): [True: 0, False: 0] ------------------ 142| 0| case '(': ------------------ | Branch (142:4): [True: 0, False: 0] ------------------ 143| 0| case ')': ------------------ | Branch (143:4): [True: 0, False: 0] ------------------ 144| 0| case '-': ------------------ | Branch (144:4): [True: 0, False: 0] ------------------ 145| 0| case '/': ------------------ | Branch (145:4): [True: 0, False: 0] ------------------ 146| 0| case '\\': ------------------ | Branch (146:4): [True: 0, False: 0] ------------------ 147| 0| case '?': ------------------ | Branch (147:4): [True: 0, False: 0] ------------------ 148| 0| case '.': ------------------ | Branch (148:4): [True: 0, False: 0] ------------------ 149| 0| case '*': ------------------ | Branch (149:4): [True: 0, False: 0] ------------------ 150| 0| case '+': ------------------ | Branch (150:4): [True: 0, False: 0] ------------------ 151| 0| case ',': ------------------ | Branch (151:4): [True: 0, False: 0] ------------------ 152| 0| fprintf (stderr, "\\%c", yylval); 153| 0| break; 154| | 155| 0| default: ------------------ | Branch (155:4): [True: 0, False: 0] ------------------ 156| 0| if (!isascii (yylval) || !isprint (yylval)) { ------------------ | Branch (156:9): [True: 0, False: 0] | Branch (156:30): [True: 0, False: 0] ------------------ 157| 0| if(env.trace_hex) ------------------ | Branch (157:9): [True: 0, False: 0] ------------------ 158| 0| fprintf (stderr, "\\x%02x", (unsigned int) yylval); 159| 0| else 160| 0| fprintf (stderr, "\\%.3o", (unsigned int) yylval); 161| 0| } else 162| 0| (void) putc (yylval, stderr); 163| 0| break; 164| 0| } 165| | 166| 0| break; 167| | 168| 0| case NUMBER: ------------------ | | 110| 0|#define NUMBER 259 ------------------ | Branch (168:3): [True: 0, False: 0] ------------------ 169| 0| fprintf (stderr, "%d", yylval); 170| 0| break; 171| | 172| 0| case PREVCCL: ------------------ | | 115| 0|#define PREVCCL 264 ------------------ | Branch (172:3): [True: 0, False: 0] ------------------ 173| 0| fprintf (stderr, "[%d]", yylval); 174| 0| break; 175| | 176| 0| case EOF_OP: ------------------ | | 116| 0|#define EOF_OP 265 ------------------ | Branch (176:3): [True: 0, False: 0] ------------------ 177| 0| fprintf (stderr, "<>"); 178| 0| break; 179| | 180| 0| case TOK_OPTION: ------------------ | | 117| 0|#define TOK_OPTION 266 ------------------ | Branch (180:3): [True: 0, False: 0] ------------------ 181| 0| fprintf (stderr, "%s ", yytext); 182| 0| break; 183| | 184| 0| case TOK_OUTFILE: ------------------ | | 118| 0|#define TOK_OUTFILE 267 ------------------ | Branch (184:3): [True: 0, False: 0] ------------------ 185| 0| case TOK_PREFIX: ------------------ | | 119| 0|#define TOK_PREFIX 268 ------------------ | Branch (185:3): [True: 0, False: 0] ------------------ 186| 0| case CCE_ALNUM: ------------------ | | 133| 0|#define CCE_ALNUM 282 ------------------ | Branch (186:3): [True: 0, False: 0] ------------------ 187| 0| case CCE_ALPHA: ------------------ | | 134| 0|#define CCE_ALPHA 283 ------------------ | Branch (187:3): [True: 0, False: 0] ------------------ 188| 0| case CCE_BLANK: ------------------ | | 135| 0|#define CCE_BLANK 284 ------------------ | Branch (188:3): [True: 0, False: 0] ------------------ 189| 0| case CCE_CNTRL: ------------------ | | 136| 0|#define CCE_CNTRL 285 ------------------ | Branch (189:3): [True: 0, False: 0] ------------------ 190| 0| case CCE_DIGIT: ------------------ | | 137| 0|#define CCE_DIGIT 286 ------------------ | Branch (190:3): [True: 0, False: 0] ------------------ 191| 0| case CCE_GRAPH: ------------------ | | 138| 0|#define CCE_GRAPH 287 ------------------ | Branch (191:3): [True: 0, False: 0] ------------------ 192| 0| case CCE_LOWER: ------------------ | | 139| 0|#define CCE_LOWER 288 ------------------ | Branch (192:3): [True: 0, False: 0] ------------------ 193| 0| case CCE_PRINT: ------------------ | | 140| 0|#define CCE_PRINT 289 ------------------ | Branch (193:3): [True: 0, False: 0] ------------------ 194| 0| case CCE_PUNCT: ------------------ | | 141| 0|#define CCE_PUNCT 290 ------------------ | Branch (194:3): [True: 0, False: 0] ------------------ 195| 0| case CCE_SPACE: ------------------ | | 142| 0|#define CCE_SPACE 291 ------------------ | Branch (195:3): [True: 0, False: 0] ------------------ 196| 0| case CCE_UPPER: ------------------ | | 143| 0|#define CCE_UPPER 292 ------------------ | Branch (196:3): [True: 0, False: 0] ------------------ 197| 0| case CCE_XDIGIT: ------------------ | | 144| 0|#define CCE_XDIGIT 293 ------------------ | Branch (197:3): [True: 0, False: 0] ------------------ 198| 0| fprintf (stderr, "%s", yytext); 199| 0| break; 200| | 201| 0| case 0: ------------------ | Branch (201:3): [True: 0, False: 0] ------------------ 202| 0| fprintf (stderr, _("End Marker\n")); ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 203| 0| break; 204| | 205| 0| default: ------------------ | Branch (205:3): [True: 0, False: 0] ------------------ 206| 0| fprintf (stderr, 207| 0| _ ------------------ | | 100| 0|#define _(String) gettext (String) ------------------ 208| 0| ("*Something Weird* - tok: %d val: %d\n"), 209| 0| toktype, yylval); 210| 0| break; 211| 0| } 212| 0| } 213| | 214| 2.31k| return toktype; 215| 2.31k|} LLVMFuzzerTestOneInput: 23| 778|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 24| 778| char filename[256]; 25| 778| sprintf(filename, "/tmp/libfuzzer.%d", getpid()); 26| | 27| 778| FILE *fp = fopen(filename, "wb"); 28| 778| if (!fp) { ------------------ | Branch (28:7): [True: 0, False: 778] ------------------ 29| 0| return 0; 30| 0| } 31| 778| fwrite(data, size, 1, fp); 32| 778| fclose(fp); 33| | 34| 778| my_argv[0] = "/tmp/fakefuzzer"; 35| 778| my_argv[1] = filename; 36| 778| my_argv[2] = NULL; 37| | 38| 778| flex_main(2, my_argv); 39| | 40| 778| unlink(filename); 41| 778| return 0; 42| 778|}