buf_init: 87| 1.26k|{ 88| 1.26k| buf->elts = NULL; 89| 1.26k| buf->nelts = 0; 90| 1.26k| buf->elt_size = elem_size; 91| 1.26k| buf->nmax = 0; 92| 1.26k|} cclinit: 194| 632|{ 195| 632| if (++lastccl >= current_maxccls) { ------------------ | Branch (195:6): [True: 0, False: 632] ------------------ 196| 0| current_maxccls += MAX_CCLS_INCREMENT; ------------------ | | 185| 0|#define MAX_CCLS_INCREMENT 100 ------------------ 197| | 198| 0| ++num_reallocs; 199| | 200| 0| cclmap = 201| 0| reallocate_integer_array (cclmap, current_maxccls); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 202| 0| ccllen = 203| 0| reallocate_integer_array (ccllen, current_maxccls); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 204| 0| cclng = reallocate_integer_array (cclng, current_maxccls); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 205| 0| ccl_has_nl = 206| 0| reallocate_bool_array (ccl_has_nl, ------------------ | | 713| 0| reallocate_array((void *) array, size, sizeof(bool)) ------------------ 207| 0| current_maxccls); 208| 0| } 209| | 210| 632| if (lastccl == 1) ------------------ | Branch (210:6): [True: 632, False: 0] ------------------ 211| | /* we're making the first ccl */ 212| 632| 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| 632| ccllen[lastccl] = 0; 224| 632| cclng[lastccl] = 0; /* ccl's start out life un-negated */ 225| 632| ccl_has_nl[lastccl] = false; 226| | 227| 632| return lastccl; 228| 632|} cclnegate: 234| 632|{ 235| 632| cclng[cclp] = 1; 236| 632| ccl_has_nl[cclp] = !ccl_has_nl[cclp]; 237| 632|} flex_main: 130| 632|{ 131| 632| int i, exit_status, child_status; 132| 632| int did_eof_rule = false; 133| | 134| | /* Set a longjmp target. Yes, I know it's a hack, but it gets worse: The 135| | * return value of setjmp, if non-zero, is the desired exit code PLUS ONE. 136| | * For example, if you want 'main' to return with code '2', then call 137| | * longjmp() with an argument of 3. This is because it is invalid to 138| | * specify a value of 0 to longjmp. FLEX_EXIT(n) should be used instead of 139| | * exit(n); 140| | */ 141| 632| exit_status = setjmp (flex_main_jmp_buf); 142| 632| if (exit_status){ ------------------ | Branch (142:6): [True: 632, False: 0] ------------------ 143| 632| if (stdout && !_stdout_closed && !ferror(stdout)){ ------------------ | Branch (143:17): [True: 0, False: 632] | Branch (143:36): [True: 0, False: 0] ------------------ 144| 0| fflush(stdout); 145| 0| fclose(stdout); 146| 0| } 147| 632| return 0; 148| | /* 149| | while (wait(&child_status) > 0){ 150| | if (!WIFEXITED (child_status) 151| | || WEXITSTATUS (child_status) != 0){ 152| | if( exit_status <= 1 ) 153| | exit_status = 2; 154| | 155| | } 156| | } 157| | return exit_status - 1; 158| | */ 159| 632| } 160| | 161| 0| flexinit (argc, argv); 162| | 163| 0| readin (); 164| | 165| 0| skelout (true); /* %% [1.0] DFA */ 166| 0| footprint += ntod (); 167| | 168| 0| for (i = 1; i <= num_rules; ++i) ------------------ | Branch (168:14): [True: 0, False: 0] ------------------ 169| 0| if (!rule_useful[i] && i != default_rule) ------------------ | Branch (169:7): [True: 0, False: 0] | Branch (169:26): [True: 0, False: 0] ------------------ 170| 0| line_warning (_("rule cannot be matched"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 171| 0| rule_linenum[i]); 172| | 173| 0| if (ctrl.spprdflt && !reject && rule_useful[default_rule]) ------------------ | Branch (173:6): [True: 0, False: 0] | Branch (173:23): [True: 0, False: 0] | Branch (173:34): [True: 0, False: 0] ------------------ 174| 0| line_warning (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 175| 0| ("-s option given but default rule can be matched"), 176| 0| rule_linenum[default_rule]); 177| | 178| 0| comment("START of m4 controls\n"); 179| | 180| | // mode switches for yy_trans_info specification 181| | // nultrans 182| 0| if (nultrans) ------------------ | Branch (182:6): [True: 0, False: 0] ------------------ 183| 0| visible_define ( "M4_MODE_NULTRANS"); 184| 0| else { 185| 0| visible_define ( "M4_MODE_NO_NULTRANS"); 186| 0| if (ctrl.fulltbl) ------------------ | Branch (186:7): [True: 0, False: 0] ------------------ 187| 0| visible_define ( "M4_MODE_NULTRANS_FULLTBL"); 188| 0| else 189| 0| visible_define ( "M4_MODE_NO_NULTRANS_FULLTBL"); 190| 0| if (ctrl.fullspd) ------------------ | Branch (190:7): [True: 0, False: 0] ------------------ 191| 0| visible_define ( "M4_MODE_NULTRANS_FULLSPD"); 192| 0| else 193| 0| visible_define ( "M4_MODE_NO_NULTRANS_FULLSPD"); 194| 0| } 195| | 196| 0| comment("END of m4 controls\n"); 197| 0| out ("\n"); 198| | 199| 0| comment("START of Flex-generated definitions\n"); 200| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_UINT(%s, %d)", "YY_NUM_RULES", num_rules); 201| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_END_OF_BUFFER", num_rules + 1); 202| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMBASE", jambase); 203| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMSTATE", jamstate); 204| 0| out_str_dec ("M4_HOOK_CONST_DEFINE_BYTE(%s, %d)", "YY_NUL_EC", NUL_ec); 205| | /* Need to define the transet type as a size large 206| | * enough to hold the biggest offset. 207| | */ 208| 0| out_str ("M4_HOOK_SET_OFFSET_TYPE(%s)", optimize_pack(tblend + numecs + 1)->name); 209| 0| comment("END of Flex-generated definitions\n"); 210| | 211| 0| skelout (true); /* %% [2.0] - tables get dumped here */ 212| | 213| | /* Generate the C state transition tables from the DFA. */ 214| 0| make_tables (); 215| | 216| 0| skelout (true); /* %% [3.0] - mode-dependent static declarations get dumped here */ 217| | 218| 0| out (&action_array[defs1_offset]); 219| | 220| 0| line_directive_out (stdout, NULL, linenum); 221| | 222| 0| skelout (true); /* %% [4.0] - various random yylex internals get dumped here */ 223| | 224| | /* Copy prolog to output file. */ 225| 0| out (&action_array[prolog_offset]); 226| | 227| 0| line_directive_out (stdout, NULL, linenum); 228| | 229| 0| skelout (true); /* %% [5.0] - main loop of matching-engine code gets dumped here */ 230| | 231| | /* Copy actions to output file. */ 232| 0| out (&action_array[action_offset]); 233| | 234| 0| line_directive_out (stdout, NULL, linenum); 235| | 236| | /* generate cases for any missing EOF rules */ 237| 0| for (i = 1; i <= lastsc; ++i) ------------------ | Branch (237:14): [True: 0, False: 0] ------------------ 238| 0| if (!sceof[i]) { ------------------ | Branch (238:7): [True: 0, False: 0] ------------------ 239| 0| out_str ("M4_HOOK_EOF_STATE_CASE_ARM(%s)", scname[i]); 240| 0| outc('\n'); 241| 0| out ("M4_HOOK_EOF_STATE_CASE_FALLTHROUGH"); 242| 0| outc('\n'); 243| 0| did_eof_rule = true; 244| 0| } 245| | 246| 0| if (did_eof_rule) { ------------------ | Branch (246:6): [True: 0, False: 0] ------------------ 247| 0| out ("M4_HOOK_EOF_STATE_CASE_TERMINATE"); 248| 0| } 249| | 250| 0| skelout (true); 251| | 252| | /* Copy remainder of input to output. */ 253| | 254| 0| line_directive_out (stdout, infilename, linenum); 255| | 256| 0| if (sectnum == 3) { ------------------ | Branch (256:6): [True: 0, False: 0] ------------------ 257| 0| OUT_BEGIN_CODE (); ------------------ | | 1121| 0|#define OUT_BEGIN_CODE() outn("m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl") ------------------ 258| 0| if (!ctrl.no_section3_escape) ------------------ | Branch (258:21): [True: 0, False: 0] ------------------ 259| 0| fputs("[[", stdout); 260| 0| (void) flexscan (); /* copy remainder of input to output */ 261| 0| if (!ctrl.no_section3_escape) ------------------ | Branch (261:21): [True: 0, False: 0] ------------------ 262| 0| fputs("]]", stdout); 263| 0| OUT_END_CODE (); ------------------ | | 1122| 0|#define OUT_END_CODE() outn("]])") ------------------ 264| 0| } 265| | 266| | /* Note, flexend does not return. It exits with its argument 267| | * as status. 268| | */ 269| 0| flexend (0); 270| | 271| 0| return 0; /* keep compilers/lint happy */ 272| 632|} check_options: 313| 632|{ 314| 632| int i; 315| | 316| 632| if (ctrl.lex_compat) { ------------------ | Branch (316:6): [True: 0, False: 632] ------------------ 317| 0| if (ctrl.C_plus_plus) ------------------ | Branch (317:7): [True: 0, False: 0] ------------------ 318| 0| flexerror (_("Can't use -+ with -l option")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 319| | 320| 0| if (ctrl.fulltbl || ctrl.fullspd) ------------------ | Branch (320:7): [True: 0, False: 0] | Branch (320:23): [True: 0, False: 0] ------------------ 321| 0| flexerror (_("Can't use -f or -F with -l option")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 322| | 323| 0| if (ctrl.reentrant || ctrl.bison_bridge_lval) ------------------ | Branch (323:7): [True: 0, False: 0] | Branch (323:25): [True: 0, False: 0] ------------------ 324| 0| flexerror (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 325| 0| ("Can't use --ctrl.reentrant or --bison-bridge with -l option")); 326| | 327| 0| ctrl.yytext_is_array = true; 328| 0| ctrl.do_yylineno = true; 329| 0| ctrl.use_read = false; 330| 0| } 331| | 332| | 333| |#if 0 334| | /* This makes no sense whatsoever. I'm removing it. */ 335| | if (ctrl.do_yylineno) 336| | /* This should really be "maintain_backup_tables = true" */ 337| | ctrl.reject_really_used = true; 338| |#endif 339| | 340| 632| if (ctrl.csize == trit_unspecified) { ------------------ | Branch (340:6): [True: 632, False: 0] ------------------ 341| 632| if ((ctrl.fulltbl || ctrl.fullspd) && !ctrl.useecs) ------------------ | Branch (341:8): [True: 0, False: 632] | Branch (341:24): [True: 0, False: 632] | Branch (341:41): [True: 0, False: 0] ------------------ 342| 0| ctrl.csize = DEFAULT_CSIZE; ------------------ | | 95| 0|#define DEFAULT_CSIZE 128 ------------------ 343| 632| else 344| 632| ctrl.csize = CSIZE; ------------------ | | 91| 632|#define CSIZE 256 ------------------ 345| 632| } 346| | 347| 632| if (ctrl.interactive == trit_unspecified) { ------------------ | Branch (347:6): [True: 632, False: 0] ------------------ 348| 632| if (ctrl.fulltbl || ctrl.fullspd) ------------------ | Branch (348:7): [True: 0, False: 632] | Branch (348:23): [True: 0, False: 632] ------------------ 349| 0| ctrl.interactive = trit_false; 350| 632| else 351| 632| ctrl.interactive = trit_true; 352| 632| } 353| | 354| 632| if (ctrl.fulltbl || ctrl.fullspd) { ------------------ | Branch (354:6): [True: 0, False: 632] | Branch (354:22): [True: 0, False: 632] ------------------ 355| 0| if (ctrl.usemecs) ------------------ | Branch (355:7): [True: 0, False: 0] ------------------ 356| 0| flexerror (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 357| 0| ("-Cf/-CF and -Cm don't make sense together")); 358| | 359| 0| if (ctrl.interactive != trit_false) ------------------ | Branch (359:7): [True: 0, False: 0] ------------------ 360| 0| flexerror (_("-Cf/-CF and -I are incompatible")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 361| | 362| 0| if (ctrl.lex_compat) ------------------ | Branch (362:7): [True: 0, False: 0] ------------------ 363| 0| flexerror (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 364| 0| ("-Cf/-CF are incompatible with lex-compatibility mode")); 365| | 366| | 367| 0| if (ctrl.fulltbl && ctrl.fullspd) ------------------ | Branch (367:7): [True: 0, False: 0] | Branch (367:23): [True: 0, False: 0] ------------------ 368| 0| flexerror (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 369| 0| ("-Cf and -CF are mutually exclusive")); 370| 0| } 371| | 372| 632| if (ctrl.C_plus_plus && ctrl.fullspd) ------------------ | Branch (372:6): [True: 0, False: 632] | Branch (372:26): [True: 0, False: 0] ------------------ 373| 0| flexerror (_("Can't use -+ with -CF option")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 374| | 375| 632| if (ctrl.C_plus_plus && ctrl.yytext_is_array) { ------------------ | Branch (375:6): [True: 0, False: 632] | Branch (375:26): [True: 0, False: 0] ------------------ 376| 0| lwarn (_("%array incompatible with -+ option")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 377| 0| ctrl.yytext_is_array = false; 378| 0| } 379| | 380| 632| if (ctrl.C_plus_plus && (ctrl.reentrant)) ------------------ | Branch (380:6): [True: 0, False: 632] | Branch (380:26): [True: 0, False: 0] ------------------ 381| 0| flexerror (_("Options -+ and --reentrant are mutually exclusive.")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 382| | 383| 632| if (ctrl.C_plus_plus && ctrl.bison_bridge_lval) ------------------ | Branch (383:6): [True: 0, False: 632] | Branch (383:26): [True: 0, False: 0] ------------------ 384| 0| flexerror (_("bison bridge not supported for the C++ scanner.")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 385| | 386| | 387| 632| if (ctrl.useecs) { /* Set up doubly-linked equivalence classes. */ ------------------ | Branch (387:6): [True: 632, False: 0] ------------------ 388| | 389| | /* We loop all the way up to ctrl.csize, since ecgroup[ctrl.csize] is 390| | * the position used for NUL characters. 391| | */ 392| 632| ecgroup[1] = NIL; ------------------ | | 177| 632|#define NIL 0 ------------------ 393| | 394| 161k| for (i = 2; i <= ctrl.csize; ++i) { ------------------ | Branch (394:15): [True: 161k, False: 632] ------------------ 395| 161k| ecgroup[i] = i - 1; 396| 161k| nextecm[i - 1] = i; 397| 161k| } 398| | 399| 632| nextecm[ctrl.csize] = NIL; ------------------ | | 177| 632|#define NIL 0 ------------------ 400| 632| } 401| | 402| 0| else { 403| | /* Put everything in its own equivalence class. */ 404| 0| for (i = 1; i <= ctrl.csize; ++i) { ------------------ | Branch (404:15): [True: 0, False: 0] ------------------ 405| 0| ecgroup[i] = i; 406| 0| nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */ ------------------ | | 295| 0|#define BAD_SUBSCRIPT -32767 ------------------ 407| 0| } 408| 0| } 409| | 410| 632| if (!env.use_stdout) { ------------------ | Branch (410:6): [True: 632, False: 0] ------------------ 411| 632| FILE *prev_stdout; 412| | 413| 632| if (!env.did_outfilename) { ------------------ | Branch (413:7): [True: 632, False: 0] ------------------ 414| 632| snprintf (outfile_path, sizeof(outfile_path), outfile_template, 415| 632| ctrl.prefix, suffix()); 416| | 417| 632| env.outfilename = outfile_path; 418| 632| } 419| | 420| 632| prev_stdout = freopen (env.outfilename, "w+", stdout); 421| | 422| 632| if (prev_stdout == NULL) ------------------ | Branch (422:7): [True: 0, False: 632] ------------------ 423| 0| lerr (_("could not create %s"), env.outfilename); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 424| | 425| 632| outfile_created = 1; 426| 632| } 427| 632|} flexend: 436| 632|{ 437| 632| static int called_before = -1; /* prevent infinite recursion. */ 438| 632| int tblsiz; 439| | 440| 632| if (++called_before) ------------------ | Branch (440:6): [True: 631, False: 1] ------------------ 441| 631| FLEX_EXIT (exit_status); ------------------ | | 1127| 631|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 442| | 443| 1| if (ctrl.yyclass != NULL && !ctrl.C_plus_plus) ------------------ | Branch (443:6): [True: 0, False: 1] | Branch (443:30): [True: 0, False: 0] ------------------ 444| 0| flexerror (_("%option yyclass only meaningful for C++ scanners")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 445| | 446| 1| if (skelfile != NULL) { ------------------ | Branch (446:6): [True: 0, False: 1] ------------------ 447| 0| if (ferror (skelfile)) ------------------ | Branch (447:7): [True: 0, False: 0] ------------------ 448| 0| lerr (_("input error reading skeleton file %s"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 449| 0| env.skelname); 450| | 451| 0| else if (fclose (skelfile)) ------------------ | Branch (451:12): [True: 0, False: 0] ------------------ 452| 0| lerr (_("error closing skeleton file %s"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 453| 0| env.skelname); 454| 0| } 455| | 456| 1| if (exit_status != 0 && outfile_created) { ------------------ | Branch (456:6): [True: 1, False: 0] | Branch (456:26): [True: 1, False: 0] ------------------ 457| 1| if (ferror (stdout)) ------------------ | Branch (457:7): [True: 0, False: 1] ------------------ 458| 0| lerr (_("error writing output file %s"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 459| 0| env.outfilename); 460| | 461| 1| else if ((_stdout_closed = 1) && fclose (stdout)) ------------------ | Branch (461:12): [True: 1, False: 0] | Branch (461:36): [True: 0, False: 1] ------------------ 462| 0| lerr (_("error closing output file %s"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 463| 0| env.outfilename); 464| | 465| 1| else if (unlink (env.outfilename)) ------------------ | Branch (465:12): [True: 0, False: 1] ------------------ 466| 0| lerr (_("error deleting output file %s"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 467| 0| env.outfilename); 468| 1| } 469| | 470| | 471| 1| if (env.backing_up_report && ctrl.backing_up_file) { ------------------ | Branch (471:6): [True: 0, False: 1] | Branch (471:31): [True: 0, False: 0] ------------------ 472| 0| if (num_backing_up == 0) ------------------ | Branch (472:7): [True: 0, False: 0] ------------------ 473| 0| fprintf (ctrl.backing_up_file, _("No backing up.\n")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 474| 0| else if (ctrl.fullspd || ctrl.fulltbl) ------------------ | Branch (474:12): [True: 0, False: 0] | Branch (474:28): [True: 0, False: 0] ------------------ 475| 0| fprintf (ctrl.backing_up_file, 476| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 477| 0| ("%d backing up (non-accepting) states.\n"), 478| 0| num_backing_up); 479| 0| else 480| 0| fprintf (ctrl.backing_up_file, 481| 0| _("Compressed tables always back up.\n")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 482| | 483| 0| if (ferror (ctrl.backing_up_file)) ------------------ | Branch (483:7): [True: 0, False: 0] ------------------ 484| 0| lerr (_("error writing backup file %s"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 485| 0| backing_name); 486| | 487| 0| else if (fclose (ctrl.backing_up_file)) ------------------ | Branch (487:12): [True: 0, False: 0] ------------------ 488| 0| lerr (_("error closing backup file %s"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 489| 0| backing_name); 490| 0| } 491| | 492| 1| if (env.printstats) { ------------------ | Branch (492:6): [True: 0, False: 1] ------------------ 493| 0| fprintf (stderr, _("%s version %s usage statistics:\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 494| 0| program_name, flex_version); 495| | 496| 0| fprintf (stderr, _(" scanner options: -")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 497| | 498| 0| if (ctrl.C_plus_plus) ------------------ | Branch (498:7): [True: 0, False: 0] ------------------ 499| 0| putc ('+', stderr); 500| 0| if (env.backing_up_report) ------------------ | Branch (500:7): [True: 0, False: 0] ------------------ 501| 0| putc ('b', stderr); 502| 0| if (ctrl.ddebug) ------------------ | Branch (502:7): [True: 0, False: 0] ------------------ 503| 0| putc ('d', stderr); 504| 0| if (sf_case_ins()) ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ 505| 0| putc ('i', stderr); 506| 0| if (ctrl.lex_compat) ------------------ | Branch (506:7): [True: 0, False: 0] ------------------ 507| 0| putc ('l', stderr); 508| 0| if (ctrl.posix_compat) ------------------ | Branch (508:7): [True: 0, False: 0] ------------------ 509| 0| putc ('X', stderr); 510| 0| if (env.performance_hint > 0) ------------------ | Branch (510:7): [True: 0, False: 0] ------------------ 511| 0| putc ('p', stderr); 512| 0| if (env.performance_hint > 1) ------------------ | Branch (512:7): [True: 0, False: 0] ------------------ 513| 0| putc ('p', stderr); 514| 0| if (ctrl.spprdflt) ------------------ | Branch (514:7): [True: 0, False: 0] ------------------ 515| 0| putc ('s', stderr); 516| 0| if (ctrl.reentrant) ------------------ | Branch (516:7): [True: 0, False: 0] ------------------ 517| 0| fputs ("--reentrant", stderr); 518| 0| if (ctrl.bison_bridge_lval) ------------------ | Branch (518:13): [True: 0, False: 0] ------------------ 519| 0| fputs ("--bison-bridge", stderr); 520| 0| if (ctrl.bison_bridge_lloc) ------------------ | Branch (520:13): [True: 0, False: 0] ------------------ 521| 0| fputs ("--bison-locations", stderr); 522| 0| if (env.use_stdout) ------------------ | Branch (522:7): [True: 0, False: 0] ------------------ 523| 0| putc ('t', stderr); 524| 0| if (env.printstats) ------------------ | Branch (524:7): [True: 0, False: 0] ------------------ 525| 0| putc ('v', stderr); /* always true! */ 526| 0| if (env.nowarn) ------------------ | Branch (526:7): [True: 0, False: 0] ------------------ 527| 0| putc ('w', stderr); 528| 0| if (ctrl.interactive == trit_false) ------------------ | Branch (528:7): [True: 0, False: 0] ------------------ 529| 0| putc ('B', stderr); 530| 0| if (ctrl.interactive == trit_true) ------------------ | Branch (530:7): [True: 0, False: 0] ------------------ 531| 0| putc ('I', stderr); 532| 0| if (!ctrl.gen_line_dirs) ------------------ | Branch (532:7): [True: 0, False: 0] ------------------ 533| 0| putc ('L', stderr); 534| 0| if (env.trace) ------------------ | Branch (534:7): [True: 0, False: 0] ------------------ 535| 0| putc ('T', stderr); 536| | 537| 0| if (ctrl.csize == trit_unspecified) ------------------ | Branch (537:7): [True: 0, False: 0] ------------------ 538| | /* We encountered an error fairly early on, so ctrl.csize 539| | * never got specified. Define it now, to prevent 540| | * bogus table sizes being written out below. 541| | */ 542| 0| ctrl.csize = 256; 543| | 544| 0| if (ctrl.csize == 128) ------------------ | Branch (544:7): [True: 0, False: 0] ------------------ 545| 0| putc ('7', stderr); 546| 0| else 547| 0| putc ('8', stderr); 548| | 549| 0| fprintf (stderr, " -C"); 550| | 551| 0| if (ctrl.long_align) ------------------ | Branch (551:7): [True: 0, False: 0] ------------------ 552| 0| putc ('a', stderr); 553| 0| if (ctrl.fulltbl) ------------------ | Branch (553:7): [True: 0, False: 0] ------------------ 554| 0| putc ('f', stderr); 555| 0| if (ctrl.fullspd) ------------------ | Branch (555:7): [True: 0, False: 0] ------------------ 556| 0| putc ('F', stderr); 557| 0| if (ctrl.useecs) ------------------ | Branch (557:7): [True: 0, False: 0] ------------------ 558| 0| putc ('e', stderr); 559| 0| if (ctrl.usemecs) ------------------ | Branch (559:7): [True: 0, False: 0] ------------------ 560| 0| putc ('m', stderr); 561| 0| if (ctrl.use_read) ------------------ | Branch (561:7): [True: 0, False: 0] ------------------ 562| 0| putc ('r', stderr); 563| | 564| 0| if (env.did_outfilename) ------------------ | Branch (564:7): [True: 0, False: 0] ------------------ 565| 0| fprintf (stderr, " -o%s", env.outfilename); 566| | 567| 0| if (env.skelname != NULL) ------------------ | Branch (567:7): [True: 0, False: 0] ------------------ 568| 0| fprintf (stderr, " -S%s", env.skelname); 569| | 570| 0| if (strcmp (ctrl.prefix, "yy")) ------------------ | Branch (570:7): [True: 0, False: 0] ------------------ 571| 0| fprintf (stderr, " -P%s", ctrl.prefix); 572| | 573| 0| putc ('\n', stderr); 574| | 575| 0| fprintf (stderr, _(" %d/%d NFA states\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 576| 0| lastnfa, current_mns); 577| 0| fprintf (stderr, _(" %d/%d DFA states (%d words)\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 578| 0| lastdfa, current_max_dfas, totnst); 579| 0| fprintf (stderr, _(" %d rules\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 580| 0| num_rules + num_eof_rules - 581| 0| 1 /* - 1 for def. rule */ ); 582| | 583| 0| if (num_backing_up == 0) ------------------ | Branch (583:7): [True: 0, False: 0] ------------------ 584| 0| fprintf (stderr, _(" No backing up\n")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 585| 0| else if (ctrl.fullspd || ctrl.fulltbl) ------------------ | Branch (585:12): [True: 0, False: 0] | Branch (585:28): [True: 0, False: 0] ------------------ 586| 0| fprintf (stderr, 587| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 588| 0| (" %d backing-up (non-accepting) states\n"), 589| 0| num_backing_up); 590| 0| else 591| 0| fprintf (stderr, 592| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 593| 0| (" Compressed tables always back-up\n")); 594| | 595| 0| if (bol_needed) ------------------ | Branch (595:7): [True: 0, False: 0] ------------------ 596| 0| fprintf (stderr, 597| 0| _(" Beginning-of-line patterns used\n")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 598| | 599| 0| fprintf (stderr, _(" %d/%d start conditions\n"), lastsc, ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 600| 0| current_max_scs); 601| 0| fprintf (stderr, 602| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 603| 0| (" %d epsilon states, %d double epsilon states\n"), 604| 0| numeps, eps2); 605| | 606| 0| if (lastccl == 0) ------------------ | Branch (606:7): [True: 0, False: 0] ------------------ 607| 0| fprintf (stderr, _(" no character classes\n")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 608| 0| else 609| 0| fprintf (stderr, 610| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 611| 0| (" %d/%d character classes needed %d/%d words of storage, %d reused\n"), 612| 0| lastccl, current_maxccls, 613| 0| cclmap[lastccl] + ccllen[lastccl], 614| 0| current_max_ccl_tbl_size, cclreuse); 615| | 616| 0| fprintf (stderr, _(" %d state/nextstate pairs created\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 617| 0| numsnpairs); 618| 0| fprintf (stderr, 619| 0| _(" %d/%d unique/duplicate transitions\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 620| 0| numuniq, numdup); 621| | 622| 0| if (ctrl.fulltbl) { ------------------ | Branch (622:7): [True: 0, False: 0] ------------------ 623| 0| tblsiz = lastdfa * numecs; 624| 0| fprintf (stderr, _(" %d table entries\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 625| 0| tblsiz); 626| 0| } 627| | 628| 0| else { 629| 0| tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend; 630| | 631| 0| fprintf (stderr, 632| 0| _(" %d/%d base-def entries created\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 633| 0| lastdfa + numtemps, current_max_dfas); 634| 0| fprintf (stderr, 635| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 636| 0| (" %d/%d (peak %d) nxt-chk entries created\n"), 637| 0| tblend, current_max_xpairs, peakpairs); 638| 0| fprintf (stderr, 639| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 640| 0| (" %d/%d (peak %d) template nxt-chk entries created\n"), 641| 0| numtemps * nummecs, 642| 0| current_max_template_xpairs, 643| 0| numtemps * numecs); 644| 0| fprintf (stderr, _(" %d empty table entries\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 645| 0| nummt); 646| 0| fprintf (stderr, _(" %d protos created\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 647| 0| numprots); 648| 0| fprintf (stderr, 649| 0| _(" %d templates created, %d uses\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 650| 0| numtemps, tmpuses); 651| 0| } 652| | 653| 0| if (ctrl.useecs) { ------------------ | Branch (653:7): [True: 0, False: 0] ------------------ 654| 0| tblsiz = tblsiz + ctrl.csize; 655| 0| fprintf (stderr, 656| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 657| 0| (" %d/%d equivalence classes created\n"), 658| 0| numecs, ctrl.csize); 659| 0| } 660| | 661| 0| if (ctrl.usemecs) { ------------------ | Branch (661:7): [True: 0, False: 0] ------------------ 662| 0| tblsiz = tblsiz + numecs; 663| 0| fprintf (stderr, 664| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 665| 0| (" %d/%d meta-equivalence classes created\n"), 666| 0| nummecs, ctrl.csize); 667| 0| } 668| | 669| 0| fprintf (stderr, 670| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 671| 0| (" %d (%d saved) hash collisions, %d DFAs equal\n"), 672| 0| hshcol, hshsave, dfaeql); 673| 0| fprintf (stderr, _(" %d sets of reallocations needed\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 674| 0| num_reallocs); 675| 0| fprintf (stderr, _(" %d total table entries needed\n"), ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 676| 0| tblsiz); 677| 0| } 678| | 679| 1| FLEX_EXIT (exit_status); ------------------ | | 1127| 1|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 680| 632|} flexinit: 686| 632|{ 687| 632| int i, sawcmpflag, rv, optind; 688| 632| char *arg; 689| 632| scanopt_t sopt; 690| | 691| 632| memset(&ctrl, '\0', sizeof(ctrl)); 692| 632| syntaxerror = false; 693| 632| yymore_used = continued_action = false; 694| 632| in_rule = reject = false; 695| 632| ctrl.yymore_really_used = ctrl.reject_really_used = trit_unspecified; 696| | 697| 632| ctrl.do_main = trit_unspecified; 698| 632| ctrl.interactive = ctrl.csize = trit_unspecified; 699| 632| ctrl.do_yywrap = ctrl.gen_line_dirs = ctrl.usemecs = ctrl.useecs = true; 700| 632| ctrl.reentrant = ctrl.bison_bridge_lval = ctrl.bison_bridge_lloc = false; 701| 632| env.performance_hint = 0; 702| 632| ctrl.prefix = "yy"; 703| 632| ctrl.rewrite = false; 704| 632| ctrl.yylmax = BUFSIZ; 705| | 706| 632| tablesext = tablesverify = false; 707| 632| gentables = true; 708| 632| tablesfilename = tablesname = NULL; 709| | 710| 632| sawcmpflag = false; 711| | 712| | /* Initialize dynamic array for holding the rule actions. */ 713| 632| action_size = 2048; /* default size of action array in bytes */ 714| 632| action_array = allocate_character_array (action_size); ------------------ | | 734| 632| allocate_array( size, sizeof(char)) ------------------ 715| 632| defs1_offset = prolog_offset = action_offset = action_index = 0; 716| 632| action_array[0] = '\0'; 717| | 718| | /* Initialize any buffers. */ 719| 632| buf_init (&userdef_buf, sizeof (char)); /* one long string */ 720| 632| buf_init (&top_buf, sizeof (char)); /* one long string */ 721| | 722| 632| sf_init (); 723| | 724| | /* Enable C++ if program name ends with '+'. */ 725| 632| program_name = argv[0]; 726| | 727| 632| if (program_name != NULL && ------------------ | Branch (727:6): [True: 632, False: 0] ------------------ 728| 632| program_name[strlen (program_name) - 1] == '+') ------------------ | Branch (728:6): [True: 0, False: 632] ------------------ 729| 0| ctrl.C_plus_plus = true; 730| | 731| | /* read flags */ 732| 632| sopt = scanopt_init (flexopts, argc, argv, 0); 733| 632| if (!sopt) { ------------------ | Branch (733:6): [True: 0, False: 632] ------------------ 734| | /* This will only happen when flexopts array is altered. */ 735| 0| fprintf (stderr, 736| 0| _("Internal error. flexopts are malformed.\n")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 737| 0| FLEX_EXIT (1); ------------------ | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 738| 0| } 739| | 740| 632| while ((rv = scanopt (sopt, &arg, &optind)) != 0) { ------------------ | Branch (740:9): [True: 0, False: 632] ------------------ 741| | 742| 0| if (rv < 0) { ------------------ | Branch (742:7): [True: 0, False: 0] ------------------ 743| | /* Scanopt has already printed an option-specific error message. */ 744| 0| fprintf (stderr, 745| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 746| 0| ("Try `%s --help' for more information.\n"), 747| 0| program_name); 748| 0| FLEX_EXIT (1); ------------------ | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 749| 0| } 750| | 751| 0| switch ((enum flexopt_flag_t) rv) { ------------------ | Branch (751:11): [True: 0, False: 0] ------------------ 752| 0| case OPT_CPLUSPLUS: ------------------ | Branch (752:7): [True: 0, False: 0] ------------------ 753| 0| ctrl.C_plus_plus = true; 754| 0| break; 755| | 756| 0| case OPT_BATCH: ------------------ | Branch (756:7): [True: 0, False: 0] ------------------ 757| 0| ctrl.interactive = trit_false; 758| 0| break; 759| | 760| 0| case OPT_BACKUP: ------------------ | Branch (760:7): [True: 0, False: 0] ------------------ 761| 0| env.backing_up_report = trit_true; 762| 0| break; 763| | 764| 0| case OPT_BACKUP_FILE: ------------------ | Branch (764:7): [True: 0, False: 0] ------------------ 765| 0| env.backing_up_report = true; 766| 0| backing_name = arg; 767| 0| break; 768| | 769| 0| case OPT_DONOTHING: ------------------ | Branch (769:7): [True: 0, False: 0] ------------------ 770| 0| break; 771| | 772| 0| case OPT_COMPRESSION: ------------------ | Branch (772:7): [True: 0, False: 0] ------------------ 773| 0| if (!sawcmpflag) { ------------------ | Branch (773:8): [True: 0, False: 0] ------------------ 774| 0| ctrl.useecs = false; 775| 0| ctrl.usemecs = false; 776| 0| ctrl.fulltbl = false; 777| 0| sawcmpflag = true; 778| 0| } 779| | 780| 0| for (i = 0; arg && arg[i] != '\0'; i++) ------------------ | Branch (780:16): [True: 0, False: 0] | Branch (780:23): [True: 0, False: 0] ------------------ 781| 0| switch (arg[i]) { 782| 0| case 'a': ------------------ | Branch (782:9): [True: 0, False: 0] ------------------ 783| 0| ctrl.long_align = true; 784| 0| break; 785| | 786| 0| case 'e': ------------------ | Branch (786:9): [True: 0, False: 0] ------------------ 787| 0| ctrl.useecs = true; 788| 0| break; 789| | 790| 0| case 'F': ------------------ | Branch (790:9): [True: 0, False: 0] ------------------ 791| 0| ctrl.fullspd = true; 792| 0| break; 793| | 794| 0| case 'f': ------------------ | Branch (794:9): [True: 0, False: 0] ------------------ 795| 0| ctrl.fulltbl = true; 796| 0| break; 797| | 798| 0| case 'm': ------------------ | Branch (798:9): [True: 0, False: 0] ------------------ 799| 0| ctrl.usemecs = true; 800| 0| break; 801| | 802| 0| case 'r': ------------------ | Branch (802:9): [True: 0, False: 0] ------------------ 803| 0| ctrl.use_read = true; 804| 0| break; 805| | 806| 0| default: ------------------ | Branch (806:9): [True: 0, False: 0] ------------------ 807| 0| lerr (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 808| 0| ("unknown -C option '%c'"), 809| 0| arg[i]); 810| 0| break; 811| 0| } 812| 0| break; 813| | 814| 0| case OPT_DEBUG: ------------------ | Branch (814:7): [True: 0, False: 0] ------------------ 815| 0| ctrl.ddebug = true; 816| 0| break; 817| | 818| 0| case OPT_NO_DEBUG: ------------------ | Branch (818:7): [True: 0, False: 0] ------------------ 819| 0| ctrl.ddebug = false; 820| 0| break; 821| | 822| 0| case OPT_FULL: ------------------ | Branch (822:7): [True: 0, False: 0] ------------------ 823| 0| ctrl.useecs = ctrl.usemecs = false; 824| 0| ctrl.use_read = ctrl.fulltbl = true; 825| 0| break; 826| | 827| 0| case OPT_FAST: ------------------ | Branch (827:7): [True: 0, False: 0] ------------------ 828| 0| ctrl.useecs = ctrl.usemecs = false; 829| 0| ctrl.use_read = ctrl.fullspd = true; 830| 0| break; 831| | 832| 0| case OPT_HELP: ------------------ | Branch (832:7): [True: 0, False: 0] ------------------ 833| 0| usage (); 834| 0| FLEX_EXIT (0); ------------------ | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 835| | 836| 0| case OPT_INTERACTIVE: ------------------ | Branch (836:7): [True: 0, False: 0] ------------------ 837| 0| ctrl.interactive = true; 838| 0| break; 839| | 840| 0| case OPT_CASE_INSENSITIVE: ------------------ | Branch (840:7): [True: 0, False: 0] ------------------ 841| 0| sf_set_case_ins(true); ------------------ | | 1208| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 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)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1208:34): [Folded - Ignored] | | ------------------ ------------------ 842| 0| break; 843| | 844| 0| case OPT_LEX_COMPAT: ------------------ | Branch (844:7): [True: 0, False: 0] ------------------ 845| 0| ctrl.lex_compat = true; 846| 0| break; 847| | 848| 0| case OPT_POSIX_COMPAT: ------------------ | Branch (848:7): [True: 0, False: 0] ------------------ 849| 0| ctrl.posix_compat = true; 850| 0| break; 851| | 852| 0| case OPT_PREPROC_LEVEL: ------------------ | Branch (852:7): [True: 0, False: 0] ------------------ 853| 0| preproc_level = (int) strtol(arg,NULL,0); 854| 0| break; 855| | 856| 0| case OPT_MAIN: ------------------ | Branch (856:7): [True: 0, False: 0] ------------------ 857| 0| ctrl.do_yywrap = false; 858| 0| ctrl.do_main = trit_true; 859| 0| break; 860| | 861| 0| case OPT_NO_MAIN: ------------------ | Branch (861:7): [True: 0, False: 0] ------------------ 862| 0| ctrl.do_main = trit_false; 863| 0| break; 864| | 865| 0| case OPT_NO_LINE: ------------------ | Branch (865:7): [True: 0, False: 0] ------------------ 866| 0| ctrl.gen_line_dirs = false; 867| 0| break; 868| | 869| 0| case OPT_OUTFILE: ------------------ | Branch (869:7): [True: 0, False: 0] ------------------ 870| 0| env.outfilename = arg; 871| 0| env.did_outfilename = 1; 872| 0| break; 873| | 874| 0| case OPT_PREFIX: ------------------ | Branch (874:7): [True: 0, False: 0] ------------------ 875| 0| ctrl.prefix = arg; 876| 0| break; 877| | 878| 0| case OPT_PERF_REPORT: ------------------ | Branch (878:7): [True: 0, False: 0] ------------------ 879| 0| ++env.performance_hint; 880| 0| break; 881| | 882| 0| case OPT_BISON_BRIDGE: ------------------ | Branch (882:7): [True: 0, False: 0] ------------------ 883| 0| ctrl.bison_bridge_lval = true; 884| 0| break; 885| | 886| 0| case OPT_BISON_BRIDGE_LOCATIONS: ------------------ | Branch (886:7): [True: 0, False: 0] ------------------ 887| 0| ctrl.bison_bridge_lval = ctrl.bison_bridge_lloc = true; 888| 0| break; 889| | 890| 0| case OPT_REENTRANT: ------------------ | Branch (890:7): [True: 0, False: 0] ------------------ 891| 0| ctrl.reentrant = true; 892| 0| break; 893| | 894| 0| case OPT_NO_REENTRANT: ------------------ | Branch (894:7): [True: 0, False: 0] ------------------ 895| 0| ctrl.reentrant = false; 896| 0| break; 897| | 898| 0| case OPT_SKEL: ------------------ | Branch (898:7): [True: 0, False: 0] ------------------ 899| 0| env.skelname = arg; 900| 0| break; 901| | 902| 0| case OPT_DEFAULT: ------------------ | Branch (902:7): [True: 0, False: 0] ------------------ 903| 0| ctrl.spprdflt = false; 904| 0| break; 905| | 906| 0| case OPT_NO_DEFAULT: ------------------ | Branch (906:7): [True: 0, False: 0] ------------------ 907| 0| ctrl.spprdflt = true; 908| 0| break; 909| | 910| 0| case OPT_STDOUT: ------------------ | Branch (910:7): [True: 0, False: 0] ------------------ 911| 0| env.use_stdout = true; 912| 0| break; 913| | 914| 0| case OPT_NO_UNISTD_H: ------------------ | Branch (914:7): [True: 0, False: 0] ------------------ 915| 0| ctrl.no_unistd = true; 916| 0| break; 917| | 918| 0| case OPT_TABLES_FILE: ------------------ | Branch (918:7): [True: 0, False: 0] ------------------ 919| 0| tablesext = true; 920| 0| tablesfilename = arg; 921| 0| break; 922| | 923| 0| case OPT_TABLES_VERIFY: ------------------ | Branch (923:7): [True: 0, False: 0] ------------------ 924| 0| tablesverify = true; 925| 0| break; 926| | 927| 0| case OPT_TRACE: ------------------ | Branch (927:7): [True: 0, False: 0] ------------------ 928| 0| env.trace = true; 929| 0| break; 930| | 931| 0| case OPT_VERBOSE: ------------------ | Branch (931:7): [True: 0, False: 0] ------------------ 932| 0| env.printstats = true; 933| 0| break; 934| | 935| 0| case OPT_VERSION: ------------------ | Branch (935:7): [True: 0, False: 0] ------------------ 936| 0| printf ("%s %s\n", (ctrl.C_plus_plus ? "flex++" : "flex"), flex_version); ------------------ | Branch (936:24): [True: 0, False: 0] ------------------ 937| 0| FLEX_EXIT (0); ------------------ | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 938| | 939| 0| case OPT_WARN: ------------------ | Branch (939:7): [True: 0, False: 0] ------------------ 940| 0| env.nowarn = false; 941| 0| break; 942| | 943| 0| case OPT_NO_WARN: ------------------ | Branch (943:7): [True: 0, False: 0] ------------------ 944| 0| env.nowarn = true; 945| 0| break; 946| | 947| 0| case OPT_7BIT: ------------------ | Branch (947:7): [True: 0, False: 0] ------------------ 948| 0| ctrl.csize = 128; 949| 0| break; 950| | 951| 0| case OPT_8BIT: ------------------ | Branch (951:7): [True: 0, False: 0] ------------------ 952| 0| ctrl.csize = CSIZE; ------------------ | | 91| 0|#define CSIZE 256 ------------------ 953| 0| break; 954| | 955| 0| case OPT_ALIGN: ------------------ | Branch (955:7): [True: 0, False: 0] ------------------ 956| 0| ctrl.long_align = true; 957| 0| break; 958| | 959| 0| case OPT_NO_ALIGN: ------------------ | Branch (959:7): [True: 0, False: 0] ------------------ 960| 0| ctrl.long_align = false; 961| 0| break; 962| | 963| 0| case OPT_ALWAYS_INTERACTIVE: ------------------ | Branch (963:7): [True: 0, False: 0] ------------------ 964| 0| ctrl.always_interactive = true; 965| 0| break; 966| | 967| 0| case OPT_NEVER_INTERACTIVE: ------------------ | Branch (967:7): [True: 0, False: 0] ------------------ 968| 0| ctrl.never_interactive = true; 969| 0| break; 970| | 971| 0| case OPT_ARRAY: ------------------ | Branch (971:7): [True: 0, False: 0] ------------------ 972| 0| ctrl.yytext_is_array = true; 973| 0| break; 974| | 975| 0| case OPT_POINTER: ------------------ | Branch (975:7): [True: 0, False: 0] ------------------ 976| 0| ctrl.yytext_is_array = false; 977| 0| break; 978| | 979| 0| case OPT_ECS: ------------------ | Branch (979:7): [True: 0, False: 0] ------------------ 980| 0| ctrl.useecs = true; 981| 0| break; 982| | 983| 0| case OPT_NO_ECS: ------------------ | Branch (983:7): [True: 0, False: 0] ------------------ 984| 0| ctrl.useecs = false; 985| 0| break; 986| | 987| 0| case OPT_EMIT: ------------------ | Branch (987:7): [True: 0, False: 0] ------------------ 988| 0| ctrl.emit = arg; 989| 0| break; 990| | 991| 0| case OPT_HEADER_FILE: ------------------ | Branch (991:7): [True: 0, False: 0] ------------------ 992| 0| env.headerfilename = arg; 993| 0| break; 994| | 995| 0| case OPT_META_ECS: ------------------ | Branch (995:7): [True: 0, False: 0] ------------------ 996| 0| ctrl.usemecs = true; 997| 0| break; 998| | 999| 0| case OPT_NO_META_ECS: ------------------ | Branch (999:7): [True: 0, False: 0] ------------------ 1000| 0| ctrl.usemecs = false; 1001| 0| break; 1002| | 1003| 0| case OPT_PREPROCDEFINE: ------------------ | Branch (1003:7): [True: 0, False: 0] ------------------ 1004| 0| { 1005| | /* arg is "symbol" or "symbol=definition". */ 1006| 0| char *def; 1007| 0| char buf2[4096]; 1008| | 1009| 0| for (def = arg; 1010| 0| *def != '\0' && *def != '='; ++def) ------------------ | Branch (1010:6): [True: 0, False: 0] | Branch (1010:22): [True: 0, False: 0] ------------------ 1011| 0| continue; 1012| 0| if (*def == '\0') ------------------ | Branch (1012:12): [True: 0, False: 0] ------------------ 1013| 0| def = "1"; 1014| | 1015| 0| snprintf(buf2, sizeof(buf2), "M4_HOOK_CONST_DEFINE_UNKNOWN(%s, %s)", arg, def); 1016| 0| buf_strappend (&userdef_buf, buf2); 1017| 0| } 1018| 0| break; 1019| | 1020| 0| case OPT_READ: ------------------ | Branch (1020:7): [True: 0, False: 0] ------------------ 1021| 0| ctrl.use_read = true; 1022| 0| break; 1023| | 1024| 0| case OPT_STACK: ------------------ | Branch (1024:7): [True: 0, False: 0] ------------------ 1025| 0| ctrl.stack_used = true; 1026| 0| break; 1027| | 1028| 0| case OPT_STDINIT: ------------------ | Branch (1028:7): [True: 0, False: 0] ------------------ 1029| 0| ctrl.do_stdinit = true; 1030| 0| break; 1031| | 1032| 0| case OPT_NO_STDINIT: ------------------ | Branch (1032:7): [True: 0, False: 0] ------------------ 1033| 0| ctrl.do_stdinit = false; 1034| 0| break; 1035| | 1036| 0| case OPT_YYCLASS: ------------------ | Branch (1036:7): [True: 0, False: 0] ------------------ 1037| 0| ctrl.yyclass = arg; 1038| 0| break; 1039| | 1040| 0| case OPT_YYLINENO: ------------------ | Branch (1040:7): [True: 0, False: 0] ------------------ 1041| 0| ctrl.do_yylineno = true; 1042| 0| break; 1043| | 1044| 0| case OPT_NO_YYLINENO: ------------------ | Branch (1044:7): [True: 0, False: 0] ------------------ 1045| 0| ctrl.do_yylineno = false; 1046| 0| break; 1047| | 1048| 0| case OPT_YYWRAP: ------------------ | Branch (1048:7): [True: 0, False: 0] ------------------ 1049| 0| ctrl.do_yywrap = true; 1050| 0| break; 1051| | 1052| 0| case OPT_NO_YYWRAP: ------------------ | Branch (1052:7): [True: 0, False: 0] ------------------ 1053| 0| ctrl.do_yywrap = false; 1054| 0| break; 1055| | 1056| 0| case OPT_YYMORE: ------------------ | Branch (1056:7): [True: 0, False: 0] ------------------ 1057| 0| ctrl.yymore_really_used = true; 1058| 0| break; 1059| | 1060| 0| case OPT_NO_YYMORE: ------------------ | Branch (1060:7): [True: 0, False: 0] ------------------ 1061| 0| ctrl.yymore_really_used = false; 1062| 0| break; 1063| | 1064| 0| case OPT_REJECT: ------------------ | Branch (1064:7): [True: 0, False: 0] ------------------ 1065| 0| ctrl.reject_really_used = true; 1066| 0| break; 1067| | 1068| 0| case OPT_NO_REJECT: ------------------ | Branch (1068:7): [True: 0, False: 0] ------------------ 1069| 0| ctrl.reject_really_used = false; 1070| 0| break; 1071| | 1072| 0| case OPT_NO_YY_PUSH_STATE: ------------------ | Branch (1072:7): [True: 0, False: 0] ------------------ 1073| 0| ctrl.no_yy_push_state = true; 1074| 0| break; 1075| 0| case OPT_NO_YY_POP_STATE: ------------------ | Branch (1075:7): [True: 0, False: 0] ------------------ 1076| 0| ctrl.no_yy_pop_state = true; 1077| 0| break; 1078| 0| case OPT_NO_YY_TOP_STATE: ------------------ | Branch (1078:7): [True: 0, False: 0] ------------------ 1079| 0| ctrl.no_yy_top_state = true; 1080| 0| break; 1081| 0| case OPT_NO_YYINPUT: ------------------ | Branch (1081:7): [True: 0, False: 0] ------------------ 1082| 0| ctrl.no_yyinput = true; 1083| 0| break; 1084| 0| case OPT_NO_YYUNPUT: ------------------ | Branch (1084:7): [True: 0, False: 0] ------------------ 1085| 0| ctrl.no_yyunput = true; 1086| 0| break; 1087| 0| case OPT_NO_YY_SCAN_BUFFER: ------------------ | Branch (1087:7): [True: 0, False: 0] ------------------ 1088| 0| ctrl.no_yy_scan_buffer = true; 1089| 0| break; 1090| 0| case OPT_NO_YY_SCAN_BYTES: ------------------ | Branch (1090:7): [True: 0, False: 0] ------------------ 1091| 0| ctrl.no_yy_scan_bytes = true; 1092| 0| break; 1093| 0| case OPT_NO_YY_SCAN_STRING: ------------------ | Branch (1093:7): [True: 0, False: 0] ------------------ 1094| 0| ctrl.no_yy_scan_string = true; 1095| 0| break; 1096| 0| case OPT_NO_YYGET_EXTRA: ------------------ | Branch (1096:7): [True: 0, False: 0] ------------------ 1097| 0| ctrl.no_yyget_extra = true; 1098| 0| break; 1099| 0| case OPT_NO_YYSET_EXTRA: ------------------ | Branch (1099:7): [True: 0, False: 0] ------------------ 1100| 0| ctrl.no_yyset_extra = true; 1101| 0| break; 1102| 0| case OPT_NO_YYGET_LENG: ------------------ | Branch (1102:7): [True: 0, False: 0] ------------------ 1103| 0| ctrl.no_yyget_leng = true; 1104| 0| break; 1105| 0| case OPT_NO_YYGET_TEXT: ------------------ | Branch (1105:7): [True: 0, False: 0] ------------------ 1106| 0| ctrl.no_yyget_text = true; 1107| 0| break; 1108| 0| case OPT_NO_YYGET_LINENO: ------------------ | Branch (1108:7): [True: 0, False: 0] ------------------ 1109| 0| ctrl.no_yyget_lineno = true; 1110| 0| break; 1111| 0| case OPT_NO_YYSET_LINENO: ------------------ | Branch (1111:7): [True: 0, False: 0] ------------------ 1112| 0| ctrl.no_yyset_lineno = true; 1113| 0| break; 1114| 0| case OPT_NO_YYGET_COLUMN: ------------------ | Branch (1114:7): [True: 0, False: 0] ------------------ 1115| 0| ctrl.no_yyget_column = true; 1116| 0| break; 1117| 0| case OPT_NO_YYSET_COLUMN: ------------------ | Branch (1117:7): [True: 0, False: 0] ------------------ 1118| 0| ctrl.no_yyset_column = true; 1119| 0| break; 1120| 0| case OPT_NO_YYGET_IN: ------------------ | Branch (1120:7): [True: 0, False: 0] ------------------ 1121| 0| ctrl.no_yyget_in = true; 1122| 0| break; 1123| 0| case OPT_NO_YYSET_IN: ------------------ | Branch (1123:7): [True: 0, False: 0] ------------------ 1124| 0| ctrl.no_yyset_in = true; 1125| 0| break; 1126| 0| case OPT_NO_YYGET_OUT: ------------------ | Branch (1126:7): [True: 0, False: 0] ------------------ 1127| 0| ctrl.no_yyget_out = true; 1128| 0| break; 1129| 0| case OPT_NO_YYSET_OUT: ------------------ | Branch (1129:7): [True: 0, False: 0] ------------------ 1130| 0| ctrl.no_yyset_out = true; 1131| 0| break; 1132| 0| case OPT_NO_YYGET_LVAL: ------------------ | Branch (1132:7): [True: 0, False: 0] ------------------ 1133| 0| ctrl.no_yyget_lval = true; 1134| 0| break; 1135| 0| case OPT_NO_YYSET_LVAL: ------------------ | Branch (1135:7): [True: 0, False: 0] ------------------ 1136| 0| ctrl.no_yyset_lval = true; 1137| 0| break; 1138| 0| case OPT_NO_YYGET_LLOC: ------------------ | Branch (1138:7): [True: 0, False: 0] ------------------ 1139| 0| ctrl.no_yyget_lloc = true; 1140| 0| break; 1141| 0| case OPT_NO_YYSET_LLOC: ------------------ | Branch (1141:7): [True: 0, False: 0] ------------------ 1142| 0| ctrl.no_yyset_lloc = true; 1143| 0| break; 1144| 0| case OPT_NO_YYGET_DEBUG: ------------------ | Branch (1144:7): [True: 0, False: 0] ------------------ 1145| 0| ctrl.no_get_debug = true; 1146| 0| break; 1147| 0| case OPT_NO_YYSET_DEBUG: ------------------ | Branch (1147:7): [True: 0, False: 0] ------------------ 1148| 0| ctrl.no_set_debug = true; 1149| 0| break; 1150| | 1151| 0| case OPT_HEX: ------------------ | Branch (1151:7): [True: 0, False: 0] ------------------ 1152| 0| env.trace_hex = true; 1153| 0| break; 1154| 0| case OPT_NO_SECT3_ESCAPE: ------------------ | Branch (1154:7): [True: 0, False: 0] ------------------ 1155| 0| ctrl.no_section3_escape = true; 1156| 0| break; 1157| 0| } /* switch */ 1158| 0| } /* while scanopt() */ 1159| | 1160| 632| scanopt_destroy (sopt); 1161| | 1162| 632| num_input_files = argc - optind; 1163| 632| input_files = argv + optind; 1164| 632| set_input_file (num_input_files > 0 ? input_files[0] : NULL); ------------------ | Branch (1164:18): [True: 632, False: 0] ------------------ 1165| | 1166| 632| lastccl = lastsc = lastdfa = lastnfa = 0; 1167| 632| num_rules = num_eof_rules = default_rule = 0; 1168| 632| numas = numsnpairs = tmpuses = 0; 1169| 632| numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = 1170| 632| 0; 1171| 632| numuniq = numdup = hshsave = eofseen = datapos = dataline = 0; 1172| 632| num_backing_up = onesp = numprots = 0; 1173| 632| variable_trailing_context_rules = bol_needed = false; 1174| | 1175| 632| linenum = sectnum = 1; 1176| 632| firstprot = NIL; ------------------ | | 177| 632|#define NIL 0 ------------------ 1177| | 1178| | /* Used in mkprot() so that the first proto goes in slot 1 1179| | * of the proto queue. 1180| | */ 1181| 632| lastprot = 1; 1182| | 1183| 632| set_up_initial_allocations (); 1184| 632|} readin: 1190| 632|{ 1191| 632| char buf[256]; 1192| | 1193| 632| line_directive_out(NULL, infilename, linenum); 1194| | 1195| 632| if (yyparse ()) { ------------------ | Branch (1195:6): [True: 0, False: 632] ------------------ 1196| 0| pinpoint_message (_("fatal parse error")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1197| 0| flexend (1); 1198| 0| } 1199| | 1200| 632| if (syntaxerror) ------------------ | Branch (1200:6): [True: 632, False: 0] ------------------ 1201| 632| flexend (1); 1202| | 1203| | /* On --emit, -e, or change backends This is where backend 1204| | * properties are collected, which means they can't be set 1205| | * from a custom skelfile. Note: might have been called sooner 1206| | * when %option emit was evaluated; this catches command-line 1207| | * optiins and the default case. 1208| | */ 1209| 632| backend_by_name(ctrl.emit); 1210| | 1211| 632| initialize_output_filters(); 1212| | 1213| 632| yyout = stdout; 1214| | 1215| 632| if (tablesext) ------------------ | Branch (1215:6): [True: 0, False: 632] ------------------ 1216| 0| gentables = false; 1217| | 1218| 632| if (tablesverify) ------------------ | Branch (1218:6): [True: 0, False: 632] ------------------ 1219| | /* force generation of C tables. */ 1220| 0| gentables = true; 1221| | 1222| | 1223| 632| if (tablesext) { ------------------ | Branch (1223:6): [True: 0, False: 632] ------------------ 1224| 0| FILE *tablesout; 1225| 0| struct yytbl_hdr hdr; 1226| 0| char *pname = 0; 1227| 0| size_t nbytes = 0; 1228| | 1229| 0| if (!tablesfilename) { ------------------ | Branch (1229:7): [True: 0, False: 0] ------------------ 1230| 0| nbytes = strlen (ctrl.prefix) + strlen (tablesfile_template) + 2; 1231| 0| tablesfilename = pname = calloc(nbytes, 1); 1232| 0| snprintf (pname, nbytes, tablesfile_template, ctrl.prefix); 1233| 0| } 1234| | 1235| 0| if ((tablesout = fopen (tablesfilename, "w")) == NULL) ------------------ | Branch (1235:7): [True: 0, False: 0] ------------------ 1236| 0| lerr (_("could not create %s"), tablesfilename); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1237| 0| free(pname); 1238| 0| tablesfilename = 0; 1239| | 1240| 0| yytbl_writer_init (&tableswr, tablesout); 1241| | 1242| 0| nbytes = strlen (ctrl.prefix) + strlen ("tables") + 2; 1243| 0| tablesname = calloc(nbytes, 1); 1244| 0| snprintf (tablesname, nbytes, "%stables", ctrl.prefix); 1245| 0| yytbl_hdr_init (&hdr, flex_version, tablesname); 1246| | 1247| 0| if (yytbl_hdr_fwrite (&tableswr, &hdr) <= 0) ------------------ | Branch (1247:7): [True: 0, False: 0] ------------------ 1248| 0| flexerror (_("could not write tables header")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1249| 0| } 1250| | 1251| 632| if (env.skelname && (skelfile = fopen (env.skelname, "r")) == NULL) ------------------ | Branch (1251:6): [True: 0, False: 632] | Branch (1251:22): [True: 0, False: 0] ------------------ 1252| 0| lerr (_("can't open skeleton file %s"), env.skelname); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1253| | 1254| 632| if (strchr(ctrl.prefix, '[') || strchr(ctrl.prefix, ']')) ------------------ | Branch (1254:6): [True: 632, False: 0] | Branch (1254:34): [True: 0, False: 0] ------------------ 1255| 0| flexerror(_("Prefix cannot include '[' or ']'")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1256| | 1257| 632| if (env.did_outfilename) ------------------ | Branch (1257:6): [True: 0, False: 632] ------------------ 1258| 0| line_directive_out (stdout, NULL, linenum); 1259| | 1260| | /* This is where we begin writing to the file. */ 1261| | 1262| 632| skelout(false); /* [0.0] Make hook macros available, silently */ 1263| | 1264| 632| comment("A lexical scanner generated by flex\n"); 1265| | 1266| | /* Dump the %top code. */ 1267| 632| if( top_buf.elts) ------------------ | Branch (1267:6): [True: 0, False: 632] ------------------ 1268| 0| outn((char*) top_buf.elts); 1269| | 1270| | /* Place a bogus line directive, it will be fixed in the filter. */ 1271| 632| line_directive_out(NULL, NULL, 0); 1272| | 1273| | /* User may want to set the scanner prototype */ 1274| 632| if (ctrl.yydecl != NULL) { ------------------ | Branch (1274:6): [True: 0, False: 632] ------------------ 1275| 0| out_str ("M4_HOOK_SET_YY_DECL(%s)\n", ctrl.yydecl); 1276| 0| } 1277| | 1278| 632| if (ctrl.userinit != NULL) { ------------------ | Branch (1278:6): [True: 0, False: 632] ------------------ 1279| 0| out_str ("M4_HOOK_SET_USERINIT(%s)\n", ctrl.userinit); 1280| 0| } 1281| 632| if (ctrl.preaction != NULL) { ------------------ | Branch (1281:6): [True: 0, False: 632] ------------------ 1282| 0| out_str ("M4_HOOK_SET_PREACTION(%s)\n", ctrl.preaction); 1283| 0| } 1284| 632| if (ctrl.postaction != NULL) { ------------------ | Branch (1284:6): [True: 0, False: 632] ------------------ 1285| 0| out_str ("M4_HOOK_SET_POSTACTION(%s)\n", ctrl.postaction); 1286| 0| } 1287| | 1288| | /* This has to be a straight textual substitution rather 1289| | * than a constant declaration because in C a const is 1290| | * not const enough to be a static array bound. 1291| | */ 1292| 632| out_dec ("m4_define([[YYLMAX]], [[%d]])\n", ctrl.yylmax); 1293| | 1294| | /* Dump the user defined preproc directives. */ 1295| 632| if (userdef_buf.elts) ------------------ | Branch (1295:6): [True: 0, False: 632] ------------------ 1296| 0| outn ((char *) (userdef_buf.elts)); 1297| | 1298| | /* If the user explicitly requested posix compatibility by specifying the 1299| | * posix-compat option, then we check for conflicting options. However, if 1300| | * the POSIXLY_CORRECT variable is set, then we quietly make flex as 1301| | * posix-compatible as possible. This is the recommended behavior 1302| | * according to the GNU Coding Standards. 1303| | * 1304| | * Note: The posix option was added to flex to provide the posix behavior 1305| | * of the repeat operator in regular expressions, e.g., `ab{3}' 1306| | */ 1307| 632| if (ctrl.posix_compat) { ------------------ | Branch (1307:6): [True: 0, False: 632] ------------------ 1308| | /* TODO: This is where we try to make flex behave according to 1309| | * POSIX, *and* check for conflicting ctrl. How far should we go 1310| | * with this? Should we disable all the neat-o flex features? 1311| | */ 1312| | /* Update: Estes says no, since other flex features don't violate posix. */ 1313| 0| } 1314| | 1315| 632| if (getenv ("POSIXLY_CORRECT")) { ------------------ | Branch (1315:6): [True: 0, False: 632] ------------------ 1316| 0| ctrl.posix_compat = true; 1317| 0| } 1318| | 1319| 632| if (env.backing_up_report) { ------------------ | Branch (1319:6): [True: 0, False: 632] ------------------ 1320| 0| ctrl.backing_up_file = fopen (backing_name, "w"); 1321| 0| if (ctrl.backing_up_file == NULL) ------------------ | Branch (1321:7): [True: 0, False: 0] ------------------ 1322| 0| lerr (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1323| 0| ("could not create backing-up info file %s"), 1324| 0| backing_name); 1325| 0| } 1326| | 1327| 632| else 1328| 632| ctrl.backing_up_file = NULL; 1329| | 1330| 632| if (ctrl.yymore_really_used == true) ------------------ | Branch (1330:6): [True: 0, False: 632] ------------------ 1331| 0| yymore_used = true; 1332| 632| else if (ctrl.yymore_really_used == false) ------------------ | Branch (1332:11): [True: 0, False: 632] ------------------ 1333| 0| yymore_used = false; 1334| | 1335| 632| if (ctrl.reject_really_used == true) ------------------ | Branch (1335:6): [True: 0, False: 632] ------------------ 1336| 0| reject = true; 1337| 632| else if (ctrl.reject_really_used == false) ------------------ | Branch (1337:11): [True: 0, False: 632] ------------------ 1338| 0| reject = false; 1339| | 1340| 632| if (env.performance_hint > 0) { ------------------ | Branch (1340:6): [True: 0, False: 632] ------------------ 1341| 0| if (ctrl.lex_compat) { ------------------ | Branch (1341:7): [True: 0, False: 0] ------------------ 1342| 0| fprintf (stderr, 1343| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1344| 0| ("-l AT&T lex compatibility option entails a large performance penalty\n")); 1345| 0| fprintf (stderr, 1346| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1347| 0| (" and may be the actual source of other reported performance penalties\n")); 1348| 0| } 1349| | 1350| 0| else if (ctrl.do_yylineno) { ------------------ | Branch (1350:12): [True: 0, False: 0] ------------------ 1351| 0| fprintf (stderr, 1352| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1353| 0| ("%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n")); 1354| 0| } 1355| | 1356| 0| if (env.performance_hint > 1) { ------------------ | Branch (1356:7): [True: 0, False: 0] ------------------ 1357| 0| if (ctrl.interactive == trit_true) ------------------ | Branch (1357:8): [True: 0, False: 0] ------------------ 1358| 0| fprintf (stderr, 1359| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1360| 0| ("-I (interactive) entails a minor performance penalty\n")); 1361| | 1362| 0| if (yymore_used) ------------------ | Branch (1362:8): [True: 0, False: 0] ------------------ 1363| 0| fprintf (stderr, 1364| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1365| 0| ("yymore() entails a minor performance penalty\n")); 1366| 0| } 1367| | 1368| 0| if (reject) ------------------ | Branch (1368:7): [True: 0, False: 0] ------------------ 1369| 0| fprintf (stderr, 1370| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1371| 0| ("REJECT entails a large performance penalty\n")); 1372| | 1373| 0| if (variable_trailing_context_rules) ------------------ | Branch (1373:7): [True: 0, False: 0] ------------------ 1374| 0| fprintf (stderr, 1375| 0| _ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1376| 0| ("Variable trailing context rules entail a large performance penalty\n")); 1377| 0| } 1378| | 1379| 632| if (reject) ------------------ | Branch (1379:6): [True: 0, False: 632] ------------------ 1380| 0| real_reject = true; 1381| | 1382| 632| if (variable_trailing_context_rules) ------------------ | Branch (1382:6): [True: 0, False: 632] ------------------ 1383| 0| reject = true; 1384| | 1385| 632| if ((ctrl.fulltbl || ctrl.fullspd) && reject) { ------------------ | Branch (1385:7): [True: 632, False: 0] | Branch (1385:23): [True: 0, False: 0] | Branch (1385:40): [True: 0, False: 0] ------------------ 1386| 0| if (real_reject) ------------------ | Branch (1386:7): [True: 0, False: 0] ------------------ 1387| 0| flexerror (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1388| 0| ("REJECT cannot be used with -f or -F")); 1389| 0| else if (ctrl.do_yylineno) ------------------ | Branch (1389:12): [True: 0, False: 0] ------------------ 1390| 0| flexerror (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1391| 0| ("%option yylineno cannot be used with REJECT")); 1392| 0| else 1393| 0| flexerror (_ ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1394| 0| ("variable trailing context rules cannot be used with -f or -F")); 1395| 0| } 1396| | 1397| 632| if (ctrl.useecs) ------------------ | Branch (1397:6): [True: 0, False: 632] ------------------ 1398| 0| numecs = cre8ecs (nextecm, ecgroup, ctrl.csize); 1399| 632| else 1400| 632| numecs = ctrl.csize; 1401| | 1402| | /* Now map the equivalence class for NUL to its expected place. */ 1403| 632| ecgroup[0] = ecgroup[ctrl.csize]; 1404| 632| NUL_ec = ABS (ecgroup[0]); ------------------ | | 108| 632|#define ABS(x) ((x) < 0 ? -(x) : (x)) | | ------------------ | | | Branch (108:17): [True: 0, False: 632] | | ------------------ ------------------ 1405| | 1406| 632| if (ctrl.useecs) ------------------ | Branch (1406:6): [True: 0, False: 632] ------------------ 1407| 0| ccl2ecl (); 1408| | 1409| | // These are used to conditionalize code in the lex skeleton 1410| | // that historically used to be generated by C code in flex 1411| | // itself; by shoving all this stuff out to the skeleton file 1412| | // we make it easier to retarget the code generation. 1413| 632| snprintf(buf, sizeof(buf), "Target: %s\n", ctrl.backend_name); 1414| 632| comment(buf); 1415| 632| comment("START of m4 controls\n"); 1416| | 1417| | /* Define the start condition macros. */ 1418| 632| { 1419| 632| struct Buf tmpbuf; 1420| 632| int i; 1421| 632| buf_init(&tmpbuf, sizeof(char)); 1422| 632| for (i = 1; i <= lastsc; i++) { ------------------ | Branch (1422:15): [True: 0, False: 632] ------------------ 1423| 0| char *str, *fmt = "M4_HOOK_CONST_DEFINE_STATE(%s, %d)"; 1424| 0| size_t strsz; 1425| | 1426| 0| strsz = strlen(fmt) + strlen(scname[i]) + (size_t)(1 + ceil (log10(i))) + 2; 1427| 0| str = malloc(strsz); 1428| 0| if (!str) ------------------ | Branch (1428:8): [True: 0, False: 0] ------------------ 1429| 0| flexfatal(_("allocation of macro definition failed")); ------------------ | | 87| 0|#define _(STRING) STRING ------------------ 1430| 0| snprintf(str, strsz, fmt, scname[i], i - 1); 1431| 0| buf_strappend(&tmpbuf, str); 1432| 0| free(str); 1433| 0| } 1434| | // FIXME: Not dumped visibly because we plan to do away with the indirection 1435| 632| out_m4_define("M4_YY_SC_DEFS", tmpbuf.elts); 1436| 632| buf_destroy(&tmpbuf); 1437| 632| } 1438| | 1439| 632| if (ctrl.bison_bridge_lval) ------------------ | Branch (1439:6): [True: 0, False: 632] ------------------ 1440| 0| visible_define("M4_YY_BISON_LVAL"); 1441| | 1442| 632| if (ctrl.bison_bridge_lloc) ------------------ | Branch (1442:6): [True: 0, False: 632] ------------------ 1443| 0| visible_define(""); 1444| | 1445| 632| if (extra_type != NULL) ------------------ | Branch (1445:6): [True: 0, False: 632] ------------------ 1446| 0| visible_define_str ("M4_MODE_EXTRA_TYPE", extra_type); 1447| | 1448| | /* always generate the tablesverify flag. */ 1449| 632| visible_define_str ("M4_YY_TABLES_VERIFY", tablesverify ? "1" : "0"); ------------------ | Branch (1449:45): [True: 0, False: 632] ------------------ 1450| | 1451| 632| if (ctrl.reentrant) { ------------------ | Branch (1451:6): [True: 0, False: 632] ------------------ 1452| 0| visible_define ("M4_YY_REENTRANT"); 1453| 0| if (ctrl.yytext_is_array) ------------------ | Branch (1453:7): [True: 0, False: 0] ------------------ 1454| 0| visible_define ("M4_MODE_REENTRANT_TEXT_IS_ARRAY"); 1455| 0| } 1456| | 1457| 632| if (ctrl.do_main == trit_true) ------------------ | Branch (1457:6): [True: 0, False: 632] ------------------ 1458| 0| visible_define_str ( "YY_MAIN", "1"); 1459| 632| else if (ctrl.do_main == trit_false) ------------------ | Branch (1459:11): [True: 0, False: 632] ------------------ 1460| 0| visible_define_str ( "YY_MAIN", "0"); 1461| | 1462| 632| if (ctrl.do_stdinit) ------------------ | Branch (1462:6): [True: 0, False: 632] ------------------ 1463| 0| visible_define ( "M4_MODE_DO_STDINIT"); 1464| 632| else 1465| 632| visible_define ( "M4_MODE_NO_DO_STDINIT"); 1466| | 1467| | // mode switches for YY_DO_BEFORE_ACTION code generation 1468| 632| if (ctrl.yytext_is_array) ------------------ | Branch (1468:6): [True: 0, False: 632] ------------------ 1469| 0| visible_define ( "M4_MODE_YYTEXT_IS_ARRAY"); 1470| 632| else 1471| 632| visible_define ( "M4_MODE_NO_YYTEXT_IS_ARRAY"); 1472| 632| if (yymore_used) ------------------ | Branch (1472:6): [True: 0, False: 632] ------------------ 1473| 0| visible_define ( "M4_MODE_YYMORE_USED"); 1474| 632| else 1475| 632| visible_define ( "M4_MODE_NO_YYMORE_USED"); 1476| | 1477| 632| if (ctrl.fullspd) ------------------ | Branch (1477:6): [True: 0, False: 632] ------------------ 1478| 0| visible_define ( "M4_MODE_REAL_FULLSPD"); 1479| 632| else 1480| 632| visible_define ( "M4_MODE_NO_REAL_FULLSPD"); 1481| | 1482| 632| if (ctrl.fulltbl) ------------------ | Branch (1482:6): [True: 0, False: 632] ------------------ 1483| 0| visible_define ( "M4_MODE_REAL_FULLTBL"); 1484| 632| else 1485| 632| visible_define ( "M4_MODE_NO_REAL_FULLTBL"); 1486| | 1487| | // niode switches for YYINPUT code generation 1488| 632| if (ctrl.use_read) ------------------ | Branch (1488:6): [True: 0, False: 632] ------------------ 1489| 0| visible_define ( "M4_MODE_CPP_USE_READ"); 1490| 632| else 1491| 632| visible_define ( "M4_MODE_NO_CPP_USE_READ"); 1492| | 1493| | // mode switches for next-action code 1494| 632| if (variable_trailing_context_rules) { ------------------ | Branch (1494:6): [True: 0, False: 632] ------------------ 1495| 0| visible_define ( "M4_MODE_VARIABLE_TRAILING_CONTEXT_RULES"); 1496| 632| } else { 1497| 632| visible_define ( "M4_MODE_NO_VARIABLE_TRAILING_CONTEXT_RULES"); 1498| 632| } 1499| 632| if (real_reject) ------------------ | Branch (1499:6): [True: 0, False: 632] ------------------ 1500| 0| visible_define ( "M4_MODE_REAL_REJECT"); 1501| 632| if (ctrl.reject_really_used) ------------------ | Branch (1501:6): [True: 0, False: 632] ------------------ 1502| 0| visible_define ( "M4_MODE_FIND_ACTION_REJECT_REALLY_USED"); 1503| 632| if (reject) ------------------ | Branch (1503:6): [True: 0, False: 632] ------------------ 1504| 0| visible_define ( "M4_MODE_USES_REJECT"); 1505| 632| else 1506| 632| visible_define ( "M4_MODE_NO_USES_REJECT"); 1507| | 1508| | // mode switches for computing next compressed state 1509| 632| if (ctrl.usemecs) ------------------ | Branch (1509:6): [True: 0, False: 632] ------------------ 1510| 0| visible_define ( "M4_MODE_USEMECS"); 1511| | 1512| | // mode switches for find-action code 1513| 632| if (ctrl.fullspd) ------------------ | Branch (1513:6): [True: 0, False: 632] ------------------ 1514| 0| visible_define ( "M4_MODE_FULLSPD"); 1515| 632| else if (ctrl.fulltbl) ------------------ | Branch (1515:11): [True: 0, False: 632] ------------------ 1516| 0| visible_define ( "M4_MODE_FIND_ACTION_FULLTBL"); 1517| 632| else if (reject) ------------------ | Branch (1517:11): [True: 0, False: 632] ------------------ 1518| 0| visible_define ( "M4_MODE_FIND_ACTION_REJECT"); 1519| 632| else 1520| 632| visible_define ( "M4_MODE_FIND_ACTION_COMPRESSED"); 1521| | 1522| | // mode switches for backup generation and gen_start_state 1523| 632| if (!ctrl.fullspd) ------------------ | Branch (1523:6): [True: 0, False: 632] ------------------ 1524| 0| visible_define ( "M4_MODE_NO_FULLSPD"); 1525| 632| if (bol_needed) ------------------ | Branch (1525:6): [True: 0, False: 632] ------------------ 1526| 0| visible_define ( "M4_MODE_BOL_NEEDED"); 1527| 632| else 1528| 632| visible_define ( "M4_MODE_NO_BOL_NEEDED"); 1529| | 1530| | // yylineno 1531| 632| if (ctrl.do_yylineno) ------------------ | Branch (1531:6): [True: 0, False: 632] ------------------ 1532| 0| visible_define ( "M4_MODE_YYLINENO"); 1533| | 1534| | // Equivalence classes 1535| 632| if (ctrl.useecs) ------------------ | Branch (1535:6): [True: 0, False: 632] ------------------ 1536| 0| visible_define ( "M4_MODE_USEECS"); 1537| 632| else 1538| 632| visible_define ( "M4_MODE_NO_USEECS"); 1539| | 1540| | // mode switches for getting next action 1541| 632| if (gentables) ------------------ | Branch (1541:6): [True: 0, False: 632] ------------------ 1542| 0| visible_define ( "M4_MODE_GENTABLES"); 1543| 632| else 1544| 632| visible_define ( "M4_MODE_NO_GENTABLES"); 1545| 632| if (ctrl.interactive == trit_true) ------------------ | Branch (1545:6): [True: 0, False: 632] ------------------ 1546| 0| visible_define ( "M4_MODE_INTERACTIVE"); 1547| 632| else 1548| 632| visible_define ( "M4_MODE_NO_INTERACTIVE"); 1549| 632| if (!(ctrl.fullspd || ctrl.fulltbl)) ------------------ | Branch (1549:8): [True: 632, False: 0] | Branch (1549:24): [True: 0, False: 0] ------------------ 1550| 0| visible_define ( "M4_MODE_NO_FULLSPD_OR_FULLTBL"); 1551| 632| if (reject || ctrl.interactive == trit_true) ------------------ | Branch (1551:6): [True: 632, False: 0] | Branch (1551:16): [True: 0, False: 0] ------------------ 1552| 0| visible_define ( "M4_MODE_FIND_ACTION_REJECT_OR_INTERACTIVE"); 1553| | 1554| 632| if (ctrl.yyclass != NULL) { ------------------ | Branch (1554:6): [True: 0, False: 632] ------------------ 1555| 0| visible_define ( "M4_MODE_YYCLASS"); 1556| 0| out_m4_define("M4_YY_CLASS_NAME", ctrl.yyclass); 1557| 0| } 1558| | 1559| 632| if (ctrl.ddebug) ------------------ | Branch (1559:6): [True: 0, False: 632] ------------------ 1560| 0| visible_define ( "M4_MODE_DEBUG"); 1561| | 1562| 632| if (ctrl.lex_compat) ------------------ | Branch (1562:6): [True: 0, False: 632] ------------------ 1563| 0| visible_define ( "M4_MODE_OPTIONS.LEX_COMPAT"); 1564| | 1565| 632| if (ctrl.do_yywrap) ------------------ | Branch (1565:6): [True: 0, False: 632] ------------------ 1566| 0| visible_define ( "M4_MODE_YYWRAP"); 1567| 632| else 1568| 632| visible_define ( "M4_MODE_NO_YYWRAP"); 1569| | 1570| 632| if (ctrl.interactive == trit_true) ------------------ | Branch (1570:6): [True: 0, False: 632] ------------------ 1571| 0| visible_define ( "M4_MODE_INTERACTIVE"); 1572| | 1573| 632| if (ctrl.noyyread) ------------------ | Branch (1573:6): [True: 0, False: 632] ------------------ 1574| 0| visible_define("M4_MODE_USER_YYREAD"); 1575| | 1576| 632| if (is_default_backend()) { ------------------ | Branch (1576:6): [True: 0, False: 632] ------------------ 1577| 0| if (ctrl.C_plus_plus) { ------------------ | Branch (1577:7): [True: 0, False: 0] ------------------ 1578| 0| visible_define ( "M4_MODE_CXX_ONLY"); 1579| 0| } else { 1580| 0| visible_define ( "M4_MODE_C_ONLY"); 1581| 0| } 1582| 0| } 1583| | 1584| 632| if (tablesext) ------------------ | Branch (1584:6): [True: 0, False: 632] ------------------ 1585| 0| visible_define ( "M4_MODE_TABLESEXT"); 1586| 632| if (ctrl.prefix != NULL) ------------------ | Branch (1586:6): [True: 0, False: 632] ------------------ 1587| 0| visible_define_str ( "M4_MODE_PREFIX", ctrl.prefix); 1588| | 1589| 632| if (ctrl.no_yyinput) ------------------ | Branch (1589:6): [True: 0, False: 632] ------------------ 1590| 0| visible_define("M4_MODE_NO_YYINPUT"); 1591| | 1592| 632| if (ctrl.bufsize != 0) ------------------ | Branch (1592:6): [True: 0, False: 632] ------------------ 1593| 0| visible_define_int("M4_MODE_YY_BUFSIZE", ctrl.bufsize); 1594| | 1595| 632| if (ctrl.yyterminate != NULL) ------------------ | Branch (1595:6): [True: 0, False: 632] ------------------ 1596| 0| visible_define_str("M4_MODE_YYTERMINATE", ctrl.yyterminate); 1597| | 1598| 632| if (ctrl.no_yypanic) ------------------ | Branch (1598:6): [True: 0, False: 632] ------------------ 1599| 0| visible_define("M4_YY_NO_YYPANIC"); 1600| 632| if (ctrl.no_yy_push_state) ------------------ | Branch (1600:6): [True: 0, False: 632] ------------------ 1601| 0| visible_define("M4_YY_NO_PUSH_STATE"); 1602| 632| if (ctrl.no_yy_pop_state) ------------------ | Branch (1602:6): [True: 0, False: 632] ------------------ 1603| 0| visible_define("M4_YY_NO_POP_STATE"); 1604| 632| if (ctrl.no_yy_top_state) ------------------ | Branch (1604:6): [True: 0, False: 632] ------------------ 1605| 0| visible_define("M4_YY_NO_TOP_STATE"); 1606| 632| if (ctrl.no_yyunput) ------------------ | Branch (1606:6): [True: 0, False: 632] ------------------ 1607| 0| visible_define("M4_YY_NO_YYUNPUT"); 1608| 632| if (ctrl.no_yy_scan_buffer) ------------------ | Branch (1608:6): [True: 0, False: 632] ------------------ 1609| 0| visible_define("M4_YY_NO_SCAN_BUFFER"); 1610| 632| if (ctrl.no_yy_scan_bytes) ------------------ | Branch (1610:6): [True: 0, False: 632] ------------------ 1611| 0| visible_define("M4_YY_NO_SCAN_BYTES"); 1612| 632| if (ctrl.no_yy_scan_string) ------------------ | Branch (1612:6): [True: 0, False: 632] ------------------ 1613| 0| visible_define("M4_YY_NO_SCAN_STRING"); 1614| 632| if (ctrl.no_yyget_extra) ------------------ | Branch (1614:6): [True: 0, False: 632] ------------------ 1615| 0| visible_define("M4_YY_NO_GET_EXTRA"); 1616| 632| if (ctrl.no_yyset_extra) ------------------ | Branch (1616:6): [True: 0, False: 632] ------------------ 1617| 0| visible_define("M4_YY_NO_SET_EXTRA"); 1618| 632| if (ctrl.no_yyget_leng) ------------------ | Branch (1618:6): [True: 0, False: 632] ------------------ 1619| 0| visible_define("M4_YY_NO_GET_LENG"); 1620| 632| if (ctrl.no_yyget_text) ------------------ | Branch (1620:6): [True: 0, False: 632] ------------------ 1621| 0| visible_define("M4_YY_NO_GET_TEXT"); 1622| 632| if (ctrl.no_yyget_lineno) ------------------ | Branch (1622:6): [True: 0, False: 632] ------------------ 1623| 0| visible_define("M4_YY_NO_GET_LINENO"); 1624| 632| if (ctrl.no_yyset_lineno) ------------------ | Branch (1624:6): [True: 0, False: 632] ------------------ 1625| 0| visible_define("M4_YY_NO_SET_LINENO"); 1626| 632| if (ctrl.no_yyget_column) ------------------ | Branch (1626:6): [True: 0, False: 632] ------------------ 1627| 0| visible_define("M4_YY_NO_GET_COLUMN"); 1628| 632| if (ctrl.no_yyset_column) ------------------ | Branch (1628:6): [True: 0, False: 632] ------------------ 1629| 0| visible_define("M4_YY_NO_SET_COLUMN"); 1630| 632| if (ctrl.no_yyget_in) ------------------ | Branch (1630:6): [True: 0, False: 632] ------------------ 1631| 0| visible_define("M4_YY_NO_GET_IN"); 1632| 632| if (ctrl.no_yyset_in) ------------------ | Branch (1632:6): [True: 0, False: 632] ------------------ 1633| 0| visible_define("M4_YY_NO_SET_IN"); 1634| 632| if (ctrl.no_yyget_out) ------------------ | Branch (1634:6): [True: 0, False: 632] ------------------ 1635| 0| visible_define("M4_YY_NO_GET_OUT"); 1636| 632| if (ctrl.no_yyset_out) ------------------ | Branch (1636:6): [True: 0, False: 632] ------------------ 1637| 0| visible_define("M4_YY_NO_SET_OUT"); 1638| 632| if (ctrl.no_yyget_lval) ------------------ | Branch (1638:6): [True: 0, False: 632] ------------------ 1639| 0| visible_define("M4_YY_NO_GET_LVAL"); 1640| 632| if (ctrl.no_yyset_lval) ------------------ | Branch (1640:6): [True: 0, False: 632] ------------------ 1641| 0| visible_define("M4_YY_NO_SET_LVAL"); 1642| 632| if (ctrl.no_yyget_lloc) ------------------ | Branch (1642:6): [True: 0, False: 632] ------------------ 1643| 0| visible_define("M4_YY_NO_GET_LLOC"); 1644| 632| if (ctrl.no_yyset_lloc) ------------------ | Branch (1644:6): [True: 0, False: 632] ------------------ 1645| 0| visible_define("M4_YY_NO_SET_LLOC"); 1646| 632| if (ctrl.no_flex_alloc) ------------------ | Branch (1646:6): [True: 0, False: 632] ------------------ 1647| 0| visible_define("M4_YY_NO_FLEX_ALLOC"); 1648| 632| if (ctrl.no_flex_realloc) ------------------ | Branch (1648:6): [True: 0, False: 632] ------------------ 1649| 0| visible_define("M4_YY_NO_FLEX_REALLOC"); 1650| 632| if (ctrl.no_flex_free) ------------------ | Branch (1650:6): [True: 0, False: 632] ------------------ 1651| 0| visible_define("M4_YY_NO_FLEX_FREE"); 1652| 632| if (ctrl.no_get_debug) ------------------ | Branch (1652:6): [True: 0, False: 632] ------------------ 1653| 0| visible_define("M4_YY_NO_GET_DEBUG"); 1654| 632| if (ctrl.no_set_debug) ------------------ | Branch (1654:6): [True: 0, False: 632] ------------------ 1655| 0| visible_define("M4_YY_NO_SET_DEBUG"); 1656| | 1657| 632| if (ctrl.no_unistd) ------------------ | Branch (1657:6): [True: 0, False: 632] ------------------ 1658| 0| visible_define("M4_YY_NO_UNISTD_H"); 1659| | 1660| 632| if (ctrl.always_interactive) ------------------ | Branch (1660:6): [True: 0, False: 632] ------------------ 1661| 0| visible_define("M4_YY_ALWAYS_INTERACTIVE"); 1662| 632| if (ctrl.never_interactive) ------------------ | Branch (1662:6): [True: 0, False: 632] ------------------ 1663| 0| visible_define("M4_YY_NEVER_INTERACTIVE"); 1664| 632| if (ctrl.stack_used) ------------------ | Branch (1664:6): [True: 0, False: 632] ------------------ 1665| 0| visible_define("M4_YY_STACK_USED"); 1666| | 1667| 632| if (ctrl.rewrite) ------------------ | Branch (1667:6): [True: 0, False: 632] ------------------ 1668| 0| visible_define ( "M4_MODE_REWRITE"); 1669| 632| else 1670| 632| visible_define ( "M4_MODE_NO_REWRITE"); 1671| | 1672| 632| comment("END of m4 controls\n"); 1673| 632| out ("\n"); 1674| 632|} set_up_initial_allocations: 1679| 632|{ 1680| 632| maximum_mns = (ctrl.long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS); ------------------ | | 204| 0|#define MAXIMUM_MNS_LONG 1999999999 ------------------ maximum_mns = (ctrl.long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS); ------------------ | | 203| 632|#define MAXIMUM_MNS 31999 ------------------ | Branch (1680:17): [True: 0, False: 632] ------------------ 1681| 632| current_mns = INITIAL_MNS; ------------------ | | 194| 632|#define INITIAL_MNS 2000 /* default maximum number of nfa states */ ------------------ 1682| 632| firstst = allocate_integer_array (current_mns); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1683| 632| lastst = allocate_integer_array (current_mns); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1684| 632| finalst = allocate_integer_array (current_mns); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1685| 632| transchar = allocate_integer_array (current_mns); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1686| 632| trans1 = allocate_integer_array (current_mns); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1687| 632| trans2 = allocate_integer_array (current_mns); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1688| 632| accptnum = allocate_integer_array (current_mns); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1689| 632| assoc_rule = allocate_integer_array (current_mns); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1690| 632| state_type = allocate_integer_array (current_mns); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1691| | 1692| 632| current_max_rules = INITIAL_MAX_RULES; ------------------ | | 191| 632|#define INITIAL_MAX_RULES 100 /* default maximum number of rules */ ------------------ 1693| 632| rule_type = allocate_integer_array (current_max_rules); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1694| 632| rule_linenum = allocate_integer_array (current_max_rules); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1695| 632| rule_useful = allocate_integer_array (current_max_rules); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1696| 632| rule_has_nl = allocate_bool_array (current_max_rules); ------------------ | | 710| 632| allocate_array(size, sizeof(bool)) ------------------ 1697| | 1698| 632| current_max_scs = INITIAL_MAX_SCS; ------------------ | | 221| 632|#define INITIAL_MAX_SCS 40 /* maximum number of start conditions */ ------------------ 1699| 632| scset = allocate_integer_array (current_max_scs); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1700| 632| scbol = allocate_integer_array (current_max_scs); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1701| 632| scxclu = allocate_integer_array (current_max_scs); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1702| 632| sceof = allocate_integer_array (current_max_scs); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1703| 632| scname = allocate_char_ptr_array (current_max_scs); ------------------ | | 719| 632| allocate_array(size, sizeof(char *)) ------------------ 1704| | 1705| 632| current_maxccls = INITIAL_MAX_CCLS; ------------------ | | 184| 632|#define INITIAL_MAX_CCLS 100 /* max number of unique character classes */ ------------------ 1706| 632| cclmap = allocate_integer_array (current_maxccls); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1707| 632| ccllen = allocate_integer_array (current_maxccls); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1708| 632| cclng = allocate_integer_array (current_maxccls); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1709| 632| ccl_has_nl = allocate_bool_array (current_maxccls); ------------------ | | 710| 632| allocate_array(size, sizeof(bool)) ------------------ 1710| | 1711| 632| current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE; ------------------ | | 188| 632|#define INITIAL_MAX_CCL_TBL_SIZE 500 ------------------ 1712| 632| ccltbl = allocate_Character_array (current_max_ccl_tbl_size); ------------------ | | 740| 632| allocate_array(size, sizeof(unsigned char)) ------------------ 1713| | 1714| 632| current_max_dfa_size = INITIAL_MAX_DFA_SIZE; ------------------ | | 150| 632|#define INITIAL_MAX_DFA_SIZE 750 ------------------ 1715| | 1716| 632| current_max_xpairs = INITIAL_MAX_XPAIRS; ------------------ | | 212| 632|#define INITIAL_MAX_XPAIRS 2000 ------------------ 1717| 632| nxt = allocate_integer_array (current_max_xpairs); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1718| 632| chk = allocate_integer_array (current_max_xpairs); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1719| | 1720| 632| current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS; ------------------ | | 216| 632|#define INITIAL_MAX_TEMPLATE_XPAIRS 2500 ------------------ 1721| 632| tnxt = allocate_integer_array (current_max_template_xpairs); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1722| | 1723| 632| current_max_dfas = INITIAL_MAX_DFAS; ------------------ | | 197| 632|#define INITIAL_MAX_DFAS 1000 /* default maximum number of dfa states */ ------------------ 1724| 632| base = allocate_integer_array (current_max_dfas); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1725| 632| def = allocate_integer_array (current_max_dfas); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1726| 632| dfasiz = allocate_integer_array (current_max_dfas); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1727| 632| accsiz = allocate_integer_array (current_max_dfas); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1728| 632| dhash = allocate_integer_array (current_max_dfas); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1729| 632| dss = allocate_int_ptr_array (current_max_dfas); ------------------ | | 716| 632| allocate_array(size, sizeof(int *)) ------------------ 1730| 632| dfaacc = allocate_dfaacc_union (current_max_dfas); ------------------ | | 722| 632| allocate_array(size, sizeof(union dfaacc_union)) ------------------ 1731| | 1732| 632| nultrans = NULL; 1733| 632|} add_action: 38| 3.04M|{ 39| 3.04M| int len = (int) strlen (new_text); 40| | 41| 3.05M| while (len + action_index >= action_size - 10 /* slop */ ) { ------------------ | Branch (41:9): [True: 1.40k, False: 3.04M] ------------------ 42| | 43| 1.40k| if (action_size > INT_MAX / 2) ------------------ | Branch (43:7): [True: 0, False: 1.40k] ------------------ 44| | /* Increase just a little, to try to avoid overflow 45| | * on 16-bit machines. 46| | */ 47| 0| action_size += action_size / 8; 48| 1.40k| else 49| 1.40k| action_size = action_size * 2; 50| | 51| 1.40k| action_array = 52| 1.40k| reallocate_character_array (action_array, ------------------ | | 737| 1.40k| reallocate_array((void *) array, size, sizeof(char)) ------------------ 53| 1.40k| action_size); 54| 1.40k| } 55| | 56| 3.04M| strcpy (&action_array[action_index], new_text); 57| | 58| 3.04M| action_index += len; 59| 3.04M|} allocate_array: 65| 22.1k|{ 66| 22.1k| void *new_array; 67| |#if HAVE_REALLOCARR 68| | new_array = NULL; 69| | if (reallocarr(&new_array, (size_t) size, element_size)) 70| | flexfatal (_("memory allocation failed in allocate_array()")); 71| |#else 72| 22.1k|# if HAVE_REALLOCARRAY 73| 22.1k| new_array = reallocarray(NULL, (size_t) size, element_size); 74| |# else 75| | /* Do manual overflow detection */ 76| | size_t num_bytes = (size_t) size * element_size; 77| | new_array = (size && SIZE_MAX / (size_t) size < element_size) ? NULL : 78| | malloc(num_bytes); 79| |# endif 80| 22.1k| if (!new_array) ------------------ | Branch (80:6): [True: 0, False: 22.1k] ------------------ 81| 0| flexfatal (_("memory allocation failed in allocate_array()")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 82| 22.1k|#endif 83| 22.1k| return new_array; 84| 22.1k|} xstrdup: 151| 1.38k|{ 152| 1.38k| char *s2; 153| | 154| 1.38k| if ((s2 = strdup(s)) == NULL) ------------------ | Branch (154:6): [True: 0, False: 1.38k] ------------------ 155| 0| flexfatal (_("memory allocation failure in xstrdup()")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 156| | 157| 1.38k| return s2; 158| 1.38k|} line_directive_out: 267| 1.26k|{ 268| 1.26k| char *trace_fmt = "m4_ifdef([[M4_HOOK_TRACE_LINE_FORMAT]], [[M4_HOOK_TRACE_LINE_FORMAT([[%d]], [[%s]])]])"; 269| 1.26k| char directive[MAXLINE*2], filename[MAXLINE]; 270| 1.26k| char *s1, *s2, *s3; 271| | 272| 1.26k| if (!ctrl.gen_line_dirs) ------------------ | Branch (272:6): [True: 0, False: 1.26k] ------------------ 273| 0| return; 274| | 275| 1.26k| s1 = (path != NULL) ? path : "M4_YY_OUTFILE_NAME"; ------------------ | Branch (275:7): [True: 1.26k, False: 0] ------------------ 276| | 277| 1.26k| if ((path != NULL) && !s1) ------------------ | Branch (277:6): [True: 1.26k, False: 0] | Branch (277:24): [True: 0, False: 1.26k] ------------------ 278| 0| s1 = ""; 279| | 280| 1.26k| s2 = filename; 281| 1.26k| s3 = &filename[sizeof (filename) - 2]; 282| | 283| 22.7k| while (s2 < s3 && *s1) { ------------------ | Branch (283:9): [True: 22.7k, False: 0] | Branch (283:20): [True: 21.5k, False: 1.26k] ------------------ 284| 21.5k| if (*s1 == '\\' || *s1 == '"') ------------------ | Branch (284:7): [True: 0, False: 21.5k] | Branch (284:22): [True: 0, False: 21.5k] ------------------ 285| | /* Escape the '\' or '"' */ 286| 0| *s2++ = '\\'; 287| | 288| 21.5k| *s2++ = *s1++; 289| 21.5k| } 290| | 291| 1.26k| *s2 = '\0'; 292| | 293| 1.26k| if (path != NULL) ------------------ | Branch (293:6): [True: 1.26k, False: 0] ------------------ 294| 1.26k| snprintf (directive, sizeof(directive), trace_fmt, linenum, filename); 295| 0| else { 296| 0| snprintf (directive, sizeof(directive), trace_fmt, 0, filename); 297| 0| } 298| | 299| | /* If output_file is nil then we should put the directive in 300| | * the accumulated actions. 301| | */ 302| 1.26k| if (output_file) { ------------------ | Branch (302:6): [True: 0, False: 1.26k] ------------------ 303| 0| fputs (directive, output_file); 304| 0| } 305| 1.26k| else 306| 1.26k| add_action (directive); 307| 1.26k|} mark_defs1: 315| 1|{ 316| 1| defs1_offset = 0; 317| 1| action_array[action_index++] = '\0'; 318| 1| action_offset = prolog_offset = action_index; 319| 1| action_array[action_index] = '\0'; 320| 1|} mark_prolog: 327| 2|{ 328| 2| action_array[action_index++] = '\0'; 329| 2| action_offset = action_index; 330| 2| action_array[action_index] = '\0'; 331| 2|} myctoi: 393| 2|{ 394| 2| int val = 0; 395| | 396| 2| (void) sscanf (array, "%d", &val); 397| | 398| 2| return val; 399| 2|} myesc: 405| 32|{ 406| 32| unsigned char c, esc_char; 407| | 408| 32| switch (array[1]) { 409| 0| case 'b': ------------------ | Branch (409:2): [True: 0, False: 32] ------------------ 410| 0| return '\b'; 411| 0| case 'f': ------------------ | Branch (411:2): [True: 0, False: 32] ------------------ 412| 0| return '\f'; 413| 0| case 'n': ------------------ | Branch (413:2): [True: 0, False: 32] ------------------ 414| 0| return '\n'; 415| 1| case 'r': ------------------ | Branch (415:2): [True: 1, False: 31] ------------------ 416| 1| return '\r'; 417| 0| case 't': ------------------ | Branch (417:2): [True: 0, False: 32] ------------------ 418| 0| return '\t'; 419| 0| case 'a': ------------------ | Branch (419:2): [True: 0, False: 32] ------------------ 420| 0| return '\a'; 421| 0| case 'v': ------------------ | Branch (421:2): [True: 0, False: 32] ------------------ 422| 0| return '\v'; 423| 0| case '0': ------------------ | Branch (423:2): [True: 0, False: 32] ------------------ 424| 0| case '1': ------------------ | Branch (424:2): [True: 0, False: 32] ------------------ 425| 0| case '2': ------------------ | Branch (425:2): [True: 0, False: 32] ------------------ 426| 0| case '3': ------------------ | Branch (426:2): [True: 0, False: 32] ------------------ 427| 0| case '4': ------------------ | Branch (427:2): [True: 0, False: 32] ------------------ 428| 0| case '5': ------------------ | Branch (428:2): [True: 0, False: 32] ------------------ 429| 0| case '6': ------------------ | Branch (429:2): [True: 0, False: 32] ------------------ 430| 0| case '7': ------------------ | Branch (430:2): [True: 0, False: 32] ------------------ 431| 0| { /* \ */ 432| 0| int sptr = 1; 433| | 434| 0| while (sptr <= 3 && ------------------ | Branch (434:11): [True: 0, False: 0] ------------------ 435| 0| array[sptr] >= '0' && array[sptr] <= '7') { ------------------ | Branch (435:32): [True: 0, False: 0] | Branch (435:54): [True: 0, False: 0] ------------------ 436| 0| ++sptr; 437| 0| } 438| | 439| 0| c = array[sptr]; 440| 0| array[sptr] = '\0'; 441| | 442| 0| esc_char = (unsigned char) strtoul (array + 1, NULL, 8); 443| | 444| 0| array[sptr] = c; 445| | 446| 0| return esc_char; 447| 0| } 448| | 449| 0| case 'x': ------------------ | Branch (449:2): [True: 0, False: 32] ------------------ 450| 0| { /* \x */ 451| 0| int sptr = 2; 452| | 453| 0| while (sptr <= 3 && isxdigit (array[sptr])) { ------------------ | Branch (453:11): [True: 0, False: 0] ------------------ 454| | /* Don't increment inside loop control 455| | * because if isxdigit() is a macro it might 456| | * expand into multiple increments ... 457| | */ 458| 0| ++sptr; 459| 0| } 460| | 461| 0| c = array[sptr]; 462| 0| array[sptr] = '\0'; 463| | 464| 0| esc_char = (unsigned char) strtoul (array + 2, NULL, 16); 465| | 466| 0| array[sptr] = c; 467| | 468| 0| return esc_char; 469| 0| } 470| | 471| 31| default: ------------------ | Branch (471:2): [True: 31, False: 1] ------------------ 472| 31| return array[1]; 473| 32| } 474| 32|} reallocate_array: 582| 1.40k|{ 583| 1.40k| void *new_array; 584| |#if HAVE_REALLOCARR 585| | new_array = array; 586| | if (reallocarr(&new_array, (size_t) size, element_size)) 587| | flexfatal (_("attempt to increase array size failed")); 588| |#else 589| 1.40k|# if HAVE_REALLOCARRAY 590| 1.40k| new_array = reallocarray(array, (size_t) size, element_size); 591| |# else 592| | /* Do manual overflow detection */ 593| | size_t num_bytes = (size_t) size * element_size; 594| | new_array = (size && SIZE_MAX / (size_t) size < element_size) ? NULL : 595| | realloc(array, num_bytes); 596| |# endif 597| 1.40k| if (!new_array) ------------------ | Branch (597:6): [True: 0, False: 1.40k] ------------------ 598| 0| flexfatal (_("attempt to increase array size failed")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 599| 1.40k|#endif 600| 1.40k| return new_array; 601| 1.40k|} add_accept: 49| 632|{ 50| | /* Hang the accepting number off an epsilon state. if it is associated 51| | * with a state that has a non-epsilon out-transition, then the state 52| | * will accept BEFORE it makes that transition, i.e., one character 53| | * too soon. 54| | */ 55| | 56| 632| if (transchar[finalst[mach]] == SYM_EPSILON) ------------------ | | 219| 632|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 632|#define CSIZE 256 | | ------------------ ------------------ | Branch (56:6): [True: 0, False: 632] ------------------ 57| 0| accptnum[finalst[mach]] = accepting_number; 58| | 59| 632| else { 60| 632| int astate = mkstate (SYM_EPSILON); ------------------ | | 219| 632|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 632|#define CSIZE 256 | | ------------------ ------------------ 61| | 62| 632| accptnum[astate] = accepting_number; 63| 632| (void) link_machines (mach, astate); 64| 632| } 65| 632|} finish_rule: 196| 632|{ 197| 632| char action_text[MAXLINE]; 198| | 199| 632| add_accept (mach, num_rules); 200| | 201| | /* We did this in new_rule(), but it often gets the wrong 202| | * number because we do it before we start parsing the current rule. 203| | */ 204| 632| rule_linenum[num_rules] = linenum; 205| | 206| | /* If this is a continued action, then the line-number has already 207| | * been updated, giving us the wrong number. 208| | */ 209| 632| if (continued_action) ------------------ | Branch (209:6): [True: 0, False: 632] ------------------ 210| 0| --rule_linenum[num_rules]; 211| | 212| | 213| | /* If the previous rule was continued action, then we inherit the 214| | * previous newline flag, possibly overriding the current one. 215| | */ 216| 632| if (pcont_act && rule_has_nl[num_rules - 1]) ------------------ | Branch (216:6): [True: 0, False: 632] | Branch (216:19): [True: 0, False: 0] ------------------ 217| 0| rule_has_nl[num_rules] = true; 218| | 219| 632| snprintf (action_text, sizeof(action_text), "M4_HOOK_NORMAL_STATE_CASE_ARM(%d)\n", num_rules); 220| 632| add_action (action_text); 221| 632| if (rule_has_nl[num_rules]) { ------------------ | Branch (221:6): [True: 0, False: 632] ------------------ 222| 0| snprintf (action_text, sizeof(action_text), "M4_HOOK_COMMENT_OPEN rule %d can match eol M4_HOOK_COMMENT_CLOSE\n", 223| 0| num_rules); 224| 0| add_action (action_text); 225| 0| } 226| | 227| | 228| 632| if (variable_trail_rule) { ------------------ | Branch (228:6): [True: 0, False: 632] ------------------ 229| 0| rule_type[num_rules] = RULE_VARIABLE; ------------------ | | 550| 0|#define RULE_VARIABLE 1 ------------------ 230| | 231| 0| if (env.performance_hint > 0) ------------------ | Branch (231:7): [True: 0, False: 0] ------------------ 232| 0| fprintf (stderr, 233| 0| _ ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 234| 0| ("Variable trailing context rule at line %d\n"), 235| 0| rule_linenum[num_rules]); 236| | 237| 0| variable_trailing_context_rules = true; 238| 0| } 239| | 240| 632| else { 241| 632| rule_type[num_rules] = RULE_NORMAL; ------------------ | | 549| 632|#define RULE_NORMAL 0 ------------------ 242| | 243| 632| if (headcnt > 0 || trailcnt > 0) { ------------------ | Branch (243:7): [True: 0, False: 632] | Branch (243:22): [True: 0, False: 632] ------------------ 244| | /* Do trailing context magic to not match the trailing 245| | * characters. 246| | */ 247| 0| add_action ("M4_HOOK_RELEASE_YYTEXT\n"); 248| | 249| 0| if (headcnt > 0) { ------------------ | Branch (249:8): [True: 0, False: 0] ------------------ 250| 0| if (rule_has_nl[num_rules]) { ------------------ | Branch (250:9): [True: 0, False: 0] ------------------ 251| 0| snprintf (action_text, sizeof(action_text), 252| 0| "M4_HOOK_LINE_FORWARD(%d)\n", headcnt); 253| 0| add_action (action_text); 254| 0| } 255| 0| snprintf (action_text, sizeof(action_text), "M4_HOOK_CHAR_FORWARD(%d)\n", 256| 0| headcnt); 257| 0| add_action (action_text); 258| 0| } 259| | 260| 0| else { 261| 0| if (rule_has_nl[num_rules]) { ------------------ | Branch (261:9): [True: 0, False: 0] ------------------ 262| 0| snprintf (action_text, sizeof(action_text), 263| 0| "M4_HOOK_LINE_REWIND(%d)\n", trailcnt); 264| 0| add_action (action_text); 265| 0| } 266| | 267| 0| snprintf (action_text, sizeof(action_text), "M4_HOOK_CHAR_REWIND(%d)\n", 268| 0| trailcnt); 269| 0| add_action (action_text); 270| 0| } 271| | 272| 0| add_action 273| 0| ("M4_HOOK_TAKE_YYTEXT\n"); 274| 0| } 275| 632| } 276| | 277| | /* Okay, in the action code at this point yytext and yyleng have 278| | * their proper final values for this rule, so here's the point 279| | * to do any user action. But don't do it for continued actions, 280| | * as that'll result in multiple rule-setup calls. 281| | */ 282| 632| if (!continued_action) ------------------ | Branch (282:6): [True: 632, False: 0] ------------------ 283| 632| add_action ("M4_HOOK_SET_RULE_SETUP\n"); 284| | 285| 632| line_directive_out(NULL, infilename, linenum); 286| 632| add_action("[["); 287| 632|} link_machines: 307| 632|{ 308| 632| if (first == NIL) ------------------ | | 177| 632|#define NIL 0 ------------------ | Branch (308:6): [True: 0, False: 632] ------------------ 309| 0| return last; 310| | 311| 632| else if (last == NIL) ------------------ | | 177| 632|#define NIL 0 ------------------ | Branch (311:11): [True: 0, False: 632] ------------------ 312| 0| return first; 313| | 314| 632| else { 315| 632| mkxtion (finalst[first], last); 316| 632| finalst[first] = finalst[last]; 317| 632| lastst[first] = MAX (lastst[first], lastst[last]); ------------------ | | 105| 632|#define MAX(x,y) ((x) > (y) ? (x) : (y)) | | ------------------ | | | Branch (105:19): [True: 0, False: 632] | | ------------------ ------------------ 318| 632| firstst[first] = MIN (firstst[first], firstst[last]); ------------------ | | 102| 632|#define MIN(x,y) ((x) < (y) ? (x) : (y)) | | ------------------ | | | Branch (102:19): [True: 632, False: 0] | | ------------------ ------------------ 319| | 320| 632| return first; 321| 632| } 322| 632|} mkbranch: 374| 632|{ 375| 632| int eps; 376| | 377| 632| if (first == NO_TRANSITION) ------------------ | | 180| 632|#define NO_TRANSITION NIL | | ------------------ | | | | 177| 632|#define NIL 0 | | ------------------ ------------------ | Branch (377:6): [True: 0, False: 632] ------------------ 378| 0| return second; 379| | 380| 632| else if (second == NO_TRANSITION) ------------------ | | 180| 632|#define NO_TRANSITION NIL | | ------------------ | | | | 177| 632|#define NIL 0 | | ------------------ ------------------ | Branch (380:11): [True: 0, False: 632] ------------------ 381| 0| return first; 382| | 383| 632| eps = mkstate (SYM_EPSILON); ------------------ | | 219| 632|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 632|#define CSIZE 256 | | ------------------ ------------------ 384| | 385| 632| mkxtion (eps, first); 386| 632| mkxtion (eps, second); 387| | 388| 632| return eps; 389| 632|} mkstate: 589| 3.16k|{ 590| 3.16k| if (++lastnfa >= current_mns) { ------------------ | Branch (590:6): [True: 0, False: 3.16k] ------------------ 591| 0| if ((current_mns += MNS_INCREMENT) >= maximum_mns) ------------------ | | 195| 0|#define MNS_INCREMENT 1000 /* amount to bump above by if it's not enough */ ------------------ | Branch (591:7): [True: 0, False: 0] ------------------ 592| 0| lerr(_ ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 593| 0| ("input rules are too complicated (>= %d NFA states)"), 594| 0|current_mns); 595| | 596| 0| ++num_reallocs; 597| | 598| 0| firstst = reallocate_integer_array (firstst, current_mns); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 599| 0| lastst = reallocate_integer_array (lastst, current_mns); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 600| 0| finalst = reallocate_integer_array (finalst, current_mns); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 601| 0| transchar = 602| 0| reallocate_integer_array (transchar, current_mns); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 603| 0| trans1 = reallocate_integer_array (trans1, current_mns); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 604| 0| trans2 = reallocate_integer_array (trans2, current_mns); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 605| 0| accptnum = 606| 0| reallocate_integer_array (accptnum, current_mns); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 607| 0| assoc_rule = 608| 0| reallocate_integer_array (assoc_rule, current_mns); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 609| 0| state_type = 610| 0| reallocate_integer_array (state_type, current_mns); ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 611| 0| } 612| | 613| 3.16k| firstst[lastnfa] = lastnfa; 614| 3.16k| finalst[lastnfa] = lastnfa; 615| 3.16k| lastst[lastnfa] = lastnfa; 616| 3.16k| transchar[lastnfa] = sym; 617| 3.16k| trans1[lastnfa] = NO_TRANSITION; ------------------ | | 180| 3.16k|#define NO_TRANSITION NIL | | ------------------ | | | | 177| 3.16k|#define NIL 0 | | ------------------ ------------------ 618| 3.16k| trans2[lastnfa] = NO_TRANSITION; ------------------ | | 180| 3.16k|#define NO_TRANSITION NIL | | ------------------ | | | | 177| 3.16k|#define NIL 0 | | ------------------ ------------------ 619| 3.16k| accptnum[lastnfa] = NIL; ------------------ | | 177| 3.16k|#define NIL 0 ------------------ 620| 3.16k| assoc_rule[lastnfa] = num_rules; 621| 3.16k| state_type[lastnfa] = current_state_type; 622| | 623| | /* Fix up equivalence classes base on this transition. Note that any 624| | * character which has its own transition gets its own equivalence 625| | * class. Thus only characters which are only in character classes 626| | * have a chance at being in the same equivalence class. E.g. "a|b" 627| | * puts 'a' and 'b' into two different equivalence classes. "[ab]" 628| | * puts them in the same equivalence class (barring other differences 629| | * elsewhere in the input). 630| | */ 631| | 632| 3.16k| if (sym < 0) { ------------------ | Branch (632:6): [True: 632, False: 2.52k] ------------------ 633| | /* We don't have to update the equivalence classes since 634| | * that was already done when the ccl was created for the 635| | * first time. 636| | */ 637| 632| } 638| | 639| 2.52k| else if (sym == SYM_EPSILON) ------------------ | | 219| 2.52k|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 2.52k|#define CSIZE 256 | | ------------------ ------------------ | Branch (639:11): [True: 2.52k, False: 0] ------------------ 640| 2.52k| ++numeps; 641| | 642| 0| else { 643| 0| check_char (sym); 644| | 645| 0| if (ctrl.useecs) ------------------ | Branch (645:7): [True: 0, False: 0] ------------------ 646| | /* Map NUL's to csize. */ 647| 0| mkechar (sym ? sym : ctrl.csize, nextecm, ecgroup); ------------------ | Branch (647:13): [True: 0, False: 0] ------------------ 648| 0| } 649| | 650| 3.16k| return lastnfa; 651| 3.16k|} mkxtion: 665| 1.89k|{ 666| 1.89k| if (trans1[statefrom] == NO_TRANSITION) ------------------ | | 180| 1.89k|#define NO_TRANSITION NIL | | ------------------ | | | | 177| 1.89k|#define NIL 0 | | ------------------ ------------------ | Branch (666:6): [True: 1.26k, False: 632] ------------------ 667| 1.26k| trans1[statefrom] = stateto; 668| | 669| 632| else if ((transchar[statefrom] != SYM_EPSILON) || ------------------ | | 219| 632|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 632|#define CSIZE 256 | | ------------------ ------------------ | Branch (669:11): [True: 0, False: 632] ------------------ 670| 632| (trans2[statefrom] != NO_TRANSITION)) ------------------ | | 180| 632|#define NO_TRANSITION NIL | | ------------------ | | | | 177| 632|#define NIL 0 | | ------------------ ------------------ | Branch (670:4): [True: 0, False: 632] ------------------ 671| 0| flexfatal (_("found too many transitions in mkxtion()")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 672| | 673| 632| else { /* second out-transition for an epsilon state */ 674| 632| ++eps2; 675| 632| trans2[statefrom] = stateto; 676| 632| } 677| 1.89k|} new_rule: 682| 632|{ 683| 632| if (++num_rules >= current_max_rules) { ------------------ | Branch (683:6): [True: 0, False: 632] ------------------ 684| 0| ++num_reallocs; 685| 0| current_max_rules += MAX_RULES_INCREMENT; ------------------ | | 192| 0|#define MAX_RULES_INCREMENT 100 ------------------ 686| 0| rule_type = reallocate_integer_array (rule_type, ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 687| 0| current_max_rules); 688| 0| rule_linenum = reallocate_integer_array (rule_linenum, ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 689| 0| current_max_rules); 690| 0| rule_useful = reallocate_integer_array (rule_useful, ------------------ | | 707| 0| reallocate_array((void *) array, size, sizeof(int)) ------------------ 691| 0| current_max_rules); 692| 0| rule_has_nl = reallocate_bool_array (rule_has_nl, ------------------ | | 713| 0| reallocate_array((void *) array, size, sizeof(bool)) ------------------ 693| 0| current_max_rules); 694| 0| } 695| | 696| 632| if (num_rules > MAX_RULE) ------------------ | | 171| 632|#define MAX_RULE (YY_TRAILING_MASK - 1) | | ------------------ | | | | 163| 632|#define YY_TRAILING_MASK 0x2000 | | ------------------ ------------------ | Branch (696:6): [True: 0, False: 632] ------------------ 697| 0| lerr (_("too many rules (> %d)!"), MAX_RULE); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ lerr (_("too many rules (> %d)!"), MAX_RULE); ------------------ | | 171| 0|#define MAX_RULE (YY_TRAILING_MASK - 1) | | ------------------ | | | | 163| 0|#define YY_TRAILING_MASK 0x2000 | | ------------------ ------------------ 698| | 699| 632| rule_linenum[num_rules] = linenum; 700| 632| rule_useful[num_rules] = false; 701| 632| rule_has_nl[num_rules] = false; 702| 632|} yyparse: 1381| 632|{ 1382| 632| yy_state_fast_t yystate; 1383| | /* Number of tokens to shift before error messages enabled. */ 1384| 632| int yyerrstatus; 1385| | 1386| | /* The stacks and their tools: 1387| | 'yyss': related to states. 1388| | 'yyvs': related to semantic values. 1389| | 1390| | Refer to the stacks through separate pointers, to allow yyoverflow 1391| | to reallocate them elsewhere. */ 1392| | 1393| | /* The state stack. */ 1394| 632| yy_state_t yyssa[YYINITDEPTH]; 1395| 632| yy_state_t *yyss; 1396| 632| yy_state_t *yyssp; 1397| | 1398| | /* The semantic value stack. */ 1399| 632| YYSTYPE yyvsa[YYINITDEPTH]; ------------------ | | 149| 632|#define YYSTYPE int ------------------ 1400| 632| YYSTYPE *yyvs; ------------------ | | 149| 632|#define YYSTYPE int ------------------ 1401| 632| YYSTYPE *yyvsp; ------------------ | | 149| 632|#define YYSTYPE int ------------------ 1402| | 1403| 632| YYPTRDIFF_T yystacksize; ------------------ | | 389| 632|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1404| | 1405| 632| int yyn; 1406| 632| int yyresult; 1407| | /* Lookahead token as an internal (translated) token number. */ 1408| 632| int yytoken = 0; 1409| | /* The variables used to return semantic value and location from the 1410| | action routines. */ 1411| 632| YYSTYPE yyval; ------------------ | | 149| 632|#define YYSTYPE int ------------------ 1412| | 1413| |#if YYERROR_VERBOSE 1414| | /* Buffer for error messages, and its allocated size. */ 1415| | char yymsgbuf[128]; 1416| | char *yymsg = yymsgbuf; 1417| | YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; 1418| |#endif 1419| | 1420| 632|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1421| | 1422| | /* The number of symbols on the RHS of the reduced rule. 1423| | Keep to zero when no symbol should be popped. */ 1424| 632| int yylen = 0; 1425| | 1426| 632| yyssp = yyss = yyssa; 1427| 632| yyvsp = yyvs = yyvsa; 1428| 632| yystacksize = YYINITDEPTH; ------------------ | | 1099| 632|# define YYINITDEPTH 200 ------------------ 1429| | 1430| 632| YYDPRINTF ((stderr, "Starting parse\n")); 1431| | 1432| 632| yystate = 0; 1433| 632| yyerrstatus = 0; 1434| 632| yynerrs = 0; 1435| 632| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 932| 632|#define YYEMPTY (-2) ------------------ 1436| 632| goto yysetstate; 1437| | 1438| | 1439| |/*------------------------------------------------------------. 1440| || yynewstate -- push a new state, which is found in yystate. | 1441| |`------------------------------------------------------------*/ 1442| 24.0k|yynewstate: 1443| | /* In all cases, when you get here, the value and location stacks 1444| | have just been pushed. So pushing a state here evens the stacks. */ 1445| 24.0k| yyssp++; 1446| | 1447| | 1448| |/*--------------------------------------------------------------------. 1449| || yysetstate -- set current state (the top of the stack) to yystate. | 1450| |`--------------------------------------------------------------------*/ 1451| 24.6k|yysetstate: 1452| 24.6k| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1453| 24.6k| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 497| 24.6k|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (497:31): [Folded - Ignored] | | | Branch (497:37): [True: 0, False: 0] | | | Branch (497:37): [True: 0, False: 0] | | ------------------ ------------------ 1454| 24.6k| YY_IGNORE_USELESS_CAST_BEGIN 1455| 24.6k| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 159| 24.6k|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1456| 24.6k| YY_IGNORE_USELESS_CAST_END 1457| | 1458| 24.6k| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1458:7): [True: 0, False: 24.6k] ------------------ 1459| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1460| | goto yyexhaustedlab; 1461| |#else 1462| 0| { 1463| | /* Get the current used size of the three stacks, in elements. */ 1464| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 389| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1465| | 1466| |# if defined yyoverflow 1467| | { 1468| | /* Give user a chance to reallocate the stack. Use copies of 1469| | these so that the &'s don't force the real ones into 1470| | memory. */ 1471| | yy_state_t *yyss1 = yyss; 1472| | YYSTYPE *yyvs1 = yyvs; 1473| | 1474| | /* Each stack pointer address is followed by the size of the 1475| | data in use in that stack, in bytes. This used to be a 1476| | conditional around just the two extra args, but that might 1477| | be undefined if yyoverflow is a macro. */ 1478| | yyoverflow (YY_("memory exhausted"), 1479| | &yyss1, yysize * YYSIZEOF (*yyssp), 1480| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1481| | &yystacksize); 1482| | yyss = yyss1; 1483| | yyvs = yyvs1; 1484| | } 1485| |# else /* defined YYSTACK_RELOCATE */ 1486| | /* Extend the stack our own way. */ 1487| 0| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1110| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1487:11): [True: 0, False: 0] ------------------ 1488| 0| goto yyexhaustedlab; 1489| 0| yystacksize *= 2; 1490| 0| if (YYMAXDEPTH < yystacksize) ------------------ | | 1110| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1490:11): [True: 0, False: 0] ------------------ 1491| 0| yystacksize = YYMAXDEPTH; ------------------ | | 1110| 0|# define YYMAXDEPTH 10000 ------------------ 1492| | 1493| 0| { 1494| 0| yy_state_t *yyss1 = yyss; 1495| 0| union yyalloc *yyptr = 1496| 0| YY_CAST (union yyalloc *, ------------------ | | 159| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1497| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1498| 0| if (! yyptr) ------------------ | Branch (1498:13): [True: 0, False: 0] ------------------ 1499| 0| goto yyexhaustedlab; 1500| 0| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 595| 0| do \ | | 596| 0| { \ | | 597| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 389| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 598| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 613| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 159| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 599| 0| Stack = &yyptr->Stack_alloc; \ | | 600| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 422| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 159| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 579| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 422| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 159| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 601| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 422| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 159| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 602| 0| } \ | | 603| 0| while (0) | | ------------------ | | | Branch (603:12): [Folded - Ignored] | | ------------------ ------------------ 1501| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 595| 0| do \ | | 596| 0| { \ | | 597| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 389| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 598| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 613| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 159| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 599| 0| Stack = &yyptr->Stack_alloc; \ | | 600| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 422| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 159| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 579| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 422| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 159| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 601| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 422| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 159| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 602| 0| } \ | | 603| 0| while (0) | | ------------------ | | | Branch (603:12): [Folded - Ignored] | | ------------------ ------------------ 1502| 0|# undef YYSTACK_RELOCATE 1503| 0| if (yyss1 != yyssa) ------------------ | Branch (1503:13): [True: 0, False: 0] ------------------ 1504| 0| YYSTACK_FREE (yyss1); ------------------ | | 539| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 558| 0|# define YYFREE free | | ------------------ ------------------ 1505| 0| } 1506| 0|# endif 1507| | 1508| 0| yyssp = yyss + yysize - 1; 1509| 0| yyvsp = yyvs + yysize - 1; 1510| | 1511| 0| YY_IGNORE_USELESS_CAST_BEGIN 1512| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n", 1513| 0| YY_CAST (long, yystacksize))); 1514| 0| YY_IGNORE_USELESS_CAST_END 1515| | 1516| 0| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1516:11): [True: 0, False: 0] ------------------ 1517| 0| YYABORT; ------------------ | | 936| 0|#define YYABORT goto yyabortlab ------------------ 1518| 0| } 1519| 24.6k|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1520| | 1521| 24.6k| if (yystate == YYFINAL) ------------------ | | 628| 24.6k|#define YYFINAL 3 ------------------ | Branch (1521:7): [True: 632, False: 24.0k] ------------------ 1522| 632| YYACCEPT; ------------------ | | 935| 632|#define YYACCEPT goto yyacceptlab ------------------ 1523| | 1524| 24.0k| goto yybackup; 1525| | 1526| | 1527| |/*-----------. 1528| || yybackup. | 1529| |`-----------*/ 1530| 24.0k|yybackup: 1531| | /* Do appropriate processing given the current state. Read a 1532| | lookahead token if we need one and don't already have one. */ 1533| | 1534| | /* First try to decide what to do without reference to lookahead token. */ 1535| 24.0k| yyn = yypact[yystate]; 1536| 24.0k| if (yypact_value_is_default (yyn)) ------------------ | | 753| 24.0k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 750| 24.0k|#define YYPACT_NINF (-88) | | ------------------ | | | Branch (753:3): [True: 12.0k, False: 11.9k] | | ------------------ ------------------ 1537| 12.0k| goto yydefault; 1538| | 1539| | /* Not known => get a lookahead token if don't already have one. */ 1540| | 1541| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1542| 11.9k| if (yychar == YYEMPTY) ------------------ | | 932| 11.9k|#define YYEMPTY (-2) ------------------ | Branch (1542:7): [True: 10.7k, False: 1.26k] ------------------ 1543| 10.7k| { 1544| 10.7k| YYDPRINTF ((stderr, "Reading a token: ")); 1545| 10.7k| yychar = yylex (); 1546| 10.7k| } 1547| | 1548| 11.9k| if (yychar <= YYEOF) ------------------ | | 933| 11.9k|#define YYEOF 0 ------------------ | Branch (1548:7): [True: 1.26k, False: 10.7k] ------------------ 1549| 1.26k| { 1550| 1.26k| yychar = yytoken = YYEOF; ------------------ | | 933| 1.26k|#define YYEOF 0 ------------------ 1551| 1.26k| YYDPRINTF ((stderr, "Now at end of input.\n")); 1552| 1.26k| } 1553| 10.7k| else 1554| 10.7k| { 1555| 10.7k| yytoken = YYTRANSLATE (yychar); ------------------ | | 648| 10.7k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 642| 10.7k|#define YYMAXUTOK 311 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 641| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (648:4): [True: 10.7k, False: 0] | | | Branch (648:18): [True: 10.7k, False: 0] | | ------------------ ------------------ 1556| 10.7k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1557| 10.7k| } 1558| | 1559| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1560| | detect an error, take that action. */ 1561| 11.9k| yyn += yytoken; 1562| 11.9k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 630| 11.9k|#define YYLAST 193 ------------------ | Branch (1562:7): [True: 0, False: 11.9k] | Branch (1562:18): [True: 611, False: 11.3k] | Branch (1562:34): [True: 8.91k, False: 2.44k] ------------------ 1563| 9.52k| goto yydefault; 1564| 2.44k| yyn = yytable[yyn]; 1565| 2.44k| if (yyn <= 0) ------------------ | Branch (1565:7): [True: 1.18k, False: 1.26k] ------------------ 1566| 1.18k| { 1567| 1.18k| if (yytable_value_is_error (yyn)) ------------------ | | 758| 1.18k| 0 | | ------------------ | | | Branch (758:3): [Folded - Ignored] | | ------------------ ------------------ 1568| 0| goto yyerrlab; 1569| 1.18k| yyn = -yyn; 1570| 1.18k| goto yyreduce; 1571| 1.18k| } 1572| | 1573| | /* Count tokens shifted since error; after three, turn off error 1574| | status. */ 1575| 1.26k| if (yyerrstatus) ------------------ | Branch (1575:7): [True: 168, False: 1.09k] ------------------ 1576| 168| yyerrstatus--; 1577| | 1578| | /* Shift the lookahead token. */ 1579| 1.26k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1580| 1.26k| yystate = yyn; 1581| 1.26k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1582| 1.26k| *++yyvsp = yylval; 1583| 1.26k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1584| | 1585| | /* Discard the shifted token. */ 1586| 1.26k| yychar = YYEMPTY; ------------------ | | 932| 1.26k|#define YYEMPTY (-2) ------------------ 1587| 1.26k| goto yynewstate; 1588| | 1589| | 1590| |/*-----------------------------------------------------------. 1591| || yydefault -- do the default action for the current state. | 1592| |`-----------------------------------------------------------*/ 1593| 21.5k|yydefault: 1594| 21.5k| yyn = yydefact[yystate]; 1595| 21.5k| if (yyn == 0) ------------------ | Branch (1595:7): [True: 9.52k, False: 12.0k] ------------------ 1596| 9.52k| goto yyerrlab; 1597| 12.0k| goto yyreduce; 1598| | 1599| | 1600| |/*-----------------------------. 1601| || yyreduce -- do a reduction. | 1602| |`-----------------------------*/ 1603| 13.2k|yyreduce: 1604| | /* yyn is the number of a rule to reduce with. */ 1605| 13.2k| yylen = yyr2[yyn]; 1606| | 1607| | /* If YYLEN is nonzero, implement the default value of the action: 1608| | '$$ = $1'. 1609| | 1610| | Otherwise, the following line sets YYVAL to garbage. 1611| | This behavior is undocumented and Bison 1612| | users should not rely upon it. Assigning to YYVAL 1613| | unconditionally makes the parser a bit smaller, and it avoids a 1614| | GCC warning that YYVAL may be used uninitialized. */ 1615| 13.2k| yyval = yyvsp[1-yylen]; 1616| | 1617| | 1618| 13.2k| YY_REDUCE_PRINT (yyn); 1619| 13.2k| switch (yyn) 1620| 13.2k| { 1621| 632| case 2: ------------------ | Branch (1621:3): [True: 632, False: 12.5k] ------------------ 1622| 632|#line 120 "parse.y" 1623| 632| { /* add default rule */ 1624| 632| int def_rule; 1625| | 1626| 632| pat = cclinit(); 1627| 632| cclnegate( pat ); 1628| | 1629| 632| def_rule = mkstate( -pat ); 1630| | 1631| | /* Remember the number of the default rule so we 1632| | * don't generate "can't match" warnings for it. 1633| | */ 1634| 632| default_rule = num_rules; 1635| | 1636| 632| finish_rule( def_rule, false, 0, 0, 0); 1637| | 1638| 1.26k| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1638:17): [True: 632, False: 632] ------------------ 1639| 632| scset[i] = mkbranch( scset[i], def_rule ); 1640| | 1641| 632| add_action("]]"); 1642| | 1643| 632| if ( ctrl.spprdflt ) ------------------ | Branch (1643:9): [True: 0, False: 632] ------------------ 1644| 0| add_action( 1645| 0| "M4_HOOK_FATAL_ERROR(\"flex scanner jammed\")"); 1646| 632| else { 1647| 632| add_action("M4_HOOK_ECHO"); 1648| 632| } 1649| | 1650| 632| add_action( "\n\tM4_HOOK_STATE_CASE_BREAK\n" ); 1651| 632| } 1652| 632|#line 1653 "parse.c" 1653| 632| break; 1654| | 1655| 632| case 3: ------------------ | Branch (1655:3): [True: 632, False: 12.5k] ------------------ 1656| 632|#line 152 "parse.y" 1657| 632| { /* initialize for processing rules */ 1658| | 1659| | /* Create default DFA start condition. */ 1660| 632| scinstal( "INITIAL", false ); 1661| 632| } 1662| 632|#line 1663 "parse.c" 1663| 632| break; 1664| | 1665| 9.52k| case 7: ------------------ | Branch (1665:3): [True: 9.52k, False: 3.70k] ------------------ 1666| 9.52k|#line 163 "parse.y" 1667| 9.52k| { synerr( _("unknown error processing section 1") ); } ------------------ | | 85| 9.52k|#define _(String) gettext (String) ------------------ 1668| 9.52k|#line 1669 "parse.c" 1669| 9.52k| break; 1670| | 1671| 632| case 8: ------------------ | Branch (1671:3): [True: 632, False: 12.5k] ------------------ 1672| 632|#line 167 "parse.y" 1673| 632| { 1674| 632| check_options(); 1675| 632| scon_stk = allocate_integer_array( lastsc + 1 ); ------------------ | | 704| 632| allocate_array(size, sizeof(int)) ------------------ 1676| 632| scon_stk_ptr = 0; 1677| 632| } 1678| 632|#line 1679 "parse.c" 1679| 632| break; 1680| | 1681| 0| case 9: ------------------ | Branch (1681:3): [True: 0, False: 13.2k] ------------------ 1682| 0|#line 175 "parse.y" 1683| 0| { xcluflg = false; } 1684| 0|#line 1685 "parse.c" 1685| 0| break; 1686| | 1687| 0| case 10: ------------------ | Branch (1687:3): [True: 0, False: 13.2k] ------------------ 1688| 0|#line 178 "parse.y" 1689| 0| { xcluflg = true; } 1690| 0|#line 1691 "parse.c" 1691| 0| break; 1692| | 1693| 0| case 11: ------------------ | Branch (1693:3): [True: 0, False: 13.2k] ------------------ 1694| 0|#line 182 "parse.y" 1695| 0| { scinstal( nmstr, xcluflg ); } 1696| 0|#line 1697 "parse.c" 1697| 0| break; 1698| | 1699| 0| case 12: ------------------ | Branch (1699:3): [True: 0, False: 13.2k] ------------------ 1700| 0|#line 185 "parse.y" 1701| 0| { scinstal( nmstr, xcluflg ); } 1702| 0|#line 1703 "parse.c" 1703| 0| break; 1704| | 1705| 0| case 13: ------------------ | Branch (1705:3): [True: 0, False: 13.2k] ------------------ 1706| 0|#line 188 "parse.y" 1707| 0| { synerr( _("bad start condition list") ); } ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 1708| 0|#line 1709 "parse.c" 1709| 0| break; 1710| | 1711| 0| case 17: ------------------ | Branch (1711:3): [True: 0, False: 13.2k] ------------------ 1712| 0|#line 199 "parse.y" 1713| 0| { 1714| 0| env.outfilename = xstrdup(nmstr); 1715| 0| env.did_outfilename = 1; 1716| 0| } 1717| 0|#line 1718 "parse.c" 1718| 0| break; 1719| | 1720| 0| case 18: ------------------ | Branch (1720:3): [True: 0, False: 13.2k] ------------------ 1721| 0|#line 204 "parse.y" 1722| 0| { extra_type = xstrdup(nmstr); } 1723| 0|#line 1724 "parse.c" 1724| 0| break; 1725| | 1726| 0| case 19: ------------------ | Branch (1726:3): [True: 0, False: 13.2k] ------------------ 1727| 0|#line 206 "parse.y" 1728| 0| { ctrl.prefix = xstrdup(nmstr); 1729| 0| if (strchr(ctrl.prefix, '[') || strchr(ctrl.prefix, ']')) ------------------ | Branch (1729:31): [True: 0, False: 0] | Branch (1729:59): [True: 0, False: 0] ------------------ 1730| 0| flexerror(_("Prefix must not contain [ or ]")); } ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 1731| 0|#line 1732 "parse.c" 1732| 0| break; 1733| | 1734| 0| case 20: ------------------ | Branch (1734:3): [True: 0, False: 13.2k] ------------------ 1735| 0|#line 210 "parse.y" 1736| 0| { ctrl.yyclass = xstrdup(nmstr); } 1737| 0|#line 1738 "parse.c" 1738| 0| break; 1739| | 1740| 0| case 21: ------------------ | Branch (1740:3): [True: 0, False: 13.2k] ------------------ 1741| 0|#line 212 "parse.y" 1742| 0| { env.headerfilename = xstrdup(nmstr); } 1743| 0|#line 1744 "parse.c" 1744| 0| break; 1745| | 1746| 0| case 22: ------------------ | Branch (1746:3): [True: 0, False: 13.2k] ------------------ 1747| 0|#line 214 "parse.y" 1748| 0| { ctrl.yylmax = nmval; } 1749| 0|#line 1750 "parse.c" 1750| 0| break; 1751| | 1752| 0| case 23: ------------------ | Branch (1752:3): [True: 0, False: 13.2k] ------------------ 1753| 0|#line 216 "parse.y" 1754| 0| { ctrl.yydecl = xstrdup(nmstr); } 1755| 0|#line 1756 "parse.c" 1756| 0| break; 1757| | 1758| 0| case 24: ------------------ | Branch (1758:3): [True: 0, False: 13.2k] ------------------ 1759| 0|#line 218 "parse.y" 1760| 0| { ctrl.preaction = xstrdup(nmstr); } 1761| 0|#line 1762 "parse.c" 1762| 0| break; 1763| | 1764| 0| case 25: ------------------ | Branch (1764:3): [True: 0, False: 13.2k] ------------------ 1765| 0|#line 220 "parse.y" 1766| 0| { ctrl.postaction = xstrdup(nmstr); } 1767| 0|#line 1768 "parse.c" 1768| 0| break; 1769| | 1770| 0| case 26: ------------------ | Branch (1770:3): [True: 0, False: 13.2k] ------------------ 1771| 0|#line 222 "parse.y" 1772| 0| { ctrl.bufsize = nmval; } 1773| 0|#line 1774 "parse.c" 1774| 0| break; 1775| | 1776| 0| case 27: ------------------ | Branch (1776:3): [True: 0, False: 13.2k] ------------------ 1777| 0|#line 224 "parse.y" 1778| 0| { ctrl.emit = xstrdup(nmstr); backend_by_name(ctrl.emit); } 1779| 0|#line 1780 "parse.c" 1780| 0| break; 1781| | 1782| 0| case 28: ------------------ | Branch (1782:3): [True: 0, False: 13.2k] ------------------ 1783| 0|#line 226 "parse.y" 1784| 0| { ctrl.userinit = xstrdup(nmstr); } 1785| 0|#line 1786 "parse.c" 1786| 0| break; 1787| | 1788| 0| case 29: ------------------ | Branch (1788:3): [True: 0, False: 13.2k] ------------------ 1789| 0|#line 228 "parse.y" 1790| 0| { ctrl.yyterminate = xstrdup(nmstr); } 1791| 0|#line 1792 "parse.c" 1792| 0| break; 1793| | 1794| 0| case 30: ------------------ | Branch (1794:3): [True: 0, False: 13.2k] ------------------ 1795| 0|#line 230 "parse.y" 1796| 0| { tablesext = true; tablesfilename = xstrdup(nmstr); } 1797| 0|#line 1798 "parse.c" 1798| 0| break; 1799| | 1800| 0| case 31: ------------------ | Branch (1800:3): [True: 0, False: 13.2k] ------------------ 1801| 0|#line 234 "parse.y" 1802| 0| { scon_stk_ptr = yyvsp[-3]; } 1803| 0|#line 1804 "parse.c" 1804| 0| break; 1805| | 1806| 0| case 32: ------------------ | Branch (1806:3): [True: 0, False: 13.2k] ------------------ 1807| 0|#line 236 "parse.y" 1808| 0| { scon_stk_ptr = yyvsp[-3]; } 1809| 0|#line 1810 "parse.c" 1810| 0| break; 1811| | 1812| 632| case 34: ------------------ | Branch (1812:3): [True: 632, False: 12.5k] ------------------ 1813| 632|#line 241 "parse.y" 1814| 632| { 1815| | /* Initialize for a parse of one rule. */ 1816| 632| trlcontxt = variable_trail_rule = varlength = false; 1817| 632| trailcnt = headcnt = rulelen = 0; 1818| 632| current_state_type = STATE_NORMAL; ------------------ | | 541| 632|#define STATE_NORMAL 0x1 ------------------ 1819| 632| previous_continued_action = continued_action; 1820| 632| in_rule = true; 1821| | 1822| 632| new_rule(); 1823| 632| } 1824| 632|#line 1825 "parse.c" 1825| 632| break; 1826| | 1827| 0| case 35: ------------------ | Branch (1827:3): [True: 0, False: 13.2k] ------------------ 1828| 0|#line 254 "parse.y" 1829| 0| { 1830| 0| pat = yyvsp[0]; 1831| 0| finish_rule( pat, variable_trail_rule, 1832| 0| headcnt, trailcnt , previous_continued_action); 1833| | 1834| 0| if ( scon_stk_ptr > 0 ) ------------------ | Branch (1834:9): [True: 0, False: 0] ------------------ 1835| 0| { 1836| 0| for ( i = 1; i <= scon_stk_ptr; ++i ) ------------------ | Branch (1836:18): [True: 0, False: 0] ------------------ 1837| 0| scbol[scon_stk[i]] = 1838| 0| mkbranch( scbol[scon_stk[i]], 1839| 0| pat ); 1840| 0| } 1841| | 1842| 0| else 1843| 0| { 1844| | /* Add to all non-exclusive start conditions, 1845| | * including the default (0) start condition. 1846| | */ 1847| | 1848| 0| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1848:18): [True: 0, False: 0] ------------------ 1849| 0| if ( ! scxclu[i] ) ------------------ | Branch (1849:11): [True: 0, False: 0] ------------------ 1850| 0| scbol[i] = mkbranch( scbol[i], 1851| 0| pat ); 1852| 0| } 1853| | 1854| 0| if ( ! bol_needed ) ------------------ | Branch (1854:9): [True: 0, False: 0] ------------------ 1855| 0| { 1856| 0| bol_needed = true; 1857| | 1858| 0| if ( env.performance_hint > 1 ) ------------------ | Branch (1858:10): [True: 0, False: 0] ------------------ 1859| 0| pinpoint_message( 1860| 0| "'^' operator results in sub-optimal performance" ); 1861| 0| } 1862| 0| } 1863| 0|#line 1864 "parse.c" 1864| 0| break; 1865| | 1866| 0| case 36: ------------------ | Branch (1866:3): [True: 0, False: 13.2k] ------------------ 1867| 0|#line 290 "parse.y" 1868| 0| { 1869| 0| pat = yyvsp[0]; 1870| 0| finish_rule( pat, variable_trail_rule, 1871| 0| headcnt, trailcnt , previous_continued_action); 1872| | 1873| 0| if ( scon_stk_ptr > 0 ) ------------------ | Branch (1873:9): [True: 0, False: 0] ------------------ 1874| 0| { 1875| 0| for ( i = 1; i <= scon_stk_ptr; ++i ) ------------------ | Branch (1875:18): [True: 0, False: 0] ------------------ 1876| 0| scset[scon_stk[i]] = 1877| 0| mkbranch( scset[scon_stk[i]], 1878| 0| pat ); 1879| 0| } 1880| | 1881| 0| else 1882| 0| { 1883| 0| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1883:18): [True: 0, False: 0] ------------------ 1884| 0| if ( ! scxclu[i] ) ------------------ | Branch (1884:11): [True: 0, False: 0] ------------------ 1885| 0| scset[i] = 1886| 0| mkbranch( scset[i], 1887| 0| pat ); 1888| 0| } 1889| 0| } 1890| 0|#line 1891 "parse.c" 1891| 0| break; 1892| | 1893| 0| case 37: ------------------ | Branch (1893:3): [True: 0, False: 13.2k] ------------------ 1894| 0|#line 314 "parse.y" 1895| 0| { 1896| 0| if ( scon_stk_ptr > 0 ) ------------------ | Branch (1896:9): [True: 0, False: 0] ------------------ 1897| 0| build_eof_action(); 1898| | 1899| 0| else 1900| 0| { 1901| | /* This EOF applies to all start conditions 1902| | * which don't already have EOF actions. 1903| | */ 1904| 0| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1904:18): [True: 0, False: 0] ------------------ 1905| 0| if ( ! sceof[i] ) ------------------ | Branch (1905:11): [True: 0, False: 0] ------------------ 1906| 0| scon_stk[++scon_stk_ptr] = i; 1907| | 1908| 0| if ( scon_stk_ptr == 0 ) ------------------ | Branch (1908:10): [True: 0, False: 0] ------------------ 1909| 0| lwarn( 1910| 0| "all start conditions already have <> rules" ); 1911| | 1912| 0| else 1913| 0| build_eof_action(); 1914| 0| } 1915| 0| } 1916| 0|#line 1917 "parse.c" 1917| 0| break; 1918| | 1919| 0| case 38: ------------------ | Branch (1919:3): [True: 0, False: 13.2k] ------------------ 1920| 0|#line 337 "parse.y" 1921| 0| { synerr( _("unrecognized rule") ); } ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 1922| 0|#line 1923 "parse.c" 1923| 0| break; 1924| | 1925| 0| case 39: ------------------ | Branch (1925:3): [True: 0, False: 13.2k] ------------------ 1926| 0|#line 341 "parse.y" 1927| 0| { yyval = scon_stk_ptr; } 1928| 0|#line 1929 "parse.c" 1929| 0| break; 1930| | 1931| 0| case 40: ------------------ | Branch (1931:3): [True: 0, False: 13.2k] ------------------ 1932| 0|#line 345 "parse.y" 1933| 0| { yyval = yyvsp[-2]; } 1934| 0|#line 1935 "parse.c" 1935| 0| break; 1936| | 1937| 0| case 41: ------------------ | Branch (1937:3): [True: 0, False: 13.2k] ------------------ 1938| 0|#line 348 "parse.y" 1939| 0| { 1940| 0| yyval = scon_stk_ptr; 1941| | 1942| 0| for ( i = 1; i <= lastsc; ++i ) ------------------ | Branch (1942:17): [True: 0, False: 0] ------------------ 1943| 0| { 1944| 0| int j; 1945| | 1946| 0| for ( j = 1; j <= scon_stk_ptr; ++j ) ------------------ | Branch (1946:18): [True: 0, False: 0] ------------------ 1947| 0| if ( scon_stk[j] == i ) ------------------ | Branch (1947:11): [True: 0, False: 0] ------------------ 1948| 0| break; 1949| | 1950| 0| if ( j > scon_stk_ptr ) ------------------ | Branch (1950:10): [True: 0, False: 0] ------------------ 1951| 0| scon_stk[++scon_stk_ptr] = i; 1952| 0| } 1953| 0| } 1954| 0|#line 1955 "parse.c" 1955| 0| break; 1956| | 1957| 0| case 42: ------------------ | Branch (1957:3): [True: 0, False: 13.2k] ------------------ 1958| 0|#line 365 "parse.y" 1959| 0| { yyval = scon_stk_ptr; } 1960| 0|#line 1961 "parse.c" 1961| 0| break; 1962| | 1963| 0| case 45: ------------------ | Branch (1963:3): [True: 0, False: 13.2k] ------------------ 1964| 0|#line 373 "parse.y" 1965| 0| { synerr( _("bad start condition list") ); } ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 1966| 0|#line 1967 "parse.c" 1967| 0| break; 1968| | 1969| 0| case 46: ------------------ | Branch (1969:3): [True: 0, False: 13.2k] ------------------ 1970| 0|#line 377 "parse.y" 1971| 0| { 1972| 0| if ( (scnum = sclookup( nmstr )) == 0 ) ------------------ | Branch (1972:9): [True: 0, False: 0] ------------------ 1973| 0| format_pinpoint_message( 1974| 0| "undeclared start condition %s", 1975| 0| nmstr ); 1976| 0| else 1977| 0| { 1978| 0| for ( i = 1; i <= scon_stk_ptr; ++i ) ------------------ | Branch (1978:18): [True: 0, False: 0] ------------------ 1979| 0| if ( scon_stk[i] == scnum ) ------------------ | Branch (1979:11): [True: 0, False: 0] ------------------ 1980| 0| { 1981| 0| format_warn( 1982| 0| "<%s> specified twice", 1983| 0| scname[scnum] ); 1984| 0| break; 1985| 0| } 1986| | 1987| 0| if ( i > scon_stk_ptr ) ------------------ | Branch (1987:10): [True: 0, False: 0] ------------------ 1988| 0| scon_stk[++scon_stk_ptr] = scnum; 1989| 0| } 1990| 0| } 1991| 0|#line 1992 "parse.c" 1992| 0| break; 1993| | 1994| 0| case 47: ------------------ | Branch (1994:3): [True: 0, False: 13.2k] ------------------ 1995| 0|#line 400 "parse.y" 1996| 0| { 1997| 0| if ( transchar[lastst[yyvsp[0]]] != SYM_EPSILON ) ------------------ | | 219| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 0|#define CSIZE 256 | | ------------------ ------------------ | Branch (1997:9): [True: 0, False: 0] ------------------ 1998| | /* Provide final transition \now/ so it 1999| | * will be marked as a trailing context 2000| | * state. 2001| | */ 2002| 0| yyvsp[0] = link_machines( yyvsp[0], 2003| 0| mkstate( SYM_EPSILON ) ); ------------------ | | 219| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 0|#define CSIZE 256 | | ------------------ ------------------ 2004| | 2005| 0| mark_beginning_as_normal( yyvsp[0] ); 2006| 0| current_state_type = STATE_NORMAL; ------------------ | | 541| 0|#define STATE_NORMAL 0x1 ------------------ 2007| | 2008| 0| if ( previous_continued_action ) ------------------ | Branch (2008:9): [True: 0, False: 0] ------------------ 2009| 0| { 2010| | /* We need to treat this as variable trailing 2011| | * context so that the backup does not happen 2012| | * in the action but before the action switch 2013| | * statement. If the backup happens in the 2014| | * action, then the rules "falling into" this 2015| | * one's action will *also* do the backup, 2016| | * erroneously. 2017| | */ 2018| 0| if ( ! varlength || headcnt != 0 ) ------------------ | Branch (2018:10): [True: 0, False: 0] | Branch (2018:25): [True: 0, False: 0] ------------------ 2019| 0| lwarn( 2020| 0| "trailing context made variable due to preceding '|' action" ); 2021| | 2022| | /* Mark as variable. */ 2023| 0| varlength = true; 2024| 0| headcnt = 0; 2025| | 2026| 0| } 2027| | 2028| 0| if ( ctrl.lex_compat || (varlength && headcnt == 0) ) ------------------ | Branch (2028:9): [True: 0, False: 0] | Branch (2028:29): [True: 0, False: 0] | Branch (2028:42): [True: 0, False: 0] ------------------ 2029| 0| { /* variable trailing context rule */ 2030| | /* Mark the first part of the rule as the 2031| | * accepting "head" part of a trailing 2032| | * context rule. 2033| | * 2034| | * By the way, we didn't do this at the 2035| | * beginning of this production because back 2036| | * then current_state_type was set up for a 2037| | * trail rule, and add_accept() can create 2038| | * a new state ... 2039| | */ 2040| 0| add_accept( yyvsp[-1], 2041| 0| num_rules | YY_TRAILING_HEAD_MASK ); ------------------ | | 168| 0|#define YY_TRAILING_HEAD_MASK 0x4000 ------------------ 2042| 0| variable_trail_rule = true; 2043| 0| } 2044| | 2045| 0| else 2046| 0| trailcnt = rulelen; 2047| | 2048| 0| yyval = link_machines( yyvsp[-1], yyvsp[0] ); 2049| 0| } 2050| 0|#line 2051 "parse.c" 2051| 0| break; 2052| | 2053| 0| case 48: ------------------ | Branch (2053:3): [True: 0, False: 13.2k] ------------------ 2054| 0|#line 456 "parse.y" 2055| 0| { synerr( _("trailing context used twice") ); } ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2056| 0|#line 2057 "parse.c" 2057| 0| break; 2058| | 2059| 0| case 49: ------------------ | Branch (2059:3): [True: 0, False: 13.2k] ------------------ 2060| 0|#line 459 "parse.y" 2061| 0| { 2062| 0| headcnt = 0; 2063| 0| trailcnt = 1; 2064| 0| rulelen = 1; 2065| 0| varlength = false; 2066| | 2067| 0| current_state_type = STATE_TRAILING_CONTEXT; ------------------ | | 542| 0|#define STATE_TRAILING_CONTEXT 0x2 ------------------ 2068| | 2069| 0| if ( trlcontxt ) ------------------ | Branch (2069:9): [True: 0, False: 0] ------------------ 2070| 0| { 2071| 0| synerr( _("trailing context used twice") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2072| 0| yyval = mkstate( SYM_EPSILON ); ------------------ | | 219| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 0|#define CSIZE 256 | | ------------------ ------------------ 2073| 0| } 2074| | 2075| 0| else if ( previous_continued_action ) ------------------ | Branch (2075:14): [True: 0, False: 0] ------------------ 2076| 0| { 2077| | /* See the comment in the rule for "re2 re" 2078| | * above. 2079| | */ 2080| 0| lwarn( 2081| 0| "trailing context made variable due to preceding '|' action" ); 2082| | 2083| 0| varlength = true; 2084| 0| } 2085| | 2086| 0| if ( ctrl.lex_compat || varlength ) ------------------ | Branch (2086:9): [True: 0, False: 0] | Branch (2086:28): [True: 0, False: 0] ------------------ 2087| 0| { 2088| | /* Again, see the comment in the rule for 2089| | * "re2 re" above. 2090| | */ 2091| 0| add_accept( yyvsp[-1], 2092| 0| num_rules | YY_TRAILING_HEAD_MASK ); ------------------ | | 168| 0|#define YY_TRAILING_HEAD_MASK 0x4000 ------------------ 2093| 0| variable_trail_rule = true; 2094| 0| } 2095| | 2096| 0| trlcontxt = true; 2097| | 2098| 0| eps = mkstate( SYM_EPSILON ); ------------------ | | 219| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 0|#define CSIZE 256 | | ------------------ ------------------ 2099| 0| yyval = link_machines( yyvsp[-1], 2100| 0| link_machines( eps, mkstate( '\n' ) ) ); 2101| 0| } 2102| 0|#line 2103 "parse.c" 2103| 0| break; 2104| | 2105| 0| case 50: ------------------ | Branch (2105:3): [True: 0, False: 13.2k] ------------------ 2106| 0|#line 502 "parse.y" 2107| 0| { 2108| 0| yyval = yyvsp[0]; 2109| | 2110| 0| if ( trlcontxt ) ------------------ | Branch (2110:9): [True: 0, False: 0] ------------------ 2111| 0| { 2112| 0| if ( ctrl.lex_compat || (varlength && headcnt == 0) ) ------------------ | Branch (2112:10): [True: 0, False: 0] | Branch (2112:30): [True: 0, False: 0] | Branch (2112:43): [True: 0, False: 0] ------------------ 2113| | /* Both head and trail are 2114| | * variable-length. 2115| | */ 2116| 0| variable_trail_rule = true; 2117| 0| else 2118| 0| trailcnt = rulelen; 2119| 0| } 2120| 0| } 2121| 0|#line 2122 "parse.c" 2122| 0| break; 2123| | 2124| 0| case 51: ------------------ | Branch (2124:3): [True: 0, False: 13.2k] ------------------ 2125| 0|#line 520 "parse.y" 2126| 0| { 2127| 0| varlength = true; 2128| 0| yyval = mkor( yyvsp[-2], yyvsp[0] ); 2129| 0| } 2130| 0|#line 2131 "parse.c" 2131| 0| break; 2132| | 2133| 0| case 52: ------------------ | Branch (2133:3): [True: 0, False: 13.2k] ------------------ 2134| 0|#line 526 "parse.y" 2135| 0| { yyval = yyvsp[0]; } 2136| 0|#line 2137 "parse.c" 2137| 0| break; 2138| | 2139| 0| case 53: ------------------ | Branch (2139:3): [True: 0, False: 13.2k] ------------------ 2140| 0|#line 531 "parse.y" 2141| 0| { 2142| | /* This rule is written separately so the 2143| | * reduction will occur before the trailing 2144| | * series is parsed. 2145| | */ 2146| | 2147| 0| if ( trlcontxt ) ------------------ | Branch (2147:9): [True: 0, False: 0] ------------------ 2148| 0| synerr( _("trailing context used twice") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2149| 0| else 2150| 0| trlcontxt = true; 2151| | 2152| 0| if ( varlength ) ------------------ | Branch (2152:9): [True: 0, False: 0] ------------------ 2153| | /* We hope the trailing context is 2154| | * fixed-length. 2155| | */ 2156| 0| varlength = false; 2157| 0| else 2158| 0| headcnt = rulelen; 2159| | 2160| 0| rulelen = 0; 2161| | 2162| 0| current_state_type = STATE_TRAILING_CONTEXT; ------------------ | | 542| 0|#define STATE_TRAILING_CONTEXT 0x2 ------------------ 2163| 0| yyval = yyvsp[-1]; 2164| 0| } 2165| 0|#line 2166 "parse.c" 2166| 0| break; 2167| | 2168| 0| case 54: ------------------ | Branch (2168:3): [True: 0, False: 13.2k] ------------------ 2169| 0|#line 558 "parse.y" 2170| 0| { 2171| | /* This is where concatenation of adjacent patterns 2172| | * gets done. 2173| | */ 2174| 0| yyval = link_machines( yyvsp[-1], yyvsp[0] ); 2175| 0| } 2176| 0|#line 2177 "parse.c" 2177| 0| break; 2178| | 2179| 0| case 55: ------------------ | Branch (2179:3): [True: 0, False: 13.2k] ------------------ 2180| 0|#line 566 "parse.y" 2181| 0| { yyval = yyvsp[0]; } 2182| 0|#line 2183 "parse.c" 2183| 0| break; 2184| | 2185| 0| case 56: ------------------ | Branch (2185:3): [True: 0, False: 13.2k] ------------------ 2186| 0|#line 569 "parse.y" 2187| 0| { 2188| 0| varlength = true; 2189| | 2190| 0| if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 ) ------------------ | Branch (2190:9): [True: 0, False: 0] | Branch (2190:34): [True: 0, False: 0] ------------------ 2191| 0| { 2192| 0| synerr( _("bad iteration values") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2193| 0| yyval = yyvsp[-5]; 2194| 0| } 2195| 0| else 2196| 0| { 2197| 0| if ( yyvsp[-3] == 0 ) ------------------ | Branch (2197:10): [True: 0, False: 0] ------------------ 2198| 0| { 2199| 0| if ( yyvsp[-1] <= 0 ) ------------------ | Branch (2199:11): [True: 0, False: 0] ------------------ 2200| 0| { 2201| 0| synerr( 2202| 0| _("bad iteration values") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2203| 0| yyval = yyvsp[-5]; 2204| 0| } 2205| 0| else 2206| 0| yyval = mkopt( 2207| 0| mkrep( yyvsp[-5], 1, yyvsp[-1] ) ); 2208| 0| } 2209| 0| else 2210| 0| yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] ); 2211| 0| } 2212| 0| } 2213| 0|#line 2214 "parse.c" 2214| 0| break; 2215| | 2216| 0| case 57: ------------------ | Branch (2216:3): [True: 0, False: 13.2k] ------------------ 2217| 0|#line 597 "parse.y" 2218| 0| { 2219| 0| varlength = true; 2220| | 2221| 0| if ( yyvsp[-2] <= 0 ) ------------------ | Branch (2221:9): [True: 0, False: 0] ------------------ 2222| 0| { 2223| 0| synerr( _("iteration value must be positive") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2224| 0| yyval = yyvsp[-4]; 2225| 0| } 2226| | 2227| 0| else 2228| 0| yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITE_REPEAT ); ------------------ | | 182| 0|#define INFINITE_REPEAT -1 /* for x{5,} constructions */ ------------------ 2229| 0| } 2230| 0|#line 2231 "parse.c" 2231| 0| break; 2232| | 2233| 0| case 58: ------------------ | Branch (2233:3): [True: 0, False: 13.2k] ------------------ 2234| 0|#line 611 "parse.y" 2235| 0| { 2236| | /* The series could be something like "(foo)", 2237| | * in which case we have no idea what its length 2238| | * is, so we punt here. 2239| | */ 2240| 0| varlength = true; 2241| | 2242| 0| if ( yyvsp[-1] <= 0 ) ------------------ | Branch (2242:9): [True: 0, False: 0] ------------------ 2243| 0| { 2244| 0| synerr( _("iteration value must be positive") ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2245| 0| ); 2246| 0| yyval = yyvsp[-3]; 2247| 0| } 2248| | 2249| 0| else 2250| 0| yyval = link_machines( yyvsp[-3], 2251| 0| copysingl( yyvsp[-3], yyvsp[-1] - 1 ) ); 2252| 0| } 2253| 0|#line 2254 "parse.c" 2254| 0| break; 2255| | 2256| 0| case 59: ------------------ | Branch (2256:3): [True: 0, False: 13.2k] ------------------ 2257| 0|#line 633 "parse.y" 2258| 0| { 2259| 0| varlength = true; 2260| | 2261| 0| yyval = mkclos( yyvsp[-1] ); 2262| 0| } 2263| 0|#line 2264 "parse.c" 2264| 0| break; 2265| | 2266| 0| case 60: ------------------ | Branch (2266:3): [True: 0, False: 13.2k] ------------------ 2267| 0|#line 640 "parse.y" 2268| 0| { 2269| 0| varlength = true; 2270| 0| yyval = mkposcl( yyvsp[-1] ); 2271| 0| } 2272| 0|#line 2273 "parse.c" 2273| 0| break; 2274| | 2275| 0| case 61: ------------------ | Branch (2275:3): [True: 0, False: 13.2k] ------------------ 2276| 0|#line 646 "parse.y" 2277| 0| { 2278| 0| varlength = true; 2279| 0| yyval = mkopt( yyvsp[-1] ); 2280| 0| } 2281| 0|#line 2282 "parse.c" 2282| 0| break; 2283| | 2284| 0| case 62: ------------------ | Branch (2284:3): [True: 0, False: 13.2k] ------------------ 2285| 0|#line 652 "parse.y" 2286| 0| { 2287| 0| varlength = true; 2288| | 2289| 0| if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 ) ------------------ | Branch (2289:9): [True: 0, False: 0] | Branch (2289:34): [True: 0, False: 0] ------------------ 2290| 0| { 2291| 0| synerr( _("bad iteration values") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2292| 0| yyval = yyvsp[-5]; 2293| 0| } 2294| 0| else 2295| 0| { 2296| 0| if ( yyvsp[-3] == 0 ) ------------------ | Branch (2296:10): [True: 0, False: 0] ------------------ 2297| 0| { 2298| 0| if ( yyvsp[-1] <= 0 ) ------------------ | Branch (2298:11): [True: 0, False: 0] ------------------ 2299| 0| { 2300| 0| synerr( 2301| 0| _("bad iteration values") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2302| 0| yyval = yyvsp[-5]; 2303| 0| } 2304| 0| else 2305| 0| yyval = mkopt( 2306| 0| mkrep( yyvsp[-5], 1, yyvsp[-1] ) ); 2307| 0| } 2308| 0| else 2309| 0| yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] ); 2310| 0| } 2311| 0| } 2312| 0|#line 2313 "parse.c" 2313| 0| break; 2314| | 2315| 0| case 63: ------------------ | Branch (2315:3): [True: 0, False: 13.2k] ------------------ 2316| 0|#line 680 "parse.y" 2317| 0| { 2318| 0| varlength = true; 2319| | 2320| 0| if ( yyvsp[-2] <= 0 ) ------------------ | Branch (2320:9): [True: 0, False: 0] ------------------ 2321| 0| { 2322| 0| synerr( _("iteration value must be positive") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2323| 0| yyval = yyvsp[-4]; 2324| 0| } 2325| | 2326| 0| else 2327| 0| yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITE_REPEAT ); ------------------ | | 182| 0|#define INFINITE_REPEAT -1 /* for x{5,} constructions */ ------------------ 2328| 0| } 2329| 0|#line 2330 "parse.c" 2330| 0| break; 2331| | 2332| 0| case 64: ------------------ | Branch (2332:3): [True: 0, False: 13.2k] ------------------ 2333| 0|#line 694 "parse.y" 2334| 0| { 2335| | /* The singleton could be something like "(foo)", 2336| | * in which case we have no idea what its length 2337| | * is, so we punt here. 2338| | */ 2339| 0| varlength = true; 2340| | 2341| 0| if ( yyvsp[-1] <= 0 ) ------------------ | Branch (2341:9): [True: 0, False: 0] ------------------ 2342| 0| { 2343| 0| synerr( _("iteration value must be positive") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2344| 0| yyval = yyvsp[-3]; 2345| 0| } 2346| | 2347| 0| else 2348| 0| yyval = link_machines( yyvsp[-3], 2349| 0| copysingl( yyvsp[-3], yyvsp[-1] - 1 ) ); 2350| 0| } 2351| 0|#line 2352 "parse.c" 2352| 0| break; 2353| | 2354| 0| case 65: ------------------ | Branch (2354:3): [True: 0, False: 13.2k] ------------------ 2355| 0|#line 713 "parse.y" 2356| 0| { 2357| 0| if ( ! madeany ) ------------------ | Branch (2357:9): [True: 0, False: 0] ------------------ 2358| 0| { 2359| | /* Create the '.' character class. */ 2360| 0| ccldot = cclinit(); 2361| 0| ccladd( ccldot, '\n' ); 2362| 0| cclnegate( ccldot ); 2363| | 2364| 0| if ( ctrl.useecs ) ------------------ | Branch (2364:26): [True: 0, False: 0] ------------------ 2365| 0| mkeccl( ccltbl + cclmap[ccldot], 2366| 0| ccllen[ccldot], nextecm, 2367| 0| ecgroup, ctrl.csize, ctrl.csize ); 2368| | 2369| | /* Create the (?s:'.') character class. */ 2370| 0| cclany = cclinit(); 2371| 0| cclnegate( cclany ); 2372| | 2373| 0| if ( ctrl.useecs ) ------------------ | Branch (2373:26): [True: 0, False: 0] ------------------ 2374| 0| mkeccl( ccltbl + cclmap[cclany], 2375| 0| ccllen[cclany], nextecm, 2376| 0| ecgroup, ctrl.csize, ctrl.csize ); 2377| | 2378| 0| madeany = true; 2379| 0| } 2380| | 2381| 0| ++rulelen; 2382| | 2383| 0| if (sf_dot_all()) ------------------ | | 1206| 0|#define sf_dot_all() (sf_top() & _SF_DOT_ALL) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_dot_all() (sf_top() & _SF_DOT_ALL) | | ------------------ | | | | 1202| 0|#define _SF_DOT_ALL ((scanflags_t) 0x0002) | | ------------------ | | | Branch (1206:28): [True: 0, False: 0] | | ------------------ ------------------ 2384| 0| yyval = mkstate( -cclany ); 2385| 0| else 2386| 0| yyval = mkstate( -ccldot ); 2387| 0| } 2388| 0|#line 2389 "parse.c" 2389| 0| break; 2390| | 2391| 0| case 66: ------------------ | Branch (2391:3): [True: 0, False: 13.2k] ------------------ 2392| 0|#line 747 "parse.y" 2393| 0| { 2394| | /* Sort characters for fast searching. 2395| | */ 2396| 0| qsort( ccltbl + cclmap[yyvsp[0]], (size_t) ccllen[yyvsp[0]], sizeof (*ccltbl), cclcmp ); 2397| | 2398| 0| if ( ctrl.useecs ) ------------------ | Branch (2398:9): [True: 0, False: 0] ------------------ 2399| 0| mkeccl( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], 2400| 0| nextecm, ecgroup, ctrl.csize, ctrl.csize); 2401| | 2402| 0| ++rulelen; 2403| | 2404| 0| if (ccl_has_nl[yyvsp[0]]) ------------------ | Branch (2404:8): [True: 0, False: 0] ------------------ 2405| 0| rule_has_nl[num_rules] = true; 2406| | 2407| 0| yyval = mkstate( -yyvsp[0] ); 2408| 0| } 2409| 0|#line 2410 "parse.c" 2410| 0| break; 2411| | 2412| 0| case 67: ------------------ | Branch (2412:3): [True: 0, False: 13.2k] ------------------ 2413| 0|#line 765 "parse.y" 2414| 0| { 2415| 0| ++rulelen; 2416| | 2417| 0| if (ccl_has_nl[yyvsp[0]]) ------------------ | Branch (2417:8): [True: 0, False: 0] ------------------ 2418| 0| rule_has_nl[num_rules] = true; 2419| | 2420| 0| yyval = mkstate( -yyvsp[0] ); 2421| 0| } 2422| 0|#line 2423 "parse.c" 2423| 0| break; 2424| | 2425| 0| case 68: ------------------ | Branch (2425:3): [True: 0, False: 13.2k] ------------------ 2426| 0|#line 775 "parse.y" 2427| 0| { yyval = yyvsp[-1]; } 2428| 0|#line 2429 "parse.c" 2429| 0| break; 2430| | 2431| 0| case 69: ------------------ | Branch (2431:3): [True: 0, False: 13.2k] ------------------ 2432| 0|#line 778 "parse.y" 2433| 0| { yyval = yyvsp[-1]; } 2434| 0|#line 2435 "parse.c" 2435| 0| break; 2436| | 2437| 0| case 70: ------------------ | Branch (2437:3): [True: 0, False: 13.2k] ------------------ 2438| 0|#line 781 "parse.y" 2439| 0| { 2440| 0| ++rulelen; 2441| | 2442| 0| if (yyvsp[0] == nlch) ------------------ | Branch (2442:8): [True: 0, False: 0] ------------------ 2443| 0| rule_has_nl[num_rules] = true; 2444| | 2445| 0| if (sf_case_ins() && has_case(yyvsp[0])) ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2445:34): [True: 0, False: 0] ------------------ 2446| | /* create an alternation, as in (a|A) */ 2447| 0| yyval = mkor (mkstate(yyvsp[0]), mkstate(reverse_case(yyvsp[0]))); 2448| 0| else 2449| 0| yyval = mkstate( yyvsp[0] ); 2450| 0| } 2451| 0|#line 2452 "parse.c" 2452| 0| break; 2453| | 2454| 0| case 71: ------------------ | Branch (2454:3): [True: 0, False: 13.2k] ------------------ 2455| 0|#line 795 "parse.y" 2456| 0| { yyval = ccl_set_diff (yyvsp[-2], yyvsp[0]); } 2457| 0|#line 2458 "parse.c" 2458| 0| break; 2459| | 2460| 0| case 72: ------------------ | Branch (2460:3): [True: 0, False: 13.2k] ------------------ 2461| 0|#line 796 "parse.y" 2462| 0| { yyval = ccl_set_union (yyvsp[-2], yyvsp[0]); } 2463| 0|#line 2464 "parse.c" 2464| 0| break; 2465| | 2466| 0| case 74: ------------------ | Branch (2466:3): [True: 0, False: 13.2k] ------------------ 2467| 0|#line 802 "parse.y" 2468| 0| { yyval = yyvsp[-1]; } 2469| 0|#line 2470 "parse.c" 2470| 0| break; 2471| | 2472| 0| case 75: ------------------ | Branch (2472:3): [True: 0, False: 13.2k] ------------------ 2473| 0|#line 805 "parse.y" 2474| 0| { 2475| 0| cclnegate( yyvsp[-1] ); 2476| 0| yyval = yyvsp[-1]; 2477| 0| } 2478| 0|#line 2479 "parse.c" 2479| 0| break; 2480| | 2481| 0| case 76: ------------------ | Branch (2481:3): [True: 0, False: 13.2k] ------------------ 2482| 0|#line 812 "parse.y" 2483| 0| { 2484| | 2485| 0| if (sf_case_ins()) ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ 2486| 0| { 2487| | 2488| | /* If one end of the range has case and the other 2489| | * does not, or the cases are different, then we're not 2490| | * sure what range the user is trying to express. 2491| | * Examples: [@-z] or [S-t] 2492| | */ 2493| 0| if (has_case (yyvsp[-2]) != has_case (yyvsp[0]) ------------------ | Branch (2493:12): [True: 0, False: 0] ------------------ 2494| 0| || (has_case (yyvsp[-2]) && (b_islower (yyvsp[-2]) != b_islower (yyvsp[0]))) ------------------ | | 1140| 0|#define b_islower(c) (islower(c)?true:false) ------------------ || (has_case (yyvsp[-2]) && (b_islower (yyvsp[-2]) != b_islower (yyvsp[0]))) ------------------ | | 1140| 0|#define b_islower(c) (islower(c)?true:false) ------------------ | Branch (2494:14): [True: 0, False: 0] | Branch (2494:38): [True: 0, False: 0] ------------------ 2495| 0| || (has_case (yyvsp[-2]) && (b_isupper (yyvsp[-2]) != b_isupper (yyvsp[0])))) ------------------ | | 1144| 0|#define b_isupper(c) (isupper(c)?true:false) ------------------ || (has_case (yyvsp[-2]) && (b_isupper (yyvsp[-2]) != b_isupper (yyvsp[0])))) ------------------ | | 1144| 0|#define b_isupper(c) (isupper(c)?true:false) ------------------ | Branch (2495:14): [True: 0, False: 0] | Branch (2495:38): [True: 0, False: 0] ------------------ 2496| 0| format_warn3 ( ------------------ | | 116| 0| do{ \ | | 117| 0| char fw3_msg[MAXLINE];\ | | 118| 0| snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\ | | ------------------ | | | | 99| 0|#define MAXLINE 2048 | | ------------------ | | 119| 0| lwarn( fw3_msg );\ | | 120| 0| }while(0) | | ------------------ | | | Branch (120:9): [Folded - Ignored] | | ------------------ ------------------ 2497| 0| _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"), 2498| 0| yyvsp[-2], yyvsp[0]); 2499| | 2500| | /* If the range spans uppercase characters but not 2501| | * lowercase (or vice-versa), then should we automatically 2502| | * include lowercase characters in the range? 2503| | * Example: [@-_] spans [a-z] but not [A-Z] 2504| | */ 2505| 0| else if (!has_case (yyvsp[-2]) && !has_case (yyvsp[0]) && !range_covers_case (yyvsp[-2], yyvsp[0])) ------------------ | Branch (2505:17): [True: 0, False: 0] | Branch (2505:42): [True: 0, False: 0] | Branch (2505:66): [True: 0, False: 0] ------------------ 2506| 0| format_warn3 ( ------------------ | | 116| 0| do{ \ | | 117| 0| char fw3_msg[MAXLINE];\ | | 118| 0| snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\ | | ------------------ | | | | 99| 0|#define MAXLINE 2048 | | ------------------ | | 119| 0| lwarn( fw3_msg );\ | | 120| 0| }while(0) | | ------------------ | | | Branch (120:9): [Folded - Ignored] | | ------------------ ------------------ 2507| 0| _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"), 2508| 0| yyvsp[-2], yyvsp[0]); 2509| 0| } 2510| | 2511| 0| if ( yyvsp[-2] > yyvsp[0] ) ------------------ | Branch (2511:9): [True: 0, False: 0] ------------------ 2512| 0| synerr( _("negative range in character class") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2513| | 2514| 0| else 2515| 0| { 2516| 0| for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i ) ------------------ | Branch (2516:26): [True: 0, False: 0] ------------------ 2517| 0| ccladd( yyvsp[-3], i ); 2518| | 2519| | /* Keep track if this ccl is staying in 2520| | * alphabetical order. 2521| | */ 2522| 0| cclsorted = cclsorted && (yyvsp[-2] > lastchar); ------------------ | Branch (2522:17): [True: 0, False: 0] | Branch (2522:30): [True: 0, False: 0] ------------------ 2523| 0| lastchar = yyvsp[0]; 2524| | 2525| | /* Do it again for upper/lowercase */ 2526| 0| if (sf_case_ins() && has_case(yyvsp[-2]) && has_case(yyvsp[0])){ ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2526:38): [True: 0, False: 0] | Branch (2526:61): [True: 0, False: 0] ------------------ 2527| 0| yyvsp[-2] = reverse_case (yyvsp[-2]); 2528| 0| yyvsp[0] = reverse_case (yyvsp[0]); 2529| | 2530| 0| for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i ) ------------------ | Branch (2530:42): [True: 0, False: 0] ------------------ 2531| 0| ccladd( yyvsp[-3], i ); 2532| | 2533| 0| cclsorted = cclsorted && (yyvsp[-2] > lastchar); ------------------ | Branch (2533:33): [True: 0, False: 0] | Branch (2533:46): [True: 0, False: 0] ------------------ 2534| 0| lastchar = yyvsp[0]; 2535| 0| } 2536| | 2537| 0| } 2538| | 2539| 0| yyval = yyvsp[-3]; 2540| 0| } 2541| 0|#line 2542 "parse.c" 2542| 0| break; 2543| | 2544| 0| case 77: ------------------ | Branch (2544:3): [True: 0, False: 13.2k] ------------------ 2545| 0|#line 872 "parse.y" 2546| 0| { 2547| 0| ccladd( yyvsp[-1], yyvsp[0] ); 2548| 0| cclsorted = cclsorted && (yyvsp[0] > lastchar); ------------------ | Branch (2548:16): [True: 0, False: 0] | Branch (2548:29): [True: 0, False: 0] ------------------ 2549| 0| lastchar = yyvsp[0]; 2550| | 2551| | /* Do it again for upper/lowercase */ 2552| 0| if (sf_case_ins() && has_case(yyvsp[0])){ ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2552:34): [True: 0, False: 0] ------------------ 2553| 0| yyvsp[0] = reverse_case (yyvsp[0]); 2554| 0| ccladd (yyvsp[-1], yyvsp[0]); 2555| | 2556| 0| cclsorted = cclsorted && (yyvsp[0] > lastchar); ------------------ | Branch (2556:29): [True: 0, False: 0] | Branch (2556:42): [True: 0, False: 0] ------------------ 2557| 0| lastchar = yyvsp[0]; 2558| 0| } 2559| | 2560| 0| yyval = yyvsp[-1]; 2561| 0| } 2562| 0|#line 2563 "parse.c" 2563| 0| break; 2564| | 2565| 0| case 78: ------------------ | Branch (2565:3): [True: 0, False: 13.2k] ------------------ 2566| 0|#line 890 "parse.y" 2567| 0| { 2568| | /* Too hard to properly maintain cclsorted. */ 2569| 0| cclsorted = false; 2570| 0| yyval = yyvsp[-1]; 2571| 0| } 2572| 0|#line 2573 "parse.c" 2573| 0| break; 2574| | 2575| 0| case 79: ------------------ | Branch (2575:3): [True: 0, False: 13.2k] ------------------ 2576| 0|#line 897 "parse.y" 2577| 0| { 2578| 0| cclsorted = true; 2579| 0| lastchar = 0; 2580| 0| currccl = yyval = cclinit(); 2581| 0| } 2582| 0|#line 2583 "parse.c" 2583| 0| break; 2584| | 2585| 0| case 80: ------------------ | Branch (2585:3): [True: 0, False: 13.2k] ------------------ 2586| 0|#line 905 "parse.y" 2587| 0| { CCL_EXPR(isalnum); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2587| 0| { CCL_EXPR(isalnum); } | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2588| 0|#line 2589 "parse.c" 2589| 0| break; 2590| | 2591| 0| case 81: ------------------ | Branch (2591:3): [True: 0, False: 13.2k] ------------------ 2592| 0|#line 906 "parse.y" 2593| 0| { CCL_EXPR(isalpha); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2593| 0| { CCL_EXPR(isalpha); } | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2594| 0|#line 2595 "parse.c" 2595| 0| break; 2596| | 2597| 0| case 82: ------------------ | Branch (2597:3): [True: 0, False: 13.2k] ------------------ 2598| 0|#line 907 "parse.y" 2599| 0| { CCL_EXPR(IS_BLANK); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2599| 0| { CCL_EXPR(IS_BLANK); } | | | | ------------------ | | | | | | 141| 0|#define IS_BLANK(c) ((c) == ' ' || (c) == '\t') | | | | | | ------------------ | | | | | | | Branch (141:22): [True: 0, False: 0] | | | | | | | Branch (141:36): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2600| 0|#line 2601 "parse.c" 2601| 0| break; 2602| | 2603| 0| case 83: ------------------ | Branch (2603:3): [True: 0, False: 13.2k] ------------------ 2604| 0|#line 908 "parse.y" 2605| 0| { CCL_EXPR(iscntrl); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2605| 0| { CCL_EXPR(iscntrl); } | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2606| 0|#line 2607 "parse.c" 2607| 0| break; 2608| | 2609| 0| case 84: ------------------ | Branch (2609:3): [True: 0, False: 13.2k] ------------------ 2610| 0|#line 909 "parse.y" 2611| 0| { CCL_EXPR(isdigit); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2611| 0| { CCL_EXPR(isdigit); } | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2612| 0|#line 2613 "parse.c" 2613| 0| break; 2614| | 2615| 0| case 85: ------------------ | Branch (2615:3): [True: 0, False: 13.2k] ------------------ 2616| 0|#line 910 "parse.y" 2617| 0| { CCL_EXPR(isgraph); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2617| 0| { CCL_EXPR(isgraph); } | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2618| 0|#line 2619 "parse.c" 2619| 0| break; 2620| | 2621| 0| case 86: ------------------ | Branch (2621:3): [True: 0, False: 13.2k] ------------------ 2622| 0|#line 911 "parse.y" 2623| 0| { 2624| 0| CCL_EXPR(islower); ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2624| 0| CCL_EXPR(islower); | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2625| 0| if (sf_case_ins()) ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ 2626| 0| CCL_EXPR(isupper); ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2626| 0| CCL_EXPR(isupper); | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2627| 0| } 2628| 0|#line 2629 "parse.c" 2629| 0| break; 2630| | 2631| 0| case 87: ------------------ | Branch (2631:3): [True: 0, False: 13.2k] ------------------ 2632| 0|#line 916 "parse.y" 2633| 0| { CCL_EXPR(isprint); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2633| 0| { CCL_EXPR(isprint); } | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2634| 0|#line 2635 "parse.c" 2635| 0| break; 2636| | 2637| 0| case 88: ------------------ | Branch (2637:3): [True: 0, False: 13.2k] ------------------ 2638| 0|#line 917 "parse.y" 2639| 0| { CCL_EXPR(ispunct); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2639| 0| { CCL_EXPR(ispunct); } | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2640| 0|#line 2641 "parse.c" 2641| 0| break; 2642| | 2643| 0| case 89: ------------------ | Branch (2643:3): [True: 0, False: 13.2k] ------------------ 2644| 0|#line 918 "parse.y" 2645| 0| { CCL_EXPR(isspace); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2645| 0| { CCL_EXPR(isspace); } | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2646| 0|#line 2647 "parse.c" 2647| 0| break; 2648| | 2649| 0| case 90: ------------------ | Branch (2649:3): [True: 0, False: 13.2k] ------------------ 2650| 0|#line 919 "parse.y" 2651| 0| { CCL_EXPR(isxdigit); } ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2651| 0| { CCL_EXPR(isxdigit); } | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2652| 0|#line 2653 "parse.c" 2653| 0| break; 2654| | 2655| 0| case 91: ------------------ | Branch (2655:3): [True: 0, False: 13.2k] ------------------ 2656| 0|#line 920 "parse.y" 2657| 0| { 2658| 0| CCL_EXPR(isupper); ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2658| 0| CCL_EXPR(isupper); | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2659| 0| if (sf_case_ins()) ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ 2660| 0| CCL_EXPR(islower); ------------------ | | 124| 0| do{ \ | | 125| 0| int c; \ | | 126| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (126:15): [True: 0, False: 0] | | ------------------ | | 127| 0| if ( isascii(c) && func(c) ) \ | | ------------------ | | | | 2660| 0| CCL_EXPR(islower); | | ------------------ | | 128| 0| ccladd( currccl, c ); \ | | 129| 0| }while(0) | | ------------------ | | | Branch (129:9): [Folded - Ignored] | | ------------------ ------------------ 2661| 0| } 2662| 0|#line 2663 "parse.c" 2663| 0| break; 2664| | 2665| 0| case 92: ------------------ | Branch (2665:3): [True: 0, False: 13.2k] ------------------ 2666| 0|#line 926 "parse.y" 2667| 0| { CCL_NEG_EXPR(isalnum); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2667| 0| { CCL_NEG_EXPR(isalnum); } | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2668| 0|#line 2669 "parse.c" 2669| 0| break; 2670| | 2671| 0| case 93: ------------------ | Branch (2671:3): [True: 0, False: 13.2k] ------------------ 2672| 0|#line 927 "parse.y" 2673| 0| { CCL_NEG_EXPR(isalpha); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2673| 0| { CCL_NEG_EXPR(isalpha); } | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2674| 0|#line 2675 "parse.c" 2675| 0| break; 2676| | 2677| 0| case 94: ------------------ | Branch (2677:3): [True: 0, False: 13.2k] ------------------ 2678| 0|#line 928 "parse.y" 2679| 0| { CCL_NEG_EXPR(IS_BLANK); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2679| 0| { CCL_NEG_EXPR(IS_BLANK); } | | | | ------------------ | | | | | | 141| 0|#define IS_BLANK(c) ((c) == ' ' || (c) == '\t') | | | | | | ------------------ | | | | | | | Branch (141:22): [True: 0, False: 0] | | | | | | | Branch (141:36): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2680| 0|#line 2681 "parse.c" 2681| 0| break; 2682| | 2683| 0| case 95: ------------------ | Branch (2683:3): [True: 0, False: 13.2k] ------------------ 2684| 0|#line 929 "parse.y" 2685| 0| { CCL_NEG_EXPR(iscntrl); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2685| 0| { CCL_NEG_EXPR(iscntrl); } | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2686| 0|#line 2687 "parse.c" 2687| 0| break; 2688| | 2689| 0| case 96: ------------------ | Branch (2689:3): [True: 0, False: 13.2k] ------------------ 2690| 0|#line 930 "parse.y" 2691| 0| { CCL_NEG_EXPR(isdigit); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2691| 0| { CCL_NEG_EXPR(isdigit); } | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2692| 0|#line 2693 "parse.c" 2693| 0| break; 2694| | 2695| 0| case 97: ------------------ | Branch (2695:3): [True: 0, False: 13.2k] ------------------ 2696| 0|#line 931 "parse.y" 2697| 0| { CCL_NEG_EXPR(isgraph); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2697| 0| { CCL_NEG_EXPR(isgraph); } | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2698| 0|#line 2699 "parse.c" 2699| 0| break; 2700| | 2701| 0| case 98: ------------------ | Branch (2701:3): [True: 0, False: 13.2k] ------------------ 2702| 0|#line 932 "parse.y" 2703| 0| { CCL_NEG_EXPR(isprint); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2703| 0| { CCL_NEG_EXPR(isprint); } | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2704| 0|#line 2705 "parse.c" 2705| 0| break; 2706| | 2707| 0| case 99: ------------------ | Branch (2707:3): [True: 0, False: 13.2k] ------------------ 2708| 0|#line 933 "parse.y" 2709| 0| { CCL_NEG_EXPR(ispunct); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2709| 0| { CCL_NEG_EXPR(ispunct); } | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2710| 0|#line 2711 "parse.c" 2711| 0| break; 2712| | 2713| 0| case 100: ------------------ | Branch (2713:3): [True: 0, False: 13.2k] ------------------ 2714| 0|#line 934 "parse.y" 2715| 0| { CCL_NEG_EXPR(isspace); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2715| 0| { CCL_NEG_EXPR(isspace); } | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2716| 0|#line 2717 "parse.c" 2717| 0| break; 2718| | 2719| 0| case 101: ------------------ | Branch (2719:3): [True: 0, False: 13.2k] ------------------ 2720| 0|#line 935 "parse.y" 2721| 0| { CCL_NEG_EXPR(isxdigit); } ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2721| 0| { CCL_NEG_EXPR(isxdigit); } | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2722| 0|#line 2723 "parse.c" 2723| 0| break; 2724| | 2725| 0| case 102: ------------------ | Branch (2725:3): [True: 0, False: 13.2k] ------------------ 2726| 0|#line 936 "parse.y" 2727| 0| { 2728| 0| if ( sf_case_ins() ) ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ 2729| 0| lwarn(_("[:^lower:] is ambiguous in case insensitive scanner")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2730| 0| else 2731| 0| CCL_NEG_EXPR(islower); ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2731| 0| CCL_NEG_EXPR(islower); | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2732| 0| } 2733| 0|#line 2734 "parse.c" 2734| 0| break; 2735| | 2736| 0| case 103: ------------------ | Branch (2736:3): [True: 0, False: 13.2k] ------------------ 2737| 0|#line 942 "parse.y" 2738| 0| { 2739| 0| if ( sf_case_ins() ) ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ 2740| 0| lwarn(_("[:^upper:] ambiguous in case insensitive scanner")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2741| 0| else 2742| 0| CCL_NEG_EXPR(isupper); ------------------ | | 133| 0| do{ \ | | 134| 0| int c; \ | | 135| 0| for ( c = 0; c < ctrl.csize; ++c ) \ | | ------------------ | | | Branch (135:15): [True: 0, False: 0] | | ------------------ | | 136| 0| if ( !func(c) ) \ | | ------------------ | | | | 2742| 0| CCL_NEG_EXPR(isupper); | | ------------------ | | | Branch (136:8): [True: 0, False: 0] | | ------------------ | | 137| 0| ccladd( currccl, c ); \ | | 138| 0| }while(0) | | ------------------ | | | Branch (138:9): [Folded - Ignored] | | ------------------ ------------------ 2743| 0| } 2744| 0|#line 2745 "parse.c" 2745| 0| break; 2746| | 2747| 0| case 104: ------------------ | Branch (2747:3): [True: 0, False: 13.2k] ------------------ 2748| 0|#line 951 "parse.y" 2749| 0| { 2750| 0| if ( yyvsp[0] == nlch ) ------------------ | Branch (2750:9): [True: 0, False: 0] ------------------ 2751| 0| rule_has_nl[num_rules] = true; 2752| | 2753| 0| ++rulelen; 2754| | 2755| 0| if (sf_case_ins() && has_case(yyvsp[0])) ------------------ | | 1205| 0|#define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_case_ins() (sf_top() & _SF_CASE_INS) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1205:28): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2755:34): [True: 0, False: 0] ------------------ 2756| 0| yyval = mkor (mkstate(yyvsp[0]), mkstate(reverse_case(yyvsp[0]))); 2757| 0| else 2758| 0| yyval = mkstate (yyvsp[0]); 2759| | 2760| 0| yyval = link_machines( yyvsp[-1], yyval); 2761| 0| } 2762| 0|#line 2763 "parse.c" 2763| 0| break; 2764| | 2765| 0| case 105: ------------------ | Branch (2765:3): [True: 0, False: 13.2k] ------------------ 2766| 0|#line 966 "parse.y" 2767| 0| { yyval = mkstate( SYM_EPSILON ); } ------------------ | | 219| 0|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 0|#define CSIZE 256 | | ------------------ ------------------ 2768| 0|#line 2769 "parse.c" 2769| 0| break; 2770| | 2771| | 2772| 0|#line 2773 "parse.c" 2773| | 2774| 1.18k| default: break; ------------------ | Branch (2774:7): [True: 1.18k, False: 12.0k] ------------------ 2775| 13.2k| } 2776| | /* User semantic actions sometimes alter yychar, and that requires 2777| | that yytoken be updated with the new translation. We take the 2778| | approach of translating immediately before every use of yytoken. 2779| | One alternative is translating here after every semantic action, 2780| | but that translation would be missed if the semantic action invokes 2781| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2782| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2783| | incorrect destructor might then be invoked immediately. In the 2784| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 2785| | to an incorrect destructor call or verbose syntax error message 2786| | before the lookahead is translated. */ 2787| 13.2k| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2788| | 2789| 13.2k| YYPOPSTACK (yylen); ------------------ | | 1420| 13.2k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2790| 13.2k| yylen = 0; 2791| 13.2k| YY_STACK_PRINT (yyss, yyssp); 2792| | 2793| 13.2k| *++yyvsp = yyval; 2794| | 2795| | /* Now 'shift' the result of the reduction. Determine what state 2796| | that goes to, based on the state we popped back to and the rule 2797| | number reduced by. */ 2798| 13.2k| { 2799| 13.2k| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 633| 13.2k|#define YYNTOKENS 78 ------------------ 2800| 13.2k| const int yyi = yypgoto[yylhs] + *yyssp; 2801| 13.2k| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 630| 14.4k|#define YYLAST 193 ------------------ | Branch (2801:16): [True: 1.26k, False: 11.9k] | Branch (2801:28): [True: 1.26k, False: 0] | Branch (2801:45): [True: 0, False: 1.26k] ------------------ 2802| 13.2k| ? yytable[yyi] 2803| 13.2k| : yydefgoto[yylhs]); 2804| 13.2k| } 2805| | 2806| 13.2k| goto yynewstate; 2807| | 2808| | 2809| |/*--------------------------------------. 2810| || yyerrlab -- here on detecting error. | 2811| |`--------------------------------------*/ 2812| 9.52k|yyerrlab: 2813| | /* Make sure we have latest lookahead translation. See comments at 2814| | user semantic actions for why this is necessary. */ 2815| 9.52k| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 932| 9.52k|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 932| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 648| 19.0k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 642| 9.52k|#define YYMAXUTOK 311 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 641| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (648:4): [True: 9.52k, False: 0] | | | Branch (648:18): [True: 9.52k, False: 0] | | ------------------ ------------------ | Branch (2815:13): [True: 0, False: 9.52k] ------------------ 2816| | 2817| | /* If not already recovering from an error, report this error. */ 2818| 9.52k| if (!yyerrstatus) ------------------ | Branch (2818:7): [True: 84, False: 9.43k] ------------------ 2819| 84| { 2820| 84| ++yynerrs; 2821| 84|#if ! YYERROR_VERBOSE 2822| 84| yyerror (YY_("syntax error")); ------------------ | | 438| 84|# define YY_(Msgid) Msgid ------------------ 2823| |#else 2824| |# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2825| | yyssp, yytoken) 2826| | { 2827| | char const *yymsgp = YY_("syntax error"); 2828| | int yysyntax_error_status; 2829| | yysyntax_error_status = YYSYNTAX_ERROR; 2830| | if (yysyntax_error_status == 0) 2831| | yymsgp = yymsg; 2832| | else if (yysyntax_error_status == 1) 2833| | { 2834| | if (yymsg != yymsgbuf) 2835| | YYSTACK_FREE (yymsg); 2836| | yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); 2837| | if (!yymsg) 2838| | { 2839| | yymsg = yymsgbuf; 2840| | yymsg_alloc = sizeof yymsgbuf; 2841| | yysyntax_error_status = 2; 2842| | } 2843| | else 2844| | { 2845| | yysyntax_error_status = YYSYNTAX_ERROR; 2846| | yymsgp = yymsg; 2847| | } 2848| | } 2849| | yyerror (yymsgp); 2850| | if (yysyntax_error_status == 2) 2851| | goto yyexhaustedlab; 2852| | } 2853| |# undef YYSYNTAX_ERROR 2854| |#endif 2855| 84| } 2856| | 2857| | 2858| | 2859| 9.52k| if (yyerrstatus == 3) ------------------ | Branch (2859:7): [True: 9.43k, False: 84] ------------------ 2860| 9.43k| { 2861| | /* If just tried and failed to reuse lookahead token after an 2862| | error, discard it. */ 2863| | 2864| 9.43k| if (yychar <= YYEOF) ------------------ | | 933| 9.43k|#define YYEOF 0 ------------------ | Branch (2864:11): [True: 0, False: 9.43k] ------------------ 2865| 0| { 2866| | /* Return failure if at end of input. */ 2867| 0| if (yychar == YYEOF) ------------------ | | 933| 0|#define YYEOF 0 ------------------ | Branch (2867:15): [True: 0, False: 0] ------------------ 2868| 0| YYABORT; ------------------ | | 936| 0|#define YYABORT goto yyabortlab ------------------ 2869| 0| } 2870| 9.43k| else 2871| 9.43k| { 2872| 9.43k| yydestruct ("Error: discarding", 2873| 9.43k| yytoken, &yylval); 2874| 9.43k| yychar = YYEMPTY; ------------------ | | 932| 9.43k|#define YYEMPTY (-2) ------------------ 2875| 9.43k| } 2876| 9.43k| } 2877| | 2878| | /* Else will try to reuse lookahead token after shifting the error 2879| | token. */ 2880| 9.52k| goto yyerrlab1; 2881| | 2882| | 2883| |/*---------------------------------------------------. 2884| || yyerrorlab -- error raised explicitly by YYERROR. | 2885| |`---------------------------------------------------*/ 2886| 9.52k|yyerrorlab: 2887| | /* Pacify compilers when the user code never invokes YYERROR and the 2888| | label yyerrorlab therefore never appears in user code. */ 2889| 0| if (0) ------------------ | Branch (2889:7): [Folded - Ignored] ------------------ 2890| 0| YYERROR; ------------------ | | 937| 0|#define YYERROR goto yyerrorlab ------------------ 2891| | 2892| | /* Do not reclaim the symbols of the rule whose action triggered 2893| | this YYERROR. */ 2894| 0| YYPOPSTACK (yylen); ------------------ | | 1420| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2895| 0| yylen = 0; 2896| 0| YY_STACK_PRINT (yyss, yyssp); 2897| 0| yystate = *yyssp; 2898| 0| goto yyerrlab1; 2899| | 2900| | 2901| |/*-------------------------------------------------------------. 2902| || yyerrlab1 -- common code for both syntax error and YYERROR. | 2903| |`-------------------------------------------------------------*/ 2904| 9.52k|yyerrlab1: 2905| 9.52k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 2906| | 2907| 9.52k| for (;;) 2908| 18.9k| { 2909| 18.9k| yyn = yypact[yystate]; 2910| 18.9k| if (!yypact_value_is_default (yyn)) ------------------ | | 753| 18.9k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 750| 18.9k|#define YYPACT_NINF (-88) | | ------------------ ------------------ | Branch (2910:11): [True: 18.9k, False: 0] ------------------ 2911| 18.9k| { 2912| 18.9k| yyn += YYTERROR; ------------------ | | 960| 18.9k|#define YYTERROR 1 ------------------ 2913| 18.9k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 630| 37.9k|#define YYLAST 193 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 960| 18.9k|#define YYTERROR 1 ------------------ | Branch (2913:15): [True: 18.9k, False: 0] | Branch (2913:27): [True: 18.9k, False: 0] | Branch (2913:44): [True: 9.52k, False: 9.43k] ------------------ 2914| 9.52k| { 2915| 9.52k| yyn = yytable[yyn]; 2916| 9.52k| if (0 < yyn) ------------------ | Branch (2916:19): [True: 9.52k, False: 0] ------------------ 2917| 9.52k| break; 2918| 9.52k| } 2919| 18.9k| } 2920| | 2921| | /* Pop the current state because it cannot handle the error token. */ 2922| 9.43k| if (yyssp == yyss) ------------------ | Branch (2922:11): [True: 0, False: 9.43k] ------------------ 2923| 0| YYABORT; ------------------ | | 936| 0|#define YYABORT goto yyabortlab ------------------ 2924| | 2925| | 2926| 9.43k| yydestruct ("Error: popping", 2927| 9.43k| yystos[yystate], yyvsp); 2928| 9.43k| YYPOPSTACK (1); ------------------ | | 1420| 9.43k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2929| 9.43k| yystate = *yyssp; 2930| 9.43k| YY_STACK_PRINT (yyss, yyssp); 2931| 9.43k| } 2932| | 2933| 9.52k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2934| 9.52k| *++yyvsp = yylval; 2935| 9.52k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2936| | 2937| | 2938| | /* Shift the error token. */ 2939| 9.52k| YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2940| | 2941| 9.52k| yystate = yyn; 2942| 9.52k| goto yynewstate; 2943| | 2944| | 2945| |/*-------------------------------------. 2946| || yyacceptlab -- YYACCEPT comes here. | 2947| |`-------------------------------------*/ 2948| 632|yyacceptlab: 2949| 632| yyresult = 0; 2950| 632| goto yyreturn; 2951| | 2952| | 2953| |/*-----------------------------------. 2954| || yyabortlab -- YYABORT comes here. | 2955| |`-----------------------------------*/ 2956| 0|yyabortlab: 2957| 0| yyresult = 1; 2958| 0| goto yyreturn; 2959| | 2960| | 2961| 0|#if !defined yyoverflow || YYERROR_VERBOSE 2962| |/*-------------------------------------------------. 2963| || yyexhaustedlab -- memory exhaustion comes here. | 2964| |`-------------------------------------------------*/ 2965| 0|yyexhaustedlab: 2966| 0| yyerror (YY_("memory exhausted")); ------------------ | | 438| 0|# define YY_(Msgid) Msgid ------------------ 2967| 0| yyresult = 2; 2968| | /* Fall through. */ 2969| 0|#endif 2970| | 2971| | 2972| |/*-----------------------------------------------------. 2973| || yyreturn -- parsing is finished, return the result. | 2974| |`-----------------------------------------------------*/ 2975| 632|yyreturn: 2976| 632| if (yychar != YYEMPTY) ------------------ | | 932| 632|#define YYEMPTY (-2) ------------------ | Branch (2976:7): [True: 0, False: 632] ------------------ 2977| 0| { 2978| | /* Make sure we have latest lookahead translation. See comments at 2979| | user semantic actions for why this is necessary. */ 2980| 0| yytoken = YYTRANSLATE (yychar); ------------------ | | 648| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 642| 0|#define YYMAXUTOK 311 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 641| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (648:4): [True: 0, False: 0] | | | Branch (648:18): [True: 0, False: 0] | | ------------------ ------------------ 2981| 0| yydestruct ("Cleanup: discarding lookahead", 2982| 0| yytoken, &yylval); 2983| 0| } 2984| | /* Do not reclaim the symbols of the rule whose action triggered 2985| | this YYABORT or YYACCEPT. */ 2986| 632| YYPOPSTACK (yylen); ------------------ | | 1420| 632|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2987| 632| YY_STACK_PRINT (yyss, yyssp); 2988| 1.89k| while (yyssp != yyss) ------------------ | Branch (2988:10): [True: 1.26k, False: 632] ------------------ 2989| 1.26k| { 2990| 1.26k| yydestruct ("Cleanup: popping", 2991| 1.26k| yystos[+*yyssp], yyvsp); 2992| 1.26k| YYPOPSTACK (1); ------------------ | | 1420| 1.26k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 2993| 1.26k| } 2994| 632|#ifndef yyoverflow 2995| 632| if (yyss != yyssa) ------------------ | Branch (2995:7): [True: 0, False: 632] ------------------ 2996| 0| YYSTACK_FREE (yyss); ------------------ | | 539| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 558| 0|# define YYFREE free | | ------------------ ------------------ 2997| 632|#endif 2998| |#if YYERROR_VERBOSE 2999| | if (yymsg != yymsgbuf) 3000| | YYSTACK_FREE (yymsg); 3001| |#endif 3002| 632| return yyresult; 3003| 0|} format_synerr: 3053| 3.38k| { 3054| 3.38k| char errmsg[MAXLINE]; 3055| | 3056| 3.38k| (void) snprintf( errmsg, sizeof(errmsg), msg, arg ); 3057| 3.38k| synerr( errmsg ); 3058| 3.38k| } synerr: 3064| 14.0k| { 3065| 14.0k| syntaxerror = true; 3066| 14.0k| pinpoint_message( str ); 3067| 14.0k| } format_pinpoint_message: 3093| 631| { 3094| 631| char errmsg[MAXLINE*2]; 3095| | 3096| 631| snprintf( errmsg, sizeof(errmsg), msg, arg ); 3097| 631| pinpoint_message( errmsg ); 3098| 631| } pinpoint_message: 3104| 14.7k| { 3105| 14.7k| line_pinpoint( str, linenum ); 3106| 14.7k| } line_pinpoint: 3126| 14.7k| { 3127| 14.7k| fprintf( stderr, "%s:%d: %s\n", infilename, line, str ); 3128| 14.7k| } yyerror: 3136| 84| { 3137| 84| (void)msg; 3138| 84| } parse.c:yydestruct: 1352| 20.1k|{ 1353| 20.1k| YYUSE (yyvaluep); ------------------ | | 460| 20.1k|# define YYUSE(E) ((void) (E)) ------------------ 1354| 20.1k| if (!yymsg) ------------------ | Branch (1354:7): [True: 0, False: 20.1k] ------------------ 1355| 0| yymsg = "Deleting"; 1356| 20.1k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1357| | 1358| 20.1k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1359| 20.1k| YYUSE (yytype); ------------------ | | 460| 20.1k|# define YYUSE(E) ((void) (E)) ------------------ 1360| 20.1k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1361| 20.1k|} sf_push: 41| 14|{ 42| 14| if (_sf_top_ix + 1 >= _sf_max) { ------------------ | Branch (42:9): [True: 0, False: 14] ------------------ 43| 0| _sf_max += 32; 44| 0| _sf_stk = realloc(_sf_stk, sizeof(scanflags_t) * _sf_max); 45| 0| } 46| | 47| | // copy the top element 48| 14| _sf_stk[_sf_top_ix + 1] = _sf_stk[_sf_top_ix]; 49| 14| ++_sf_top_ix; 50| 14|} sf_pop: 54| 11|{ 55| 11| assert(_sf_top_ix > 0); 56| 11| --_sf_top_ix; 57| 11|} sf_init: 62| 632|{ 63| 632| assert(_sf_stk == NULL); 64| 632| _sf_max = 32; 65| 632| _sf_stk = malloc(sizeof(scanflags_t) * _sf_max); 66| 632| if (!_sf_stk) ------------------ | Branch (66:9): [True: 0, False: 632] ------------------ 67| 0| lerr_fatal(_("Unable to allocate %zu of stack"), sizeof(scanflags_t)); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 68| 632| _sf_stk[_sf_top_ix] = 0; 69| 632|} scanopt_init: 138| 632|{ 139| 632| int i; 140| 632| struct _scanopt_t *s; 141| 632| s = malloc(sizeof (struct _scanopt_t)); 142| | 143| 632| s->options = options; 144| 632| s->optc = 0; 145| 632| s->argc = argc; 146| 632| s->argv = (char **) argv; 147| 632| s->index = 1; 148| 632| s->subscript = 0; 149| 632| s->no_err_msg = (flags & SCANOPT_NO_ERR_MSG); 150| 632| s->has_long = 0; 151| 632| s->has_short = 0; 152| | 153| | /* Determine option count. (Find entry with all zeros). */ 154| 632| s->optc = 0; 155| 79.0k| while (options[s->optc].opt_fmt ------------------ | Branch (155:9): [True: 78.3k, False: 632] ------------------ 156| 79.0k| || options[s->optc].r_val || options[s->optc].desc) ------------------ | Branch (156:12): [True: 0, False: 632] | Branch (156:38): [True: 0, False: 632] ------------------ 157| 78.3k| s->optc++; 158| | 159| | /* Build auxiliary data */ 160| 632| s->aux = malloc((size_t) s->optc * sizeof (struct _aux)); 161| | 162| 79.0k| for (i = 0; i < s->optc; i++) { ------------------ | Branch (162:14): [True: 78.3k, False: 632] ------------------ 163| 78.3k| const unsigned char *p, *pname; 164| 78.3k| const struct optspec_t *opt; 165| 78.3k| struct _aux *aux; 166| | 167| 78.3k| opt = s->options + i; 168| 78.3k| aux = s->aux + i; 169| | 170| 78.3k| aux->flags = ARG_NONE; ------------------ | | 40| 78.3k|#define ARG_NONE 0x01 ------------------ 171| | 172| 78.3k| if (opt->opt_fmt[0] == '-' && opt->opt_fmt[1] == '-') { ------------------ | Branch (172:7): [True: 78.3k, False: 0] | Branch (172:33): [True: 58.7k, False: 19.5k] ------------------ 173| 58.7k| aux->flags |= IS_LONG; ------------------ | | 43| 58.7k|#define IS_LONG 0x08 ------------------ 174| 58.7k| pname = (const unsigned char *)(opt->opt_fmt + 2); 175| 58.7k| s->has_long = 1; 176| 58.7k| } 177| 19.5k| else { 178| 19.5k| pname = (const unsigned char *)(opt->opt_fmt + 1); 179| 19.5k| s->has_short = 1; 180| 19.5k| } 181| 78.3k| aux->printlen = (int) strlen (opt->opt_fmt); 182| | 183| 78.3k| aux->namelen = 0; 184| 597k| for (p = pname + 1; *p; p++) { ------------------ | Branch (184:23): [True: 520k, False: 76.4k] ------------------ 185| | /* detect required arg */ 186| 520k| if (*p == '=' || isspace ((unsigned char)*p) ------------------ | Branch (186:8): [True: 4.42k, False: 516k] ------------------ 187| 520k| || !(aux->flags & IS_LONG)) { ------------------ | | 43| 513k|#define IS_LONG 0x08 ------------------ | Branch (187:11): [True: 15.1k, False: 498k] ------------------ 188| 22.1k| if (aux->namelen == 0) ------------------ | Branch (188:9): [True: 8.21k, False: 13.9k] ------------------ 189| 8.21k| aux->namelen = (int) (p - pname); 190| 22.1k| aux->flags |= ARG_REQ; ------------------ | | 41| 22.1k|#define ARG_REQ 0x02 ------------------ 191| 22.1k| aux->flags &= ~ARG_NONE; ------------------ | | 40| 22.1k|#define ARG_NONE 0x01 ------------------ 192| 22.1k| } 193| | /* detect optional arg. This overrides required arg. */ 194| 520k| if (*p == '[') { ------------------ | Branch (194:8): [True: 1.89k, False: 518k] ------------------ 195| 1.89k| if (aux->namelen == 0) ------------------ | Branch (195:9): [True: 1.26k, False: 632] ------------------ 196| 1.26k| aux->namelen = (int) (p - pname); 197| 1.89k| aux->flags &= ~(ARG_REQ | ARG_NONE); ------------------ | | 41| 1.89k|#define ARG_REQ 0x02 ------------------ aux->flags &= ~(ARG_REQ | ARG_NONE); ------------------ | | 40| 1.89k|#define ARG_NONE 0x01 ------------------ 198| 1.89k| aux->flags |= ARG_OPT; ------------------ | | 42| 1.89k|#define ARG_OPT 0x04 ------------------ 199| 1.89k| break; 200| 1.89k| } 201| 520k| } 202| 78.3k| if (aux->namelen == 0) ------------------ | Branch (202:7): [True: 68.8k, False: 9.48k] ------------------ 203| 68.8k| aux->namelen = (int) (p - pname); 204| 78.3k| } 205| 632| return (scanopt_t *) s; 206| 632|} scanopt: 615| 632|{ 616| 632| char *optname = NULL, *optarg = NULL, *pstart; 617| 632| int namelen = 0, arglen = 0; 618| 632| int errcode = 0, has_next; 619| 632| const optspec_t *optp; 620| 632| struct _scanopt_t *s; 621| 632| struct _aux *auxp; 622| 632| int is_short; 623| 632| int opt_offset = -1; 624| | 625| 632| s = (struct _scanopt_t *) svoid; 626| | 627| | /* Normalize return-parameters. */ 628| 632| SAFE_ASSIGN (arg, NULL); ------------------ | | 125| 632| do{ \ | | 126| 632| if((ptr)!=NULL) \ | | ------------------ | | | Branch (126:12): [True: 632, False: 0] | | ------------------ | | 127| 632| *(ptr) = val; \ | | 128| 632| }while(0) | | ------------------ | | | Branch (128:12): [Folded - Ignored] | | ------------------ ------------------ 629| 632| SAFE_ASSIGN (optindex, s->index); ------------------ | | 125| 632| do{ \ | | 126| 632| if((ptr)!=NULL) \ | | ------------------ | | | Branch (126:12): [True: 632, False: 0] | | ------------------ | | 127| 632| *(ptr) = val; \ | | 128| 632| }while(0) | | ------------------ | | | Branch (128:12): [Folded - Ignored] | | ------------------ ------------------ 630| | 631| 632| if (s->index >= s->argc) ------------------ | Branch (631:6): [True: 0, False: 632] ------------------ 632| 0| return 0; 633| | 634| | /* pstart always points to the start of our current scan. */ 635| 632| pstart = s->argv[s->index] + s->subscript; 636| 632| if (!pstart) ------------------ | Branch (636:6): [True: 0, False: 632] ------------------ 637| 0| return 0; 638| | 639| 632| if (s->subscript == 0) { ------------------ | Branch (639:6): [True: 632, False: 0] ------------------ 640| | 641| | /* test for exact match of "--" */ 642| 632| if (pstart[0] == '-' && pstart[1] == '-' && !pstart[2]) { ------------------ | Branch (642:7): [True: 0, False: 632] | Branch (642:27): [True: 0, False: 0] | Branch (642:47): [True: 0, False: 0] ------------------ 643| 0| SAFE_ASSIGN (optindex, s->index + 1); ------------------ | | 125| 0| do{ \ | | 126| 0| if((ptr)!=NULL) \ | | ------------------ | | | Branch (126:12): [True: 0, False: 0] | | ------------------ | | 127| 0| *(ptr) = val; \ | | 128| 0| }while(0) | | ------------------ | | | Branch (128:12): [Folded - Ignored] | | ------------------ ------------------ 644| 0| INC_INDEX (s, 1); ------------------ | | 132| 0| do{ \ | | 133| 0| (s)->index += (n); \ | | 134| 0| (s)->subscript= 0; \ | | 135| 0| }while(0) | | ------------------ | | | Branch (135:12): [Folded - Ignored] | | ------------------ ------------------ 645| 0| return 0; 646| 0| } 647| | 648| | /* Match an opt. */ 649| 632| if (matchlongopt ------------------ | Branch (649:7): [True: 0, False: 632] ------------------ 650| 632| (pstart, &optname, &namelen, &optarg, &arglen)) { 651| | 652| | /* it LOOKS like an opt, but is it one?! */ 653| 0| if (!find_opt ------------------ | Branch (653:8): [True: 0, False: 0] ------------------ 654| 0| (s, 1, optname, namelen, &errcode, 655| 0| &opt_offset)) { 656| 0| scanopt_err (s, 0, errcode); 657| 0| return errcode; 658| 0| } 659| | /* We handle this below. */ 660| 0| is_short = 0; 661| | 662| | /* Check for short opt. */ 663| 0| } 664| 632| else if (pstart[0] == '-' && pstart[1]) { ------------------ | Branch (664:12): [True: 0, False: 632] | Branch (664:32): [True: 0, False: 0] ------------------ 665| | /* Pass through to below. */ 666| 0| is_short = 1; 667| 0| s->subscript++; 668| 0| pstart++; 669| 0| } 670| | 671| 632| else { 672| | /* It's not an option. We're done. */ 673| 632| return 0; 674| 632| } 675| 632| } 676| | 677| | /* We have to re-check the subscript status because it 678| | * may have changed above. */ 679| | 680| 0| if (s->subscript != 0) { ------------------ | Branch (680:6): [True: 0, False: 0] ------------------ 681| | 682| | /* we are somewhere in a run of short opts, 683| | * e.g., at the 'z' in `tar -xzf` */ 684| | 685| 0| optname = pstart; 686| 0| namelen = 1; 687| 0| is_short = 1; 688| | 689| 0| if (!find_opt ------------------ | Branch (689:7): [True: 0, False: 0] ------------------ 690| 0| (s, 0, pstart, namelen, &errcode, &opt_offset)) { 691| 0| scanopt_err(s, 1, errcode); 692| 0| return errcode; 693| 0| } 694| | 695| 0| optarg = pstart + 1; 696| 0| if (!*optarg) { ------------------ | Branch (696:7): [True: 0, False: 0] ------------------ 697| 0| optarg = NULL; 698| 0| arglen = 0; 699| 0| } 700| 0| else 701| 0| arglen = (int) strlen (optarg); 702| 0| } 703| | 704| | /* At this point, we have a long or short option matched at opt_offset into 705| | * the s->options array (and corresponding aux array). 706| | * A trailing argument is in {optarg,arglen}, if any. 707| | */ 708| | 709| | /* Look ahead in argv[] to see if there is something 710| | * that we can use as an argument (if needed). */ 711| 0| has_next = s->index + 1 < s->argc; 712| | 713| 0| optp = s->options + opt_offset; 714| 0| auxp = s->aux + opt_offset; 715| | 716| | /* case: no args allowed */ 717| 0| if (auxp->flags & ARG_NONE) { ------------------ | | 40| 0|#define ARG_NONE 0x01 ------------------ | Branch (717:6): [True: 0, False: 0] ------------------ 718| 0| if (optarg && !is_short) { ------------------ | Branch (718:7): [True: 0, False: 0] | Branch (718:17): [True: 0, False: 0] ------------------ 719| 0| scanopt_err(s, is_short, SCANOPT_ERR_ARG_NOT_ALLOWED); 720| 0| INC_INDEX (s, 1); ------------------ | | 132| 0| do{ \ | | 133| 0| (s)->index += (n); \ | | 134| 0| (s)->subscript= 0; \ | | 135| 0| }while(0) | | ------------------ | | | Branch (135:12): [Folded - Ignored] | | ------------------ ------------------ 721| 0| return SCANOPT_ERR_ARG_NOT_ALLOWED; 722| 0| } 723| 0| else if (!optarg) ------------------ | Branch (723:12): [True: 0, False: 0] ------------------ 724| 0| INC_INDEX (s, 1); ------------------ | | 132| 0| do{ \ | | 133| 0| (s)->index += (n); \ | | 134| 0| (s)->subscript= 0; \ | | 135| 0| }while(0) | | ------------------ | | | Branch (135:12): [Folded - Ignored] | | ------------------ ------------------ 725| 0| else 726| 0| s->subscript++; 727| 0| return optp->r_val; 728| 0| } 729| | 730| | /* case: required */ 731| 0| if (auxp->flags & ARG_REQ) { ------------------ | | 41| 0|#define ARG_REQ 0x02 ------------------ | Branch (731:6): [True: 0, False: 0] ------------------ 732| 0| if (!optarg && !has_next) { ------------------ | Branch (732:7): [True: 0, False: 0] | Branch (732:18): [True: 0, False: 0] ------------------ 733| 0| scanopt_err(s, is_short, SCANOPT_ERR_ARG_NOT_FOUND); 734| 0| return SCANOPT_ERR_ARG_NOT_FOUND; 735| 0| } 736| | 737| 0| if (!optarg) { ------------------ | Branch (737:7): [True: 0, False: 0] ------------------ 738| | /* Let the next argv element become the argument. */ 739| 0| SAFE_ASSIGN (arg, s->argv[s->index + 1]); ------------------ | | 125| 0| do{ \ | | 126| 0| if((ptr)!=NULL) \ | | ------------------ | | | Branch (126:12): [True: 0, False: 0] | | ------------------ | | 127| 0| *(ptr) = val; \ | | 128| 0| }while(0) | | ------------------ | | | Branch (128:12): [Folded - Ignored] | | ------------------ ------------------ 740| 0| INC_INDEX (s, 2); ------------------ | | 132| 0| do{ \ | | 133| 0| (s)->index += (n); \ | | 134| 0| (s)->subscript= 0; \ | | 135| 0| }while(0) | | ------------------ | | | Branch (135:12): [Folded - Ignored] | | ------------------ ------------------ 741| 0| } 742| 0| else { 743| 0| SAFE_ASSIGN (arg, (char *) optarg); ------------------ | | 125| 0| do{ \ | | 126| 0| if((ptr)!=NULL) \ | | ------------------ | | | Branch (126:12): [True: 0, False: 0] | | ------------------ | | 127| 0| *(ptr) = val; \ | | 128| 0| }while(0) | | ------------------ | | | Branch (128:12): [Folded - Ignored] | | ------------------ ------------------ 744| 0| INC_INDEX (s, 1); ------------------ | | 132| 0| do{ \ | | 133| 0| (s)->index += (n); \ | | 134| 0| (s)->subscript= 0; \ | | 135| 0| }while(0) | | ------------------ | | | Branch (135:12): [Folded - Ignored] | | ------------------ ------------------ 745| 0| } 746| 0| return optp->r_val; 747| 0| } 748| | 749| | /* case: optional */ 750| 0| if (auxp->flags & ARG_OPT) { ------------------ | | 42| 0|#define ARG_OPT 0x04 ------------------ | Branch (750:6): [True: 0, False: 0] ------------------ 751| 0| SAFE_ASSIGN (arg, optarg); ------------------ | | 125| 0| do{ \ | | 126| 0| if((ptr)!=NULL) \ | | ------------------ | | | Branch (126:12): [True: 0, False: 0] | | ------------------ | | 127| 0| *(ptr) = val; \ | | 128| 0| }while(0) | | ------------------ | | | Branch (128:12): [Folded - Ignored] | | ------------------ ------------------ 752| 0| INC_INDEX (s, 1); ------------------ | | 132| 0| do{ \ | | 133| 0| (s)->index += (n); \ | | 134| 0| (s)->subscript= 0; \ | | 135| 0| }while(0) | | ------------------ | | | Branch (135:12): [Folded - Ignored] | | ------------------ ------------------ 753| 0| return optp->r_val; 754| 0| } 755| | 756| | 757| | /* Should not reach here. */ 758| 0| return 0; 759| 0|} scanopt_destroy: 763| 632|{ 764| 632| struct _scanopt_t *s; 765| | 766| 632| s = (struct _scanopt_t *) svoid; 767| 632| if (s != NULL) { ------------------ | Branch (767:6): [True: 632, False: 0] ------------------ 768| 632| free(s->aux); 769| 632| free(s); 770| 632| } 771| 632| return 0; 772| 632|} scanopt.c:matchlongopt: 515| 632|{ 516| 632| char *p; 517| | 518| 632| *optname = *arg = NULL; 519| 632| *optlen = *arglen = 0; 520| | 521| | /* Match regex /--./ */ 522| 632| p = str; 523| 632| if (p[0] != '-' || p[1] != '-' || !p[2]) ------------------ | Branch (523:6): [True: 632, False: 0] | Branch (523:21): [True: 0, False: 0] | Branch (523:36): [True: 0, False: 0] ------------------ 524| 632| return 0; 525| | 526| 0| p += 2; 527| 0| *optname = p; 528| | 529| | /* find the end of optname */ 530| 0| while (*p && *p != '=') ------------------ | Branch (530:9): [True: 0, False: 0] | Branch (530:15): [True: 0, False: 0] ------------------ 531| 0| ++p; 532| | 533| 0| *optlen = (int) (p - *optname); 534| | 535| 0| if (!*p) ------------------ | Branch (535:6): [True: 0, False: 0] ------------------ 536| | /* an option with no '=...' part. */ 537| 0| return 1; 538| | 539| | 540| | /* We saw an '=' char. The rest of p is the arg. */ 541| 0| p++; 542| 0| *arg = p; 543| 0| while (*p) ------------------ | Branch (543:9): [True: 0, False: 0] ------------------ 544| 0| ++p; 545| 0| *arglen = (int) (p - *arg); 546| | 547| 0| return 1; 548| 0|} is_default_backend: 78| 632|{ 79| 632| return backend == &backends[0]; 80| 632|} suffix: 131| 632|{ 132| 632| const char *suffix; 133| | 134| 632| if (is_default_backend()) { ------------------ | Branch (134:6): [True: 632, False: 0] ------------------ 135| 632| if (ctrl.C_plus_plus) ------------------ | Branch (135:7): [True: 0, False: 632] ------------------ 136| 0| suffix = "cc"; 137| 632| else 138| 632| suffix = "c"; 139| 632| } else { 140| 0| suffix = skel_property("M4_PROPERTY_SOURCE_SUFFIX"); 141| 0| } 142| | 143| 632| return suffix; 144| 632|} flexscan: 2739| 10.0k|YY_DECL { 2740| 10.0k| yy_state_type yy_current_state; 2741| 10.0k| char *yy_cp, *yy_bp; 2742| 10.0k| int yy_act; 2743| | 2744| 10.0k| if ( !(yy_init) ) { ------------------ | Branch (2744:7): [True: 1, False: 10.0k] ------------------ 2745| 1| (yy_init) = 1; 2746| | 2747| 1|#ifdef YY_USER_INIT 2748| 1| YY_USER_INIT; ------------------ | | 2470| 1| if ( getenv("POSIXLY_CORRECT") ) \ | | ------------------ | | | Branch (2470:7): [True: 0, False: 1] | | ------------------ | | 2471| 1| ctrl.posix_compat = true; ------------------ 2749| 1|#endif 2750| | 2751| 1| if ( ! (yy_start) ) { ------------------ | Branch (2751:8): [True: 1, False: 0] ------------------ 2752| 1| (yy_start) = 1; /* first start state */ 2753| 1| } 2754| 1| if ( ! yyin ) { ------------------ | Branch (2754:8): [True: 0, False: 1] ------------------ 2755| | 2756| 0| yyin = stdin; 2757| | 2758| 0| } 2759| 1| if ( ! yyout ) { ------------------ | Branch (2759:8): [True: 1, False: 0] ------------------ 2760| | 2761| 1| yyout = stdout; 2762| | 2763| 1| } 2764| 1| if ( yy_current_buffer() == NULL ) { ------------------ | | 391| 1|#define yy_current_buffer() ( (yy_buffer_stack) \ | | ------------------ | | | Branch (391:31): [True: 0, False: 1] | | ------------------ | | 392| 1| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 393| 1| : NULL) ------------------ | Branch (2764:8): [True: 1, False: 0] ------------------ 2765| 1| yyensure_buffer_stack (); 2766| 1| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 399| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 2767| 1| yy_create_buffer( yyin, YY_BUF_SIZE ); ------------------ | | 2626| 1|#define YY_BUF_SIZE (2 * YY_READ_BUF_SIZE) | | ------------------ | | | | 2619| 1|#define YY_READ_BUF_SIZE BUFSIZ | | ------------------ ------------------ 2768| 1| } 2769| | 2770| 1| yy_load_buffer_state( ); 2771| 1| } 2772| | 2773| | /* open scope of user declarationns */ 2774| 10.0k| { 2775| |/* %% [4.0] user's declarations go here */ 2776| 10.0k|#line 156 "./scan.l" 2777| | 2778| 10.0k|#line 158 "./scan.l" 2779| 10.0k| static int bracelevel, didadef, indented_code; 2780| 10.0k| static int doing_rule_action = false; 2781| 10.0k| static int option_sense; 2782| | 2783| 10.0k| int doing_codeblock = false; 2784| 10.0k| int brace_depth=0, brace_start_line=0; 2785| 10.0k| char nmdef[MAXLINE]; 2786| | 2787| | 2788| 10.0k|#line 2789 "stage1scan.c" 2789| | 2790| 3.05M| while ( /*CONSTCOND*/1 ) { /* loops until end-of-file is reached */ ------------------ | Branch (2790:24): [Folded - Ignored] ------------------ 2791| | 2792| 3.05M| yy_cp = (yy_c_buf_p); 2793| | 2794| | /* Support of yytext. */ 2795| 3.05M| *yy_cp = (yy_hold_char); 2796| | 2797| | /* yy_bp points to the position in yy_ch_buf of the start of 2798| | * the current run. 2799| | */ 2800| 3.05M| yy_bp = yy_cp; 2801| | 2802| | /* Generate the code to find the start state. */ 2803| | 2804| 3.05M| yy_current_state = (yy_start); 2805| 3.05M|yy_current_state += yyatbol(); ------------------ | | 467| 3.05M|#define yyatbol() (YY_CURRENT_BUFFER_LVALUE->yyatbol) | | ------------------ | | | | 399| 3.05M|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ ------------------ 2806| | /* Set up for storing up states. */ 2807| | 2808| 11.8M| yy_match: 2809| | /* Generate the code to find the next match. */ 2810| | 2811| 46.6M| do { 2812| | 2813| 46.6M| int yy_c = *(yy_ec+YY_SC_TO_UI(*yy_cp)); ------------------ | | 193| 46.6M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 2814| | /* Save the backing-up info \before/ computing the next state 2815| | * because we always compute one more state than needed - we 2816| | * always proceed until we reach a jam state 2817| | */ 2818| | 2819| | /* Generate code to keep backing-up information. */ 2820| | 2821| 46.6M| if ( yy_accept[yy_current_state] ) { ------------------ | Branch (2821:8): [True: 43.9M, False: 2.64M] ------------------ 2822| | 2823| 43.9M| (yy_last_accepting_state) = yy_current_state; 2824| 43.9M| (yy_last_accepting_cpos) = yy_cp; 2825| 43.9M| } 2826| | 2827| 92.8M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { ------------------ | Branch (2827:10): [True: 46.2M, False: 46.6M] ------------------ 2828| 46.2M| yy_current_state = (int) yy_def[yy_current_state]; 2829| | 2830| | /* We've arranged it so that templates are never chained 2831| | * to one another. This means we can afford to make a 2832| | * very simple test to see if we need to convert to 2833| | * yy_c's meta-equivalence class without worrying 2834| | * about erroneously looking up the meta-equivalence 2835| | * class twice 2836| | */ 2837| | 2838| | /* lastdfa + 2 == YY_JAMSTATE + 1 is the beginning of the templates */ 2839| 46.2M| if (yy_current_state >= YY_JAMSTATE + 1) { ------------------ | | 545| 46.2M|#define YY_JAMSTATE 1327 ------------------ | Branch (2839:7): [True: 34.3M, False: 11.8M] ------------------ 2840| 34.3M| yy_c = yy_meta[yy_c]; 2841| 34.3M| } 2842| | 2843| 46.2M| } 2844| 46.6M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2845| | 2846| 46.6M| ++yy_cp; 2847| | 2848| 46.6M| } 2849| 46.6M| while ( yy_base[yy_current_state] != YY_JAMBASE ); ------------------ | | 544| 46.6M|#define YY_JAMBASE 5176 ------------------ | Branch (2849:12): [True: 34.7M, False: 11.8M] ------------------ 2850| | 2851| 11.9M| yy_find_action: 2852| | /* code to find the action number goes here */ 2853| | 2854| 11.9M| yy_act = yy_accept[yy_current_state]; 2855| 11.9M| if ( yy_act == 0 ) { /* have to back up */ ------------------ | Branch (2855:9): [True: 10.9M, False: 923k] ------------------ 2856| 10.9M| yy_cp = (yy_last_accepting_cpos); 2857| 10.9M| yy_current_state = (yy_last_accepting_state); 2858| 10.9M| yy_act = yy_accept[yy_current_state]; 2859| 10.9M| } 2860| | 2861| 11.9M| YY_DO_BEFORE_ACTION; ------------------ | | 584| 11.9M| do { \ | | 585| 11.9M| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 528| 11.9M|#define yytext_ptr yytext | | ------------------ | | 586| 11.9M| \ | | 587| 11.9M| yyleng = (int) (yy_cp - yy_bp); \ | | 588| 11.9M| \ | | 589| 11.9M| (yy_hold_char) = *yy_cp; \ | | 590| 11.9M| *yy_cp = '\0'; \ | | 591| 11.9M| \ | | 592| 11.9M| (yy_c_buf_p) = yy_cp; \ | | 593| 11.9M| } while(0) | | ------------------ | | | Branch (593:10): [Folded - Ignored] | | ------------------ ------------------ 2862| | 2863| 11.9M| do_action: /* This label is used only to access EOF actions. */ 2864| | 2865| 11.9M| switch ( yy_act ) { /* beginning of action switch */ 2866| | 2867| 0| case 0: /* must back up */ ------------------ | Branch (2867:4): [True: 0, False: 11.9M] ------------------ 2868| | /* undo the effects of YY_DO_BEFORE_ACTION */ 2869| 0| *yy_cp = (yy_hold_char); 2870| | 2871| | /* Backing-up info for compressed tables is taken \after/ */ 2872| | /* yy_cp has been incremented for the next state. */ 2873| 0| yy_cp = (yy_last_accepting_cpos); 2874| | 2875| 0| yy_current_state = (yy_last_accepting_state); 2876| 0| goto yy_find_action; 2877| | 2878| |/* %% [5.0] user actions get inserted here */ 2879| | 2880| 2| case 1: ------------------ | Branch (2880:2): [True: 2, False: 11.9M] ------------------ 2881| 2|YY_RULE_SETUP ------------------ | | 2732| 2| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 2, False: 0] | | ------------------ | | 2733| 2| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 2| } \ | | 2735| 2| YY_USER_ACTION ------------------ 2882| | 2883| 2|#line 168 "./scan.l" 2884| 2|START_CODEBLOCK(true); ------------------ | | 2473| 2|#define START_CODEBLOCK(x) do { \ | | 2474| 2| /* Emit the needed line directive... */\ | | 2475| 2| if (indented_code == false) { \ | | ------------------ | | | Branch (2475:9): [True: 1, False: 1] | | ------------------ | | 2476| 1| linenum++; \ | | 2477| 1| line_directive_out(NULL, infilename, linenum); \ | | 2478| 1| } \ | | 2479| 2| add_action(M4QSTART); \ | | ------------------ | | | | 2424| 2|#define M4QSTART "[""[" | | ------------------ | | 2480| 2| yy_push_state(CODEBLOCK); \ | | ------------------ | | | | 2503| 2|#define CODEBLOCK 4 | | ------------------ | | 2481| 2| if ((indented_code = x)) ACTION_ECHO; \ | | ------------------ | | | | 2430| 2|#define ACTION_ECHO add_action( yytext ) | | ------------------ | | | Branch (2481:9): [True: 2, False: 0] | | ------------------ | | 2482| 2|} while(0) | | ------------------ | | | Branch (2482:9): [Folded - Ignored] | | ------------------ ------------------ 2885| 2| /*LINTED*/break; 2886| 0| case 2: ------------------ | Branch (2886:2): [True: 0, False: 11.9M] ------------------ 2887| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2888| | 2889| 0|#line 169 "./scan.l" 2890| 0|add_action("/*[""["); yy_push_state( COMMENT ); ------------------ | | 2513| 0|#define COMMENT 14 ------------------ 2891| 0| /*LINTED*/break; 2892| 0| case 3: ------------------ | Branch (2892:2): [True: 0, False: 11.9M] ------------------ 2893| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2894| | 2895| 0|#line 170 "./scan.l" 2896| 0|yy_push_state( LINEDIR ); ------------------ | | 2517| 0|#define LINEDIR 18 ------------------ 2897| 0| /*LINTED*/break; 2898| 0| case 4: ------------------ | Branch (2898:2): [True: 0, False: 11.9M] ------------------ 2899| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2900| | 2901| 0|#line 171 "./scan.l" 2902| 0|return SCDECL; ------------------ | | 112| 0|#define SCDECL 261 ------------------ 2903| 0| /*LINTED*/break; 2904| 0| case 5: ------------------ | Branch (2904:2): [True: 0, False: 11.9M] ------------------ 2905| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2906| | 2907| 0|#line 172 "./scan.l" 2908| 0|return XSCDECL; ------------------ | | 113| 0|#define XSCDECL 262 ------------------ 2909| 0| /*LINTED*/break; 2910| 0| case 6: ------------------ | Branch (2910:2): [True: 0, False: 11.9M] ------------------ 2911| |/* rule 6 can match eol */ 2912| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2913| | 2914| 0|#line 173 "./scan.l" 2915| 0|START_CODEBLOCK(false); ------------------ | | 2473| 0|#define START_CODEBLOCK(x) do { \ | | 2474| 0| /* Emit the needed line directive... */\ | | 2475| 0| if (indented_code == false) { \ | | ------------------ | | | Branch (2475:9): [True: 0, False: 0] | | ------------------ | | 2476| 0| linenum++; \ | | 2477| 0| line_directive_out(NULL, infilename, linenum); \ | | 2478| 0| } \ | | 2479| 0| add_action(M4QSTART); \ | | ------------------ | | | | 2424| 0|#define M4QSTART "[""[" | | ------------------ | | 2480| 0| yy_push_state(CODEBLOCK); \ | | ------------------ | | | | 2503| 0|#define CODEBLOCK 4 | | ------------------ | | 2481| 0| if ((indented_code = x)) ACTION_ECHO; \ | | ------------------ | | | | 2430| 0|#define ACTION_ECHO add_action( yytext ) | | ------------------ | | | Branch (2481:9): [True: 0, False: 0] | | ------------------ | | 2482| 0|} while(0) | | ------------------ | | | Branch (2482:9): [Folded - Ignored] | | ------------------ ------------------ 2916| 0| /*LINTED*/break; 2917| 0| case 7: ------------------ | Branch (2917:2): [True: 0, False: 11.9M] ------------------ 2918| |/* rule 7 can match eol */ 2919| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2920| | 2921| 0|#line 174 "./scan.l" 2922| 0|{ 2923| 0| char trampoline[512]; 2924| 0| brace_start_line = linenum; 2925| 0| ++linenum; 2926| 0| snprintf(trampoline, sizeof(trampoline), 2927| 0| "M4_HOOK_TRACE_LINE_FORMAT(%d, [[%s]])", 2928| 0| linenum, infilename?infilename:""); ------------------ | Branch (2928:14): [True: 0, False: 0] ------------------ 2929| 0| buf_strappend(&top_buf, trampoline); 2930| 0| brace_depth = 1; 2931| 0| yy_push_state(CODEBLOCK_MATCH_BRACE); ------------------ | | 2518| 0|#define CODEBLOCK_MATCH_BRACE 19 ------------------ 2932| 0| } 2933| 0| /*LINTED*/break; 2934| 0| case 8: ------------------ | Branch (2934:2): [True: 0, False: 11.9M] ------------------ 2935| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2936| | 2937| 0|#line 186 "./scan.l" 2938| 0|synerr( _("malformed '%top' directive") ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 2939| 0| /*LINTED*/break; 2940| 1| case 9: ------------------ | Branch (2940:2): [True: 1, False: 11.9M] ------------------ 2941| 1|YY_RULE_SETUP ------------------ | | 2732| 1| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 1, False: 0] | | ------------------ | | 2733| 1| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 1| } \ | | 2735| 1| YY_USER_ACTION ------------------ 2942| | 2943| 1|#line 188 "./scan.l" 2944| |/* discard */ 2945| 1| /*LINTED*/break; 2946| 1| case 10: ------------------ | Branch (2946:2): [True: 1, False: 11.9M] ------------------ 2947| 1|YY_RULE_SETUP ------------------ | | 2732| 1| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 1, False: 0] | | ------------------ | | 2733| 1| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 1| } \ | | 2735| 1| YY_USER_ACTION ------------------ 2948| | 2949| 1|#line 190 "./scan.l" 2950| 1|{ 2951| 1| sectnum = 2; 2952| 1| bracelevel = 0; 2953| 1| mark_defs1(); 2954| 1| line_directive_out(NULL, infilename, linenum); 2955| 1| BEGIN(SECT2PROLOG); ------------------ | | 233| 1|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2PROLOG); ------------------ | | 2501| 1|#define SECT2PROLOG 2 ------------------ 2956| 1| return SECTEND; ------------------ | | 111| 1|#define SECTEND 260 ------------------ 2957| 0| } 2958| 0| /*LINTED*/break; 2959| 0| case 11: ------------------ | Branch (2959:2): [True: 0, False: 11.9M] ------------------ 2960| |/* rule 11 can match eol */ 2961| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2962| | 2963| 0|#line 199 "./scan.l" 2964| 0|ctrl.yytext_is_array = false; ++linenum; 2965| 0| /*LINTED*/break; 2966| 0| case 12: ------------------ | Branch (2966:2): [True: 0, False: 11.9M] ------------------ 2967| |/* rule 12 can match eol */ 2968| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2969| | 2970| 0|#line 200 "./scan.l" 2971| 0|ctrl.yytext_is_array = true; ++linenum; 2972| 0| /*LINTED*/break; 2973| 0| case 13: ------------------ | Branch (2973:2): [True: 0, False: 11.9M] ------------------ 2974| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2975| | 2976| 0|#line 202 "./scan.l" 2977| 0|BEGIN(OPTION); return TOK_OPTION; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(OPTION); return TOK_OPTION; ------------------ | | 2516| 0|#define OPTION 17 ------------------ BEGIN(OPTION); return TOK_OPTION; ------------------ | | 117| 0|#define TOK_OPTION 266 ------------------ 2978| 0| /*LINTED*/break; 2979| 0| case 14: ------------------ | Branch (2979:2): [True: 0, False: 11.9M] ------------------ 2980| |/* rule 14 can match eol */ 2981| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2982| | 2983| 0|#line 204 "./scan.l" 2984| 0|++linenum; /* ignore */ 2985| 0| /*LINTED*/break; 2986| 0| case 15: ------------------ | Branch (2986:2): [True: 0, False: 11.9M] ------------------ 2987| |/* rule 15 can match eol */ 2988| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 2989| | 2990| 0|#line 205 "./scan.l" 2991| 0|++linenum; /* ignore */ 2992| 0| /*LINTED*/break; 2993| |/* xgettext: no-c-format */ 2994| 1| case 16: ------------------ | Branch (2994:2): [True: 1, False: 11.9M] ------------------ 2995| |/* rule 16 can match eol */ 2996| 1|YY_RULE_SETUP ------------------ | | 2732| 1| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 1, False: 0] | | ------------------ | | 2733| 1| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 1| } \ | | 2735| 1| YY_USER_ACTION ------------------ 2997| | 2998| 1|#line 208 "./scan.l" 2999| 1|synerr( _( "unrecognized '%' directive" ) ); ------------------ | | 85| 1|#define _(String) gettext (String) ------------------ 3000| 1| /*LINTED*/break; 3001| 6| case 17: ------------------ | Branch (3001:2): [True: 6, False: 11.9M] ------------------ 3002| 6|YY_RULE_SETUP ------------------ | | 2732| 6| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 6, False: 0] | | ------------------ | | 2733| 6| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 6|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 6| } \ | | 2735| 6| YY_USER_ACTION ------------------ 3003| | 3004| 6|#line 210 "./scan.l" 3005| 6|{ 3006| 6| if(yyleng < MAXLINE) ------------------ | | 99| 6|#define MAXLINE 2048 ------------------ | Branch (3006:7): [True: 6, False: 0] ------------------ 3007| 6| { 3008| 6| strncpy( nmstr, yytext, sizeof(nmstr) ); 3009| 6| } 3010| 0| else 3011| 0| { 3012| 0| synerr( _("Definition name too long\n")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 3013| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 3014| 0| } 3015| | 3016| 6| didadef = false; 3017| 6| BEGIN(PICKUPDEF); ------------------ | | 233| 6|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(PICKUPDEF); ------------------ | | 2504| 6|#define PICKUPDEF 5 ------------------ 3018| 6| } 3019| 0| /*LINTED*/break; 3020| 1| case 18: ------------------ | Branch (3020:2): [True: 1, False: 11.9M] ------------------ 3021| 1|YY_RULE_SETUP ------------------ | | 2732| 1| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 1, False: 0] | | ------------------ | | 2733| 1| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 1| } \ | | 2735| 1| YY_USER_ACTION ------------------ 3022| | 3023| 1|#line 225 "./scan.l" 3024| 1|RETURNNAME; ------------------ | | 2444| 1| if(yyleng < MAXLINE) \ | | ------------------ | | | | 99| 1|#define MAXLINE 2048 | | ------------------ | | | Branch (2444:5): [True: 1, False: 0] | | ------------------ | | 2445| 1| { \ | | 2446| 1| strncpy( nmstr, yytext, sizeof(nmstr) ); \ | | 2447| 1| return NAME; \ | | ------------------ | | | | 114| 1|#define NAME 263 | | ------------------ | | 2448| 1| } \ | | 2449| 1| else \ | | 2450| 1| do { \ | | 2451| 0| synerr(_("Input line too long\n")); \ | | ------------------ | | | | 85| 0|#define _(String) gettext (String) | | ------------------ | | 2452| 0| FLEX_EXIT(EXIT_FAILURE); \ | | ------------------ | | | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) | | ------------------ | | 2453| 0| } while (0) | | ------------------ | | | Branch (2453:12): [Folded - Ignored] | | ------------------ ------------------ 3025| 0| /*LINTED*/break; 3026| 4| case 19: ------------------ | Branch (3026:2): [True: 4, False: 11.9M] ------------------ 3027| |/* rule 19 can match eol */ 3028| 4|YY_RULE_SETUP ------------------ | | 2732| 4| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 4, False: 0] | | ------------------ | | 2733| 4| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 4|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 4| } \ | | 2735| 4| YY_USER_ACTION ------------------ 3029| | 3030| 4|#line 226 "./scan.l" 3031| 4|++linenum; /* allows blank lines in section 1 */ 3032| 4| /*LINTED*/break; 3033| 2| case 20: ------------------ | Branch (3033:2): [True: 2, False: 11.9M] ------------------ 3034| |/* rule 20 can match eol */ 3035| 2|YY_RULE_SETUP ------------------ | | 2732| 2| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 2, False: 0] | | ------------------ | | 2733| 2| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 2| } \ | | 2735| 2| YY_USER_ACTION ------------------ 3036| | 3037| 2|#line 227 "./scan.l" 3038| 2|ACTION_ECHO; ++linenum; /* maybe end of comment line */ ------------------ | | 2430| 2|#define ACTION_ECHO add_action( yytext ) ------------------ 3039| 2| /*LINTED*/break; 3040| | 3041| |/* */ 3042| 85.9k| case 21: ------------------ | Branch (3042:2): [True: 85.9k, False: 11.8M] ------------------ 3043| 85.9k|YY_RULE_SETUP ------------------ | | 2732| 85.9k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 85.9k, False: 0] | | ------------------ | | 2733| 85.9k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 85.9k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 85.9k| } \ | | 2735| 85.9k| YY_USER_ACTION ------------------ 3044| | 3045| 85.9k|#line 232 "./scan.l" 3046| 85.9k|ACTION_ECHO; ------------------ | | 2430| 85.9k|#define ACTION_ECHO add_action( yytext ) ------------------ 3047| 85.9k| /*LINTED*/break; 3048| 40.1k| case 22: ------------------ | Branch (3048:2): [True: 40.1k, False: 11.8M] ------------------ 3049| 40.1k|YY_RULE_SETUP ------------------ | | 2732| 40.1k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 40.1k, False: 0] | | ------------------ | | 2733| 40.1k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 40.1k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 40.1k| } \ | | 2735| 40.1k| YY_USER_ACTION ------------------ 3050| | 3051| 40.1k|#line 233 "./scan.l" 3052| 40.1k|ACTION_ECHO; ------------------ | | 2430| 40.1k|#define ACTION_ECHO add_action( yytext ) ------------------ 3053| 40.1k| /*LINTED*/break; 3054| 157k| case 23: ------------------ | Branch (3054:2): [True: 157k, False: 11.7M] ------------------ 3055| |/* rule 23 can match eol */ 3056| 157k|YY_RULE_SETUP ------------------ | | 2732| 157k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 157k, False: 0] | | ------------------ | | 2733| 157k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 157k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 157k| } \ | | 2735| 157k| YY_USER_ACTION ------------------ 3057| | 3058| 157k|#line 235 "./scan.l" 3059| 157k|++linenum; ACTION_ECHO; ------------------ | | 2430| 157k|#define ACTION_ECHO add_action( yytext ) ------------------ 3060| 157k| /*LINTED*/break; 3061| | 3062| | 3063| 0| case 24: ------------------ | Branch (3063:2): [True: 0, False: 11.9M] ------------------ 3064| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3065| | 3066| 0|#line 238 "./scan.l" 3067| 0|add_action("*/]""]"); yy_pop_state(); 3068| 0| /*LINTED*/break; 3069| | 3070| | 3071| 1.28k| case 25: ------------------ | Branch (3071:2): [True: 1.28k, False: 11.9M] ------------------ 3072| 1.28k|YY_RULE_SETUP ------------------ | | 2732| 1.28k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 1.28k, False: 0] | | ------------------ | | 2733| 1.28k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 1.28k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 1.28k| } \ | | 2735| 1.28k| YY_USER_ACTION ------------------ 3073| | 3074| 1.28k|#line 241 "./scan.l" 3075| 1.28k|ACTION_ECHO; yy_pop_state(); ------------------ | | 2430| 1.28k|#define ACTION_ECHO add_action( yytext ) ------------------ 3076| 1.28k| /*LINTED*/break; 3077| | 3078| | 3079| |/* This is the same as COMMENT, but is discarded rather than output. */ 3080| 0| case 26: ------------------ | Branch (3080:2): [True: 0, False: 11.9M] ------------------ 3081| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3082| | 3083| 0|#line 246 "./scan.l" 3084| 0|yy_pop_state(); 3085| 0| /*LINTED*/break; 3086| 0| case 27: ------------------ | Branch (3086:2): [True: 0, False: 11.9M] ------------------ 3087| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3088| | 3089| 0|#line 247 "./scan.l" 3090| 0|; 3091| 0| /*LINTED*/break; 3092| 0| case 28: ------------------ | Branch (3092:2): [True: 0, False: 11.9M] ------------------ 3093| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3094| | 3095| 0|#line 248 "./scan.l" 3096| 0|; 3097| 0| /*LINTED*/break; 3098| 0| case 29: ------------------ | Branch (3098:2): [True: 0, False: 11.9M] ------------------ 3099| |/* rule 29 can match eol */ 3100| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3101| | 3102| 0|#line 249 "./scan.l" 3103| 0|++linenum; 3104| 0| /*LINTED*/break; 3105| | 3106| | 3107| 0| case 30: ------------------ | Branch (3107:2): [True: 0, False: 11.9M] ------------------ 3108| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3109| | 3110| 0|#line 253 "./scan.l" 3111| 0|yy_pop_state(); 3112| 0| /*LINTED*/break; 3113| 0| case 31: ------------------ | Branch (3113:2): [True: 0, False: 11.9M] ------------------ 3114| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3115| | 3116| 0|#line 254 "./scan.l" 3117| 0|; 3118| 0| /*LINTED*/break; 3119| 0| case 32: ------------------ | Branch (3119:2): [True: 0, False: 11.9M] ------------------ 3120| |/* rule 32 can match eol */ 3121| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3122| | 3123| 0|#line 255 "./scan.l" 3124| 0|++linenum; 3125| 0| /*LINTED*/break; 3126| | 3127| | 3128| 0| case 33: ------------------ | Branch (3128:2): [True: 0, False: 11.9M] ------------------ 3129| |/* rule 33 can match eol */ 3130| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3131| | 3132| 0|#line 259 "./scan.l" 3133| 0|yy_pop_state(); 3134| 0| /*LINTED*/break; 3135| 0| case 34: ------------------ | Branch (3135:2): [True: 0, False: 11.9M] ------------------ 3136| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3137| | 3138| 0|#line 260 "./scan.l" 3139| 0|linenum = myctoi( yytext ); 3140| 0| /*LINTED*/break; 3141| 0| case 35: ------------------ | Branch (3141:2): [True: 0, False: 11.9M] ------------------ 3142| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3143| | 3144| 0|#line 262 "./scan.l" 3145| 0|{ 3146| 0| free(infilename); 3147| 0| infilename = xstrdup(yytext + 1); 3148| 0| infilename[strlen( infilename ) - 1] = '\0'; 3149| 0| } 3150| 0| /*LINTED*/break; 3151| 0| case 36: ------------------ | Branch (3151:2): [True: 0, False: 11.9M] ------------------ 3152| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3153| | 3154| 0|#line 267 "./scan.l" 3155| |/* ignore spurious characters */ 3156| 0| /*LINTED*/break; 3157| | 3158| | 3159| 175k| case 37: ------------------ | Branch (3159:2): [True: 175k, False: 11.7M] ------------------ 3160| 175k|YY_RULE_SETUP ------------------ | | 2732| 175k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 175k, False: 0] | | ------------------ | | 2733| 175k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 175k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 175k| } \ | | 2735| 175k| YY_USER_ACTION ------------------ 3161| | 3162| 175k|#line 270 "./scan.l" 3163| 175k|ACTION_ECHO_QSTART; ------------------ | | 2431| 175k|#define ACTION_ECHO_QSTART add_action (ESCAPED_QSTART) | | ------------------ | | | | 2427| 175k|#define ESCAPED_QSTART "[" M4QEND M4QSTART "[" M4QEND M4QSTART | | | | ------------------ | | | | | | 2424| 175k|#define M4QSTART "[""[" | | | | ------------------ | | ------------------ ------------------ 3164| 175k| /*LINTED*/break; 3165| 26.3k| case 38: ------------------ | Branch (3165:2): [True: 26.3k, False: 11.8M] ------------------ 3166| 26.3k|YY_RULE_SETUP ------------------ | | 2732| 26.3k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 26.3k, False: 0] | | ------------------ | | 2733| 26.3k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 26.3k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 26.3k| } \ | | 2735| 26.3k| YY_USER_ACTION ------------------ 3167| | 3168| 26.3k|#line 271 "./scan.l" 3169| 26.3k|ACTION_ECHO_QEND; ------------------ | | 2432| 26.3k|#define ACTION_ECHO_QEND add_action (ESCAPED_QEND) | | ------------------ | | | | 2428| 26.3k|#define ESCAPED_QEND M4QEND "]" M4QSTART M4QEND "]" M4QSTART | | | | ------------------ | | | | | | 2425| 26.3k|#define M4QEND "]""]" | | | | ------------------ | | | | #define ESCAPED_QEND M4QEND "]" M4QSTART M4QEND "]" M4QSTART | | | | ------------------ | | | | | | 2424| 26.3k|#define M4QSTART "[""[" | | | | ------------------ | | ------------------ ------------------ 3170| 26.3k| /*LINTED*/break; 3171| | 3172| | 3173| 0| case 39: ------------------ | Branch (3173:2): [True: 0, False: 11.9M] ------------------ 3174| |/* rule 39 can match eol */ 3175| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3176| | 3177| 0|#line 275 "./scan.l" 3178| 0|++linenum; END_CODEBLOCK; ------------------ | | 2484| 0|#define END_CODEBLOCK do { \ | | 2485| 0| yy_pop_state();\ | | 2486| 0| add_action(M4QEND); \ | | ------------------ | | | | 2425| 0|#define M4QEND "]""]" | | ------------------ | | 2487| 0| if (!indented_code) line_directive_out(NULL, NULL, linenum); \ | | ------------------ | | | Branch (2487:9): [True: 0, False: 0] | | ------------------ | | 2488| 0|} while (0) | | ------------------ | | | Branch (2488:10): [Folded - Ignored] | | ------------------ ------------------ 3179| 0| /*LINTED*/break; 3180| 6| case 40: ------------------ | Branch (3180:2): [True: 6, False: 11.9M] ------------------ 3181| 6|YY_RULE_SETUP ------------------ | | 2732| 6| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 6, False: 0] | | ------------------ | | 2733| 6| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 6|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 6| } \ | | 2735| 6| YY_USER_ACTION ------------------ 3182| | 3183| 6|#line 276 "./scan.l" 3184| 6|ACTION_ECHO; ------------------ | | 2430| 6|#define ACTION_ECHO add_action( yytext ) ------------------ 3185| 6| /*LINTED*/break; 3186| 4| case 41: ------------------ | Branch (3186:2): [True: 4, False: 11.9M] ------------------ 3187| 4|YY_RULE_SETUP ------------------ | | 2732| 4| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 4, False: 0] | | ------------------ | | 2733| 4| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 4|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 4| } \ | | 2735| 4| YY_USER_ACTION ------------------ 3188| | 3189| 4|#line 277 "./scan.l" 3190| 4|ACTION_ECHO; ------------------ | | 2430| 4|#define ACTION_ECHO add_action( yytext ) ------------------ 3191| 4| /*LINTED*/break; 3192| 2| case 42: ------------------ | Branch (3192:2): [True: 2, False: 11.9M] ------------------ 3193| |/* rule 42 can match eol */ 3194| 2|YY_RULE_SETUP ------------------ | | 2732| 2| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 2, False: 0] | | ------------------ | | 2733| 2| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 2| } \ | | 2735| 2| YY_USER_ACTION ------------------ 3195| | 3196| 2|#line 278 "./scan.l" 3197| 2|{ 3198| 2| ++linenum; 3199| 2| ACTION_ECHO; ------------------ | | 2430| 2|#define ACTION_ECHO add_action( yytext ) ------------------ 3200| 2| if ( indented_code ) END_CODEBLOCK; ------------------ | | 2484| 2|#define END_CODEBLOCK do { \ | | 2485| 2| yy_pop_state();\ | | 2486| 2| add_action(M4QEND); \ | | ------------------ | | | | 2425| 2|#define M4QEND "]""]" | | ------------------ | | 2487| 2| if (!indented_code) line_directive_out(NULL, NULL, linenum); \ | | ------------------ | | | Branch (2487:9): [True: 0, False: 2] | | ------------------ | | 2488| 2|} while (0) | | ------------------ | | | Branch (2488:10): [Folded - Ignored] | | ------------------ ------------------ | Branch (3200:9): [True: 2, False: 0] ------------------ 3201| 2| } 3202| 2| /*LINTED*/break; 3203| | 3204| | 3205| 0| case 43: ------------------ | Branch (3205:2): [True: 0, False: 11.9M] ------------------ 3206| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3207| | 3208| 0|#line 286 "./scan.l" 3209| 0|{ 3210| 0| if( --brace_depth == 0){ ------------------ | Branch (3210:21): [True: 0, False: 0] ------------------ 3211| | /* TODO: Matched. */ 3212| 0| yy_pop_state(); 3213| 0| }else 3214| 0| buf_strnappend(&top_buf, yytext, yyleng); 3215| 0| } 3216| 0| /*LINTED*/break; 3217| 0| case 44: ------------------ | Branch (3217:2): [True: 0, False: 11.9M] ------------------ 3218| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3219| | 3220| 0|#line 294 "./scan.l" 3221| 0|{ 3222| 0| brace_depth++; 3223| 0| buf_strnappend(&top_buf, yytext, yyleng); 3224| 0| } 3225| 0| /*LINTED*/break; 3226| 0| case 45: ------------------ | Branch (3226:2): [True: 0, False: 11.9M] ------------------ 3227| |/* rule 45 can match eol */ 3228| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3229| | 3230| 0|#line 299 "./scan.l" 3231| 0|{ 3232| 0| ++linenum; 3233| 0| buf_strnappend(&top_buf, yytext, yyleng); 3234| 0| } 3235| 0| /*LINTED*/break; 3236| 0| case 46: ------------------ | Branch (3236:2): [True: 0, False: 11.9M] ------------------ 3237| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3238| | 3239| 0|#line 304 "./scan.l" 3240| 0|buf_strnappend(&top_buf, escaped_qstart, (int) strlen(escaped_qstart)); 3241| 0| /*LINTED*/break; 3242| 0| case 47: ------------------ | Branch (3242:2): [True: 0, False: 11.9M] ------------------ 3243| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3244| | 3245| 0|#line 305 "./scan.l" 3246| 0|buf_strnappend(&top_buf, escaped_qend, (int) strlen(escaped_qend)); 3247| 0| /*LINTED*/break; 3248| 0| case 48: ------------------ | Branch (3248:2): [True: 0, False: 11.9M] ------------------ 3249| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3250| | 3251| 0|#line 306 "./scan.l" 3252| 0|{ 3253| 0| buf_strnappend(&top_buf, yytext, yyleng); 3254| 0| } 3255| 0| /*LINTED*/break; 3256| 0|case YY_STATE_EOF(CODEBLOCK_MATCH_BRACE): ------------------ | | 243| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (3256:1): [True: 0, False: 11.9M] ------------------ 3257| 0|#line 310 "./scan.l" 3258| 0|{ 3259| 0| linenum = brace_start_line; 3260| 0| synerr(_("Unmatched '{'")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 3261| 0| return YY_NULL; ------------------ | | 187| 0|#define YY_NULL 0 ------------------ 3262| 1| } 3263| 0| /*LINTED*/break; 3264| | 3265| | 3266| 4| case 49: ------------------ | Branch (3266:2): [True: 4, False: 11.9M] ------------------ 3267| 4|YY_RULE_SETUP ------------------ | | 2732| 4| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 4, False: 0] | | ------------------ | | 2733| 4| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 4|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 4| } \ | | 2735| 4| YY_USER_ACTION ------------------ 3268| | 3269| 4|#line 319 "./scan.l" 3270| |/* separates name and definition */ 3271| 4| /*LINTED*/break; 3272| 22| case 50: ------------------ | Branch (3272:2): [True: 22, False: 11.9M] ------------------ 3273| 22|YY_RULE_SETUP ------------------ | | 2732| 22| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 22, False: 0] | | ------------------ | | 2733| 22| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 22|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 22| } \ | | 2735| 22| YY_USER_ACTION ------------------ 3274| | 3275| 22|#line 321 "./scan.l" 3276| 22|{ 3277| 22| if(yyleng < MAXLINE) ------------------ | | 99| 22|#define MAXLINE 2048 ------------------ | Branch (3277:15): [True: 22, False: 0] ------------------ 3278| 22| { 3279| 22| strncpy( nmdef, yytext, sizeof(nmdef) ); 3280| 22| } 3281| 0| else 3282| 0| { 3283| 0| format_synerr( _("Definition value for {%s} too long\n"), nmstr); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 3284| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 3285| 0| } 3286| | /* Skip trailing whitespace. */ 3287| 22| { 3288| 22| size_t i = strlen( nmdef ); 3289| 25| while (i > 0 && (nmdef[i-1] == ' ' || nmdef[i-1] == '\t')) ------------------ | Branch (3289:15): [True: 20, False: 5] | Branch (3289:25): [True: 0, False: 20] | Branch (3289:46): [True: 3, False: 17] ------------------ 3290| 3| --i; 3291| 22| nmdef[i] = '\0'; 3292| 22| } 3293| | 3294| 22| ndinstal( nmstr, nmdef ); 3295| 22| didadef = true; 3296| 22| } 3297| 0| /*LINTED*/break; 3298| 6| case 51: ------------------ | Branch (3298:2): [True: 6, False: 11.9M] ------------------ 3299| |/* rule 51 can match eol */ 3300| 6|YY_RULE_SETUP ------------------ | | 2732| 6| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 6, False: 0] | | ------------------ | | 2733| 6| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 6|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 6| } \ | | 2735| 6| YY_USER_ACTION ------------------ 3301| | 3302| 6|#line 343 "./scan.l" 3303| 6|{ 3304| 6| if ( ! didadef ) ------------------ | Branch (3304:9): [True: 1, False: 5] ------------------ 3305| 1| synerr( _( "incomplete name definition" ) ); ------------------ | | 85| 1|#define _(String) gettext (String) ------------------ 3306| 6| BEGIN(INITIAL); ------------------ | | 233| 6|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 2499| 6|#define INITIAL 0 ------------------ 3307| 6| ++linenum; 3308| 6| } 3309| 6| /*LINTED*/break; 3310| | 3311| | 3312| 0| case 52: ------------------ | Branch (3312:2): [True: 0, False: 11.9M] ------------------ 3313| |/* rule 52 can match eol */ 3314| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3315| | 3316| 0|#line 353 "./scan.l" 3317| 0|++linenum; BEGIN(INITIAL); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ ++linenum; BEGIN(INITIAL); ------------------ | | 2499| 0|#define INITIAL 0 ------------------ 3318| 0| /*LINTED*/break; 3319| 0| case 53: ------------------ | Branch (3319:2): [True: 0, False: 11.9M] ------------------ 3320| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3321| | 3322| 0|#line 354 "./scan.l" 3323| 0|option_sense = true; 3324| 0| /*LINTED*/break; 3325| 0| case 54: ------------------ | Branch (3325:2): [True: 0, False: 11.9M] ------------------ 3326| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3327| | 3328| 0|#line 356 "./scan.l" 3329| 0|return '='; 3330| 0| /*LINTED*/break; 3331| 0| case 55: ------------------ | Branch (3331:2): [True: 0, False: 11.9M] ------------------ 3332| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3333| | 3334| 0|#line 357 "./scan.l" 3335| 0|{nmval = atoi(yytext); return TOK_NUMERIC;} ------------------ | | 125| 0|#define TOK_NUMERIC 274 ------------------ 3336| 0| /*LINTED*/break; 3337| 0| case 56: ------------------ | Branch (3337:2): [True: 0, False: 11.9M] ------------------ 3338| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3339| | 3340| 0|#line 359 "./scan.l" 3341| 0|option_sense = ! option_sense; 3342| 0| /*LINTED*/break; 3343| 0| case 57: ------------------ | Branch (3343:2): [True: 0, False: 11.9M] ------------------ 3344| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3345| | 3346| 0|#line 361 "./scan.l" 3347| 0|ctrl.csize = option_sense ? 128 : 256; ------------------ | Branch (3347:14): [True: 0, False: 0] ------------------ 3348| 0| /*LINTED*/break; 3349| 0| case 58: ------------------ | Branch (3349:2): [True: 0, False: 11.9M] ------------------ 3350| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3351| | 3352| 0|#line 362 "./scan.l" 3353| 0|ctrl.csize = option_sense ? 256 : 128; ------------------ | Branch (3353:14): [True: 0, False: 0] ------------------ 3354| 0| /*LINTED*/break; 3355| 0| case 59: ------------------ | Branch (3355:2): [True: 0, False: 11.9M] ------------------ 3356| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3357| | 3358| 0|#line 364 "./scan.l" 3359| 0|ctrl.long_align = option_sense; 3360| 0| /*LINTED*/break; 3361| 0| case 60: ------------------ | Branch (3361:2): [True: 0, False: 11.9M] ------------------ 3362| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3363| | 3364| 0|#line 365 "./scan.l" 3365| 0|{ 3366| 0| ctrl.always_interactive = option_sense; 3367| 0| ctrl.interactive = (trit)option_sense; 3368| 0| } 3369| 0| /*LINTED*/break; 3370| 0| case 61: ------------------ | Branch (3370:2): [True: 0, False: 11.9M] ------------------ 3371| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3372| | 3373| 0|#line 369 "./scan.l" 3374| 0|ctrl.yytext_is_array = option_sense; 3375| 0| /*LINTED*/break; 3376| 0| case 62: ------------------ | Branch (3376:2): [True: 0, False: 11.9M] ------------------ 3377| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3378| | 3379| 0|#line 370 "./scan.l" 3380| 0|env.backing_up_report = option_sense; 3381| 0| /*LINTED*/break; 3382| 0| case 63: ------------------ | Branch (3382:2): [True: 0, False: 11.9M] ------------------ 3383| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3384| | 3385| 0|#line 371 "./scan.l" 3386| 0|ctrl.interactive = (trit)!option_sense; 3387| 0| /*LINTED*/break; 3388| 0| case 64: ------------------ | Branch (3388:2): [True: 0, False: 11.9M] ------------------ 3389| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3390| | 3391| 0|#line 372 "./scan.l" 3392| 0|ctrl.bison_bridge_lval = option_sense; 3393| 0| /*LINTED*/break; 3394| 0| case 65: ------------------ | Branch (3394:2): [True: 0, False: 11.9M] ------------------ 3395| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3396| | 3397| 0|#line 373 "./scan.l" 3398| 0|{ if((ctrl.bison_bridge_lloc = option_sense)) ------------------ | Branch (3398:6): [True: 0, False: 0] ------------------ 3399| 0| ctrl.bison_bridge_lval = true; 3400| 0| } 3401| 0| /*LINTED*/break; 3402| 0| case 66: ------------------ | Branch (3402:2): [True: 0, False: 11.9M] ------------------ 3403| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3404| | 3405| 0|#line 376 "./scan.l" 3406| 0|ctrl.C_plus_plus = option_sense; 3407| 0| /*LINTED*/break; 3408| 0| case 67: ------------------ | Branch (3408:2): [True: 0, False: 11.9M] ------------------ 3409| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3410| | 3411| 0|#line 377 "./scan.l" 3412| 0|sf_set_case_ins(!option_sense); ------------------ | | 1208| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 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)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1208:34): [True: 0, False: 0] | | ------------------ ------------------ 3413| 0| /*LINTED*/break; 3414| 0| case 68: ------------------ | Branch (3414:2): [True: 0, False: 11.9M] ------------------ 3415| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3416| | 3417| 0|#line 378 "./scan.l" 3418| 0|sf_set_case_ins(option_sense); ------------------ | | 1208| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 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)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1208:34): [True: 0, False: 0] | | ------------------ ------------------ 3419| 0| /*LINTED*/break; 3420| 0| case 69: ------------------ | Branch (3420:2): [True: 0, False: 11.9M] ------------------ 3421| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3422| | 3423| 0|#line 379 "./scan.l" 3424| 0|ctrl.ddebug = option_sense; 3425| 0| /*LINTED*/break; 3426| 0| case 70: ------------------ | Branch (3426:2): [True: 0, False: 11.9M] ------------------ 3427| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3428| | 3429| 0|#line 380 "./scan.l" 3430| 0|ctrl.spprdflt = ! option_sense; 3431| 0| /*LINTED*/break; 3432| 0| case 71: ------------------ | Branch (3432:2): [True: 0, False: 11.9M] ------------------ 3433| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3434| | 3435| 0|#line 381 "./scan.l" 3436| 0|ctrl.useecs = option_sense; 3437| 0| /*LINTED*/break; 3438| 0| case 72: ------------------ | Branch (3438:2): [True: 0, False: 11.9M] ------------------ 3439| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3440| | 3441| 0|#line 382 "./scan.l" 3442| 0|{ 3443| 0| ctrl.useecs = ctrl.usemecs = false; 3444| 0| ctrl.use_read = ctrl.fullspd = true; 3445| 0| } 3446| 0| /*LINTED*/break; 3447| 0| case 73: ------------------ | Branch (3447:2): [True: 0, False: 11.9M] ------------------ 3448| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3449| | 3450| 0|#line 386 "./scan.l" 3451| 0|{ 3452| 0| ctrl.useecs = ctrl.usemecs = false; 3453| 0| ctrl.use_read = ctrl.fulltbl = true; 3454| 0| } 3455| 0| /*LINTED*/break; 3456| 0| case 74: ------------------ | Branch (3456:2): [True: 0, False: 11.9M] ------------------ 3457| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3458| | 3459| 0|#line 390 "./scan.l" 3460| 0|ctrl.no_yyinput = ! option_sense; 3461| 0| /*LINTED*/break; 3462| 0| case 75: ------------------ | Branch (3462:2): [True: 0, False: 11.9M] ------------------ 3463| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3464| | 3465| 0|#line 391 "./scan.l" 3466| 0|ctrl.no_yyinput = ! option_sense; 3467| 0| /*LINTED*/break; 3468| 0| case 76: ------------------ | Branch (3468:2): [True: 0, False: 11.9M] ------------------ 3469| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3470| | 3471| 0|#line 392 "./scan.l" 3472| 0|ctrl.interactive = (trit)option_sense; 3473| 0| /*LINTED*/break; 3474| 0| case 77: ------------------ | Branch (3474:2): [True: 0, False: 11.9M] ------------------ 3475| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3476| | 3477| 0|#line 393 "./scan.l" 3478| 0|ctrl.lex_compat = option_sense; 3479| 0| /*LINTED*/break; 3480| 0| case 78: ------------------ | Branch (3480:2): [True: 0, False: 11.9M] ------------------ 3481| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3482| | 3483| 0|#line 394 "./scan.l" 3484| 0|ctrl.posix_compat = option_sense; 3485| 0| /*LINTED*/break; 3486| 0| case 79: ------------------ | Branch (3486:2): [True: 0, False: 11.9M] ------------------ 3487| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3488| | 3489| 0|#line 395 "./scan.l" 3490| 0|ctrl.gen_line_dirs = option_sense; 3491| 0| /*LINTED*/break; 3492| 0| case 80: ------------------ | Branch (3492:2): [True: 0, False: 11.9M] ------------------ 3493| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3494| | 3495| 0|#line 396 "./scan.l" 3496| 0|{ 3497| 0| ctrl.do_main = option_sense; 3498| | /* Override yywrap */ 3499| 0| if( option_sense == true ) ------------------ | Branch (3499:8): [True: 0, False: 0] ------------------ 3500| 0| ctrl.do_yywrap = false; 3501| 0| } 3502| 0| /*LINTED*/break; 3503| 0| case 81: ------------------ | Branch (3503:2): [True: 0, False: 11.9M] ------------------ 3504| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3505| | 3506| 0|#line 402 "./scan.l" 3507| 0|ctrl.usemecs = option_sense; 3508| 0| /*LINTED*/break; 3509| 0| case 82: ------------------ | Branch (3509:2): [True: 0, False: 11.9M] ------------------ 3510| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3511| | 3512| 0|#line 403 "./scan.l" 3513| 0|{ 3514| 0| ctrl.never_interactive = option_sense; 3515| 0| ctrl.interactive = (trit)!option_sense; 3516| 0| } 3517| 0| /*LINTED*/break; 3518| 0| case 83: ------------------ | Branch (3518:2): [True: 0, False: 11.9M] ------------------ 3519| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3520| | 3521| 0|#line 407 "./scan.l" 3522| 0|env.performance_hint += option_sense ? 1 : -1; ------------------ | Branch (3522:25): [True: 0, False: 0] ------------------ 3523| 0| /*LINTED*/break; 3524| 0| case 84: ------------------ | Branch (3524:2): [True: 0, False: 11.9M] ------------------ 3525| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3526| | 3527| 0|#line 408 "./scan.l" 3528| 0|ctrl.yytext_is_array = ! option_sense; 3529| 0| /*LINTED*/break; 3530| 0| case 85: ------------------ | Branch (3530:2): [True: 0, False: 11.9M] ------------------ 3531| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3532| | 3533| 0|#line 409 "./scan.l" 3534| 0|ctrl.use_read = option_sense; 3535| 0| /*LINTED*/break; 3536| 0| case 86: ------------------ | Branch (3536:2): [True: 0, False: 11.9M] ------------------ 3537| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3538| | 3539| 0|#line 410 "./scan.l" 3540| 0|ctrl.reentrant = option_sense; 3541| 0| /*LINTED*/break; 3542| 0| case 87: ------------------ | Branch (3542:2): [True: 0, False: 11.9M] ------------------ 3543| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3544| | 3545| 0|#line 411 "./scan.l" 3546| 0|ctrl.reject_really_used = option_sense; 3547| 0| /*LINTED*/break; 3548| 0| case 88: ------------------ | Branch (3548:2): [True: 0, False: 11.9M] ------------------ 3549| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3550| | 3551| 0|#line 412 "./scan.l" 3552| 0|ctrl.rewrite = option_sense; 3553| 0| /*LINTED*/break; 3554| 0| case 89: ------------------ | Branch (3554:2): [True: 0, False: 11.9M] ------------------ 3555| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3556| | 3557| 0|#line 413 "./scan.l" 3558| 0|ctrl.stack_used = option_sense; 3559| 0| /*LINTED*/break; 3560| 0| case 90: ------------------ | Branch (3560:2): [True: 0, False: 11.9M] ------------------ 3561| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3562| | 3563| 0|#line 414 "./scan.l" 3564| 0|ctrl.do_stdinit = option_sense; 3565| 0| /*LINTED*/break; 3566| 0| case 91: ------------------ | Branch (3566:2): [True: 0, False: 11.9M] ------------------ 3567| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3568| | 3569| 0|#line 415 "./scan.l" 3570| 0|env.use_stdout = option_sense; 3571| 0| /*LINTED*/break; 3572| 0| case 92: ------------------ | Branch (3572:2): [True: 0, False: 11.9M] ------------------ 3573| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3574| | 3575| 0|#line 416 "./scan.l" 3576| 0|ctrl.no_unistd = ! option_sense; 3577| 0| /*LINTED*/break; 3578| 0| case 93: ------------------ | Branch (3578:2): [True: 0, False: 11.9M] ------------------ 3579| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3580| | 3581| 0|#line 417 "./scan.l" 3582| 0|ctrl.no_yyunput = ! option_sense; 3583| 0| /*LINTED*/break; 3584| 0| case 94: ------------------ | Branch (3584:2): [True: 0, False: 11.9M] ------------------ 3585| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3586| | 3587| 0|#line 418 "./scan.l" 3588| 0|ctrl.no_yyunput = ! option_sense; 3589| 0| /*LINTED*/break; 3590| 0| case 95: ------------------ | Branch (3590:2): [True: 0, False: 11.9M] ------------------ 3591| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3592| | 3593| 0|#line 419 "./scan.l" 3594| 0|env.printstats = option_sense; 3595| 0| /*LINTED*/break; 3596| 0| case 96: ------------------ | Branch (3596:2): [True: 0, False: 11.9M] ------------------ 3597| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3598| | 3599| 0|#line 420 "./scan.l" 3600| 0|env.nowarn = ! option_sense; 3601| 0| /*LINTED*/break; 3602| 0| case 97: ------------------ | Branch (3602:2): [True: 0, False: 11.9M] ------------------ 3603| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3604| | 3605| 0|#line 421 "./scan.l" 3606| 0|ctrl.do_yylineno = option_sense; 3607| 0| /*LINTED*/break; 3608| 0| case 98: ------------------ | Branch (3608:2): [True: 0, False: 11.9M] ------------------ 3609| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3610| | 3611| 0|#line 422 "./scan.l" 3612| 0|ctrl.yymore_really_used = option_sense; 3613| 0| /*LINTED*/break; 3614| 0| case 99: ------------------ | Branch (3614:2): [True: 0, False: 11.9M] ------------------ 3615| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3616| | 3617| 0|#line 423 "./scan.l" 3618| 0|ctrl.do_yywrap = option_sense; 3619| 0| /*LINTED*/break; 3620| 0| case 100: ------------------ | Branch (3620:2): [True: 0, False: 11.9M] ------------------ 3621| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3622| | 3623| 0|#line 424 "./scan.l" 3624| 0|ctrl.noyyread = !option_sense; 3625| 0| /*LINTED*/break; 3626| 0| case 101: ------------------ | Branch (3626:2): [True: 0, False: 11.9M] ------------------ 3627| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3628| | 3629| 0|#line 426 "./scan.l" 3630| 0|ctrl.no_yypanic = !option_sense; 3631| 0| /*LINTED*/break; 3632| 0| case 102: ------------------ | Branch (3632:2): [True: 0, False: 11.9M] ------------------ 3633| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3634| | 3635| 0|#line 428 "./scan.l" 3636| 0|ctrl.no_yy_push_state = ! option_sense; 3637| 0| /*LINTED*/break; 3638| 0| case 103: ------------------ | Branch (3638:2): [True: 0, False: 11.9M] ------------------ 3639| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3640| | 3641| 0|#line 429 "./scan.l" 3642| 0|ctrl.no_yy_pop_state = ! option_sense; 3643| 0| /*LINTED*/break; 3644| 0| case 104: ------------------ | Branch (3644:2): [True: 0, False: 11.9M] ------------------ 3645| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3646| | 3647| 0|#line 430 "./scan.l" 3648| 0|ctrl.no_yy_top_state = ! option_sense; 3649| 0| /*LINTED*/break; 3650| 0| case 105: ------------------ | Branch (3650:2): [True: 0, False: 11.9M] ------------------ 3651| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3652| | 3653| 0|#line 432 "./scan.l" 3654| 0|ctrl.no_yy_scan_buffer = ! option_sense; 3655| 0| /*LINTED*/break; 3656| 0| case 106: ------------------ | Branch (3656:2): [True: 0, False: 11.9M] ------------------ 3657| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3658| | 3659| 0|#line 433 "./scan.l" 3660| 0|ctrl.no_yy_scan_bytes = ! option_sense; 3661| 0| /*LINTED*/break; 3662| 0| case 107: ------------------ | Branch (3662:2): [True: 0, False: 11.9M] ------------------ 3663| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3664| | 3665| 0|#line 434 "./scan.l" 3666| 0|ctrl.no_yy_scan_string = ! option_sense; 3667| 0| /*LINTED*/break; 3668| 0| case 108: ------------------ | Branch (3668:2): [True: 0, False: 11.9M] ------------------ 3669| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3670| | 3671| 0|#line 436 "./scan.l" 3672| 0|ctrl.no_flex_alloc = ! option_sense; 3673| 0| /*LINTED*/break; 3674| 0| case 109: ------------------ | Branch (3674:2): [True: 0, False: 11.9M] ------------------ 3675| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3676| | 3677| 0|#line 437 "./scan.l" 3678| 0|ctrl.no_flex_realloc = ! option_sense; 3679| 0| /*LINTED*/break; 3680| 0| case 110: ------------------ | Branch (3680:2): [True: 0, False: 11.9M] ------------------ 3681| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3682| | 3683| 0|#line 438 "./scan.l" 3684| 0|ctrl.no_flex_free = ! option_sense; 3685| 0| /*LINTED*/break; 3686| 0| case 111: ------------------ | Branch (3686:2): [True: 0, False: 11.9M] ------------------ 3687| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3688| | 3689| 0|#line 440 "./scan.l" 3690| 0|ctrl.no_get_debug = ! option_sense; 3691| 0| /*LINTED*/break; 3692| 0| case 112: ------------------ | Branch (3692:2): [True: 0, False: 11.9M] ------------------ 3693| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3694| | 3695| 0|#line 441 "./scan.l" 3696| 0|ctrl.no_set_debug = ! option_sense; 3697| 0| /*LINTED*/break; 3698| 0| case 113: ------------------ | Branch (3698:2): [True: 0, False: 11.9M] ------------------ 3699| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3700| | 3701| 0|#line 442 "./scan.l" 3702| 0|ctrl.no_yyget_extra = ! option_sense; 3703| 0| /*LINTED*/break; 3704| 0| case 114: ------------------ | Branch (3704:2): [True: 0, False: 11.9M] ------------------ 3705| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3706| | 3707| 0|#line 443 "./scan.l" 3708| 0|ctrl.no_yyset_extra = ! option_sense; 3709| 0| /*LINTED*/break; 3710| 0| case 115: ------------------ | Branch (3710:2): [True: 0, False: 11.9M] ------------------ 3711| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3712| | 3713| 0|#line 444 "./scan.l" 3714| 0|ctrl.no_yyget_leng = ! option_sense; 3715| 0| /*LINTED*/break; 3716| 0| case 116: ------------------ | Branch (3716:2): [True: 0, False: 11.9M] ------------------ 3717| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3718| | 3719| 0|#line 445 "./scan.l" 3720| 0|ctrl.no_yyget_text = ! option_sense; 3721| 0| /*LINTED*/break; 3722| 0| case 117: ------------------ | Branch (3722:2): [True: 0, False: 11.9M] ------------------ 3723| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3724| | 3725| 0|#line 446 "./scan.l" 3726| 0|ctrl.no_yyget_column = ! option_sense; 3727| 0| /*LINTED*/break; 3728| 0| case 118: ------------------ | Branch (3728:2): [True: 0, False: 11.9M] ------------------ 3729| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3730| | 3731| 0|#line 447 "./scan.l" 3732| 0|ctrl.no_yyset_column = ! option_sense; 3733| 0| /*LINTED*/break; 3734| 0| case 119: ------------------ | Branch (3734:2): [True: 0, False: 11.9M] ------------------ 3735| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3736| | 3737| 0|#line 448 "./scan.l" 3738| 0|ctrl.no_yyget_lineno = ! option_sense; 3739| 0| /*LINTED*/break; 3740| 0| case 120: ------------------ | Branch (3740:2): [True: 0, False: 11.9M] ------------------ 3741| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3742| | 3743| 0|#line 449 "./scan.l" 3744| 0|ctrl.no_yyset_lineno = ! option_sense; 3745| 0| /*LINTED*/break; 3746| 0| case 121: ------------------ | Branch (3746:2): [True: 0, False: 11.9M] ------------------ 3747| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3748| | 3749| 0|#line 450 "./scan.l" 3750| 0|ctrl.no_yyget_in = ! option_sense; 3751| 0| /*LINTED*/break; 3752| 0| case 122: ------------------ | Branch (3752:2): [True: 0, False: 11.9M] ------------------ 3753| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3754| | 3755| 0|#line 451 "./scan.l" 3756| 0|ctrl.no_yyset_in = ! option_sense; 3757| 0| /*LINTED*/break; 3758| 0| case 123: ------------------ | Branch (3758:2): [True: 0, False: 11.9M] ------------------ 3759| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3760| | 3761| 0|#line 452 "./scan.l" 3762| 0|ctrl.no_yyget_out = ! option_sense; 3763| 0| /*LINTED*/break; 3764| 0| case 124: ------------------ | Branch (3764:2): [True: 0, False: 11.9M] ------------------ 3765| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3766| | 3767| 0|#line 453 "./scan.l" 3768| 0|ctrl.no_yyset_out = ! option_sense; 3769| 0| /*LINTED*/break; 3770| 0| case 125: ------------------ | Branch (3770:2): [True: 0, False: 11.9M] ------------------ 3771| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3772| | 3773| 0|#line 454 "./scan.l" 3774| 0|ctrl.no_yyget_lval = ! option_sense; 3775| 0| /*LINTED*/break; 3776| 0| case 126: ------------------ | Branch (3776:2): [True: 0, False: 11.9M] ------------------ 3777| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3778| | 3779| 0|#line 455 "./scan.l" 3780| 0|ctrl.no_yyset_lval = ! option_sense; 3781| 0| /*LINTED*/break; 3782| 0| case 127: ------------------ | Branch (3782:2): [True: 0, False: 11.9M] ------------------ 3783| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3784| | 3785| 0|#line 456 "./scan.l" 3786| 0|ctrl.no_yyget_lloc = ! option_sense; 3787| 0| /*LINTED*/break; 3788| 0| case 128: ------------------ | Branch (3788:2): [True: 0, False: 11.9M] ------------------ 3789| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3790| | 3791| 0|#line 457 "./scan.l" 3792| 0|ctrl.no_yyset_lloc = ! option_sense; 3793| 0| /*LINTED*/break; 3794| 0| case 129: ------------------ | Branch (3794:2): [True: 0, False: 11.9M] ------------------ 3795| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3796| | 3797| 0|#line 459 "./scan.l" 3798| 0|return TOK_BUFSIZE; ------------------ | | 131| 0|#define TOK_BUFSIZE 280 ------------------ 3799| 0| /*LINTED*/break; 3800| 0| case 130: ------------------ | Branch (3800:2): [True: 0, False: 11.9M] ------------------ 3801| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3802| | 3803| 0|#line 460 "./scan.l" 3804| 0|return TOK_EMIT; ------------------ | | 130| 0|#define TOK_EMIT 279 ------------------ 3805| 0| /*LINTED*/break; 3806| 0| case 131: ------------------ | Branch (3806:2): [True: 0, False: 11.9M] ------------------ 3807| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3808| | 3809| 0|#line 461 "./scan.l" 3810| 0|return TOK_EXTRA_TYPE; ------------------ | | 122| 0|#define TOK_EXTRA_TYPE 271 ------------------ 3811| 0| /*LINTED*/break; 3812| 0| case 132: ------------------ | Branch (3812:2): [True: 0, False: 11.9M] ------------------ 3813| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3814| | 3815| 0|#line 462 "./scan.l" 3816| 0|return TOK_OUTFILE; ------------------ | | 118| 0|#define TOK_OUTFILE 267 ------------------ 3817| 0| /*LINTED*/break; 3818| 0| case 133: ------------------ | Branch (3818:2): [True: 0, False: 11.9M] ------------------ 3819| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3820| | 3821| 0|#line 463 "./scan.l" 3822| 0|return TOK_PREFIX; ------------------ | | 119| 0|#define TOK_PREFIX 268 ------------------ 3823| 0| /*LINTED*/break; 3824| 0| case 134: ------------------ | Branch (3824:2): [True: 0, False: 11.9M] ------------------ 3825| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3826| | 3827| 0|#line 464 "./scan.l" 3828| 0|return TOK_YYCLASS; ------------------ | | 120| 0|#define TOK_YYCLASS 269 ------------------ 3829| 0| /*LINTED*/break; 3830| 0| case 135: ------------------ | Branch (3830:2): [True: 0, False: 11.9M] ------------------ 3831| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3832| | 3833| 0|#line 465 "./scan.l" 3834| 0|return TOK_YYLMAX; ------------------ | | 124| 0|#define TOK_YYLMAX 273 ------------------ 3835| 0| /*LINTED*/break; 3836| 0| case 136: ------------------ | Branch (3836:2): [True: 0, False: 11.9M] ------------------ 3837| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3838| | 3839| 0|#line 466 "./scan.l" 3840| 0|return TOK_YYDECL; ------------------ | | 126| 0|#define TOK_YYDECL 275 ------------------ 3841| 0| /*LINTED*/break; 3842| 0| case 137: ------------------ | Branch (3842:2): [True: 0, False: 11.9M] ------------------ 3843| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3844| | 3845| 0|#line 467 "./scan.l" 3846| 0|return TOK_YYTERMINATE; ------------------ | | 132| 0|#define TOK_YYTERMINATE 281 ------------------ 3847| 0| /*LINTED*/break; 3848| 0| case 138: ------------------ | Branch (3848:2): [True: 0, False: 11.9M] ------------------ 3849| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3850| | 3851| 0|#line 468 "./scan.l" 3852| 0|return TOK_PREACTION; ------------------ | | 127| 0|#define TOK_PREACTION 276 ------------------ 3853| 0| /*LINTED*/break; 3854| 0| case 139: ------------------ | Branch (3854:2): [True: 0, False: 11.9M] ------------------ 3855| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3856| | 3857| 0|#line 469 "./scan.l" 3858| 0|return TOK_POSTACTION; ------------------ | | 128| 0|#define TOK_POSTACTION 277 ------------------ 3859| 0| /*LINTED*/break; 3860| 0| case 140: ------------------ | Branch (3860:2): [True: 0, False: 11.9M] ------------------ 3861| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3862| | 3863| 0|#line 470 "./scan.l" 3864| 0|return TOK_USERINIT; ------------------ | | 129| 0|#define TOK_USERINIT 278 ------------------ 3865| 0| /*LINTED*/break; 3866| 0| case 141: ------------------ | Branch (3866:2): [True: 0, False: 11.9M] ------------------ 3867| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3868| | 3869| 0|#line 471 "./scan.l" 3870| 0|return TOK_HEADER_FILE; ------------------ | | 121| 0|#define TOK_HEADER_FILE 270 ------------------ 3871| 0| /*LINTED*/break; 3872| 0| case 142: ------------------ | Branch (3872:2): [True: 0, False: 11.9M] ------------------ 3873| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3874| | 3875| 0|#line 472 "./scan.l" 3876| 0|return TOK_TABLES_FILE; ------------------ | | 123| 0|#define TOK_TABLES_FILE 272 ------------------ 3877| 0| /*LINTED*/break; 3878| 0| case 143: ------------------ | Branch (3878:2): [True: 0, False: 11.9M] ------------------ 3879| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3880| | 3881| 0|#line 473 "./scan.l" 3882| 0|{ 3883| 0| tablesverify = option_sense; 3884| 0| if(!tablesext && option_sense) ------------------ | Branch (3884:24): [True: 0, False: 0] | Branch (3884:38): [True: 0, False: 0] ------------------ 3885| 0| tablesext = true; 3886| 0| } 3887| 0| /*LINTED*/break; 3888| 0| case 144: ------------------ | Branch (3888:2): [True: 0, False: 11.9M] ------------------ 3889| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3890| | 3891| 0|#line 480 "./scan.l" 3892| 0|{ 3893| 0| if(yyleng-1 < MAXLINE) ------------------ | | 99| 0|#define MAXLINE 2048 ------------------ | Branch (3893:7): [True: 0, False: 0] ------------------ 3894| 0| { 3895| 0| strncpy( nmstr, yytext + 1, sizeof(nmstr) ); 3896| 0| } 3897| 0| else 3898| 0| { 3899| 0| synerr( _("Option line too long\n")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 3900| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 3901| 0| } 3902| 0| nmstr[strlen( nmstr ) - 1] = '\0'; 3903| 0| return NAME; ------------------ | | 114| 0|#define NAME 263 ------------------ 3904| 0| } 3905| 0| /*LINTED*/break; 3906| 0| case 145: ------------------ | Branch (3906:2): [True: 0, False: 11.9M] ------------------ 3907| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3908| | 3909| 0|#line 494 "./scan.l" 3910| 0|{ 3911| 0| format_synerr( _( "unrecognized %%option: %s" ), ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 3912| 0| yytext ); 3913| 0| BEGIN(RECOVER); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(RECOVER); ------------------ | | 2512| 0|#define RECOVER 13 ------------------ 3914| 0| } 3915| 0| /*LINTED*/break; 3916| | 3917| 0| case 146: ------------------ | Branch (3917:2): [True: 0, False: 11.9M] ------------------ 3918| |/* rule 146 can match eol */ 3919| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3920| | 3921| 0|#line 501 "./scan.l" 3922| 0|++linenum; BEGIN(INITIAL); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ ++linenum; BEGIN(INITIAL); ------------------ | | 2499| 0|#define INITIAL 0 ------------------ 3923| 0| /*LINTED*/break; 3924| | 3925| 0| case 147: ------------------ | Branch (3925:2): [True: 0, False: 11.9M] ------------------ 3926| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3927| | 3928| 0|#line 505 "./scan.l" 3929| 0|++bracelevel; yyless( 2 ); /* eat only %{ */ ------------------ | | 290| 0| do \ | | 291| 0| { \ | | 292| 0| /* Undo effects of setting up yytext. */ \ | | 293| 0| int yyless_macro_arg = (n); \ | | 294| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 295| 0| *yy_cp = (yy_hold_char); \ | | 296| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 297| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2370| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 298| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 584| 0| do { \ | | | | 585| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 528| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 586| 0| \ | | | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 588| 0| \ | | | | 589| 0| (yy_hold_char) = *yy_cp; \ | | | | 590| 0| *yy_cp = '\0'; \ | | | | 591| 0| \ | | | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | | | 593| 0| } while(0) | | | | ------------------ | | | | | Branch (593:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 299| 0| } \ | | 300| 0| while ( 0 ) | | ------------------ | | | Branch (300:10): [Folded - Ignored] | | ------------------ ------------------ 3930| 0| /*LINTED*/break; 3931| 0| case 148: ------------------ | Branch (3931:2): [True: 0, False: 11.9M] ------------------ 3932| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3933| | 3934| 0|#line 506 "./scan.l" 3935| 0|--bracelevel; yyless( 2 ); /* eat only %} */ ------------------ | | 290| 0| do \ | | 291| 0| { \ | | 292| 0| /* Undo effects of setting up yytext. */ \ | | 293| 0| int yyless_macro_arg = (n); \ | | 294| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 295| 0| *yy_cp = (yy_hold_char); \ | | 296| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 297| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2370| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 298| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 584| 0| do { \ | | | | 585| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 528| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 586| 0| \ | | | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 588| 0| \ | | | | 589| 0| (yy_hold_char) = *yy_cp; \ | | | | 590| 0| *yy_cp = '\0'; \ | | | | 591| 0| \ | | | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | | | 593| 0| } while(0) | | | | ------------------ | | | | | Branch (593:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 299| 0| } \ | | 300| 0| while ( 0 ) | | ------------------ | | | Branch (300:10): [Folded - Ignored] | | ------------------ ------------------ 3936| 0| /*LINTED*/break; 3937| 0| case 149: ------------------ | Branch (3937:2): [True: 0, False: 11.9M] ------------------ 3938| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3939| | 3940| 0|#line 508 "./scan.l" 3941| 0|START_CODEBLOCK(true); /* indented code in prolog */ ------------------ | | 2473| 0|#define START_CODEBLOCK(x) do { \ | | 2474| 0| /* Emit the needed line directive... */\ | | 2475| 0| if (indented_code == false) { \ | | ------------------ | | | Branch (2475:9): [True: 0, False: 0] | | ------------------ | | 2476| 0| linenum++; \ | | 2477| 0| line_directive_out(NULL, infilename, linenum); \ | | 2478| 0| } \ | | 2479| 0| add_action(M4QSTART); \ | | ------------------ | | | | 2424| 0|#define M4QSTART "[""[" | | ------------------ | | 2480| 0| yy_push_state(CODEBLOCK); \ | | ------------------ | | | | 2503| 0|#define CODEBLOCK 4 | | ------------------ | | 2481| 0| if ((indented_code = x)) ACTION_ECHO; \ | | ------------------ | | | | 2430| 0|#define ACTION_ECHO add_action( yytext ) | | ------------------ | | | Branch (2481:9): [True: 0, False: 0] | | ------------------ | | 2482| 0|} while(0) | | ------------------ | | | Branch (2482:9): [Folded - Ignored] | | ------------------ ------------------ 3942| 0| /*LINTED*/break; 3943| 1| case 150: ------------------ | Branch (3943:2): [True: 1, False: 11.9M] ------------------ 3944| 1|YY_RULE_SETUP ------------------ | | 2732| 1| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 1, False: 0] | | ------------------ | | 2733| 1| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 1| } \ | | 2735| 1| YY_USER_ACTION ------------------ 3945| | 3946| 1|#line 510 "./scan.l" 3947| 1|{ 3948| | /* non-indented code */ 3949| 1| if ( bracelevel <= 0 ) { ------------------ | Branch (3949:8): [True: 1, False: 0] ------------------ 3950| | /* not in %{ ... %} */ 3951| 1| yyless( 0 ); /* put it all back */ ------------------ | | 290| 1| do \ | | 291| 1| { \ | | 292| 1| /* Undo effects of setting up yytext. */ \ | | 293| 1| int yyless_macro_arg = (n); \ | | 294| 1| YY_LESS_LINENO(yyless_macro_arg);\ | | 295| 1| *yy_cp = (yy_hold_char); \ | | 296| 1| YY_RESTORE_YY_MORE_OFFSET \ | | 297| 1| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2370| 1|#define YY_MORE_ADJ 0 | | ------------------ | | 298| 1| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 584| 1| do { \ | | | | 585| 1| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 528| 1|#define yytext_ptr yytext | | | | ------------------ | | | | 586| 1| \ | | | | 587| 1| yyleng = (int) (yy_cp - yy_bp); \ | | | | 588| 1| \ | | | | 589| 1| (yy_hold_char) = *yy_cp; \ | | | | 590| 1| *yy_cp = '\0'; \ | | | | 591| 1| \ | | | | 592| 1| (yy_c_buf_p) = yy_cp; \ | | | | 593| 1| } while(0) | | | | ------------------ | | | | | Branch (593:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 299| 1| } \ | | 300| 1| while ( 0 ) | | ------------------ | | | Branch (300:10): [Folded - Ignored] | | ------------------ ------------------ 3952| 1| yy_set_bol( 1 ); ------------------ | | 471| 1| { \ | | 472| 1| if ( yy_current_buffer() == NULL ) { \ | | ------------------ | | | | 391| 1|#define yy_current_buffer() ( (yy_buffer_stack) \ | | | | ------------------ | | | | | Branch (391:31): [True: 1, False: 0] | | | | ------------------ | | | | 392| 1| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | | | 393| 1| : NULL) | | ------------------ | | | Branch (472:7): [True: 0, False: 1] | | ------------------ | | 473| 0| yyensure_buffer_stack (); \ | | 474| 0| YY_CURRENT_BUFFER_LVALUE = \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 475| 0| yy_create_buffer( yyin, YY_BUF_SIZE ); \ | | ------------------ | | | | 2626| 0|#define YY_BUF_SIZE (2 * YY_READ_BUF_SIZE) | | | | ------------------ | | | | | | 2619| 0|#define YY_READ_BUF_SIZE BUFSIZ | | | | ------------------ | | ------------------ | | 476| 0| } \ | | 477| 1| YY_CURRENT_BUFFER_LVALUE->yyatbol = at_bol; \ | | ------------------ | | | | 399| 1|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 478| 1|} ------------------ 3953| 1| mark_prolog(); 3954| 1| BEGIN(SECT2); ------------------ | | 233| 1|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 1|#define SECT2 1 ------------------ 3955| 1| } else { 3956| 0| START_CODEBLOCK(true); ------------------ | | 2473| 0|#define START_CODEBLOCK(x) do { \ | | 2474| 0| /* Emit the needed line directive... */\ | | 2475| 0| if (indented_code == false) { \ | | ------------------ | | | Branch (2475:9): [True: 0, False: 0] | | ------------------ | | 2476| 0| linenum++; \ | | 2477| 0| line_directive_out(NULL, infilename, linenum); \ | | 2478| 0| } \ | | 2479| 0| add_action(M4QSTART); \ | | ------------------ | | | | 2424| 0|#define M4QSTART "[""[" | | ------------------ | | 2480| 0| yy_push_state(CODEBLOCK); \ | | ------------------ | | | | 2503| 0|#define CODEBLOCK 4 | | ------------------ | | 2481| 0| if ((indented_code = x)) ACTION_ECHO; \ | | ------------------ | | | | 2430| 0|#define ACTION_ECHO add_action( yytext ) | | ------------------ | | | Branch (2481:9): [True: 0, False: 0] | | ------------------ | | 2482| 0|} while(0) | | ------------------ | | | Branch (2482:9): [Folded - Ignored] | | ------------------ ------------------ 3957| 0| } 3958| 1| } 3959| 1| /*LINTED*/break; 3960| 0| case 151: ------------------ | Branch (3960:2): [True: 0, False: 11.9M] ------------------ 3961| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3962| | 3963| 0|#line 523 "./scan.l" 3964| 0|ACTION_ECHO; ------------------ | | 2430| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 3965| 0| /*LINTED*/break; 3966| 0| case 152: ------------------ | Branch (3966:2): [True: 0, False: 11.9M] ------------------ 3967| |/* rule 152 can match eol */ 3968| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 3969| | 3970| 0|#line 524 "./scan.l" 3971| 0|++linenum; ACTION_ECHO; ------------------ | | 2430| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 3972| 0| /*LINTED*/break; 3973| 1|case YY_STATE_EOF(SECT2PROLOG): ------------------ | | 243| 1|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 1|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (3973:1): [True: 1, False: 11.9M] ------------------ 3974| 1|#line 526 "./scan.l" 3975| 1|{ 3976| 1| mark_prolog(); 3977| 1| sectnum = 0; 3978| 1| return YY_NULL; /* to stop the parser */ ------------------ | | 187| 1|#define YY_NULL 0 ------------------ 3979| 0| } 3980| 0| /*LINTED*/break; 3981| | 3982| | 3983| 770| case 153: ------------------ | Branch (3983:2): [True: 770, False: 11.9M] ------------------ 3984| |/* rule 153 can match eol */ 3985| 770|YY_RULE_SETUP ------------------ | | 2732| 770| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 770, False: 0] | | ------------------ | | 2733| 770| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 770|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 770| } \ | | 2735| 770| YY_USER_ACTION ------------------ 3986| | 3987| 770|#line 534 "./scan.l" 3988| 770|++linenum; /* allow blank lines in section 2 */ 3989| 770| /*LINTED*/break; 3990| 2| case 154: ------------------ | Branch (3990:2): [True: 2, False: 11.9M] ------------------ 3991| 2|YY_RULE_SETUP ------------------ | | 2732| 2| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 2, False: 0] | | ------------------ | | 2733| 2| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 2| } \ | | 2735| 2| YY_USER_ACTION ------------------ 3992| | 3993| 2|#line 536 "./scan.l" 3994| 2|{ 3995| 2| indented_code = false; 3996| 2| doing_codeblock = true; 3997| 2| bracelevel = 1; 3998| 2| BEGIN(PERCENT_BRACE_ACTION); ------------------ | | 233| 2|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(PERCENT_BRACE_ACTION); ------------------ | | 2515| 2|#define PERCENT_BRACE_ACTION 16 ------------------ 3999| 2| } 4000| 2| /*LINTED*/break; 4001| 4| case 155: ------------------ | Branch (4001:2): [True: 4, False: 11.9M] ------------------ 4002| 4|YY_RULE_SETUP ------------------ | | 2732| 4| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 4, False: 0] | | ------------------ | | 2733| 4| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 4|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 4| } \ | | 2735| 4| YY_USER_ACTION ------------------ 4003| | 4004| 4|#line 543 "./scan.l" 4005| 4|{ 4006| | /* Allow "<" to appear in (?x) patterns. */ 4007| 4| if (!sf_skip_ws()) ------------------ | | 1207| 4|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1204| 4|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1203| 4|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ ------------------ | Branch (4007:29): [True: 4, False: 0] ------------------ 4008| 4| BEGIN(SC); ------------------ | | 233| 4|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SC); ------------------ | | 2505| 4|#define SC 6 ------------------ 4009| 4| return '<'; 4010| 0| } 4011| 0| /*LINTED*/break; 4012| 0| case 156: ------------------ | Branch (4012:2): [True: 0, False: 11.9M] ------------------ 4013| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4014| | 4015| 0|#line 549 "./scan.l" 4016| 0|return '^'; 4017| 0| /*LINTED*/break; 4018| 29| case 157: ------------------ | Branch (4018:2): [True: 29, False: 11.9M] ------------------ 4019| 29|YY_RULE_SETUP ------------------ | | 2732| 29| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 29, False: 0] | | ------------------ | | 2733| 29| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 29|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 29| } \ | | 2735| 29| YY_USER_ACTION ------------------ 4020| | 4021| 29|#line 550 "./scan.l" 4022| 29|BEGIN(QUOTE); return '"'; ------------------ | | 233| 29|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(QUOTE); return '"'; ------------------ | | 2508| 29|#define QUOTE 9 ------------------ 4023| 0| /*LINTED*/break; 4024| 2| case 158: ------------------ | Branch (4024:2): [True: 2, False: 11.9M] ------------------ 4025| 2|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4026| 2|(yy_c_buf_p) = yy_cp = yy_bp + 1; 4027| 2|YY_DO_BEFORE_ACTION; /* set up yytext */ ------------------ | | 584| 2| do { \ | | 585| 2| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 528| 2|#define yytext_ptr yytext | | ------------------ | | 586| 2| \ | | 587| 2| yyleng = (int) (yy_cp - yy_bp); \ | | 588| 2| \ | | 589| 2| (yy_hold_char) = *yy_cp; \ | | 590| 2| *yy_cp = '\0'; \ | | 591| 2| \ | | 592| 2| (yy_c_buf_p) = yy_cp; \ | | 593| 2| } while(0) | | ------------------ | | | Branch (593:10): [Folded - Ignored] | | ------------------ ------------------ 4028| 2|YY_RULE_SETUP ------------------ | | 2732| 2| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 2, False: 0] | | ------------------ | | 2733| 2| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 2| } \ | | 2735| 2| YY_USER_ACTION ------------------ 4029| | 4030| 2|#line 551 "./scan.l" 4031| 2|{ 4032| 2| BEGIN(NUM); ------------------ | | 233| 2|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(NUM); ------------------ | | 2507| 2|#define NUM 8 ------------------ 4033| 2| if ( ctrl.lex_compat || ctrl.posix_compat ) ------------------ | Branch (4033:9): [True: 0, False: 2] | Branch (4033:28): [True: 0, False: 2] ------------------ 4034| 0| return BEGIN_REPEAT_POSIX; ------------------ | | 159| 0|#define BEGIN_REPEAT_POSIX 308 ------------------ 4035| 2| else 4036| 2| return BEGIN_REPEAT_FLEX; ------------------ | | 161| 2|#define BEGIN_REPEAT_FLEX 310 ------------------ 4037| 2| } 4038| 0| /*LINTED*/break; 4039| 0| case 159: ------------------ | Branch (4039:2): [True: 0, False: 11.9M] ------------------ 4040| |/* rule 159 can match eol */ 4041| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4042| 0|YY_LINENO_REWIND_TO(yy_bp + 1); 4043| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 4044| 0|YY_DO_BEFORE_ACTION; /* set up yytext */ ------------------ | | 584| 0| do { \ | | 585| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ | | 586| 0| \ | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 588| 0| \ | | 589| 0| (yy_hold_char) = *yy_cp; \ | | 590| 0| *yy_cp = '\0'; \ | | 591| 0| \ | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | 593| 0| } while(0) | | ------------------ | | | Branch (593:10): [Folded - Ignored] | | ------------------ ------------------ 4045| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4046| | 4047| 0|#line 558 "./scan.l" 4048| 0|return '$'; 4049| 0| /*LINTED*/break; 4050| 0| case 160: ------------------ | Branch (4050:2): [True: 0, False: 11.9M] ------------------ 4051| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4052| | 4053| 0|#line 560 "./scan.l" 4054| 0|{ 4055| 0| bracelevel = 1; 4056| 0| BEGIN(PERCENT_BRACE_ACTION); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(PERCENT_BRACE_ACTION); ------------------ | | 2515| 0|#define PERCENT_BRACE_ACTION 16 ------------------ 4057| | 4058| 0| if ( in_rule ) ------------------ | Branch (4058:9): [True: 0, False: 0] ------------------ 4059| 0| { 4060| 0| doing_rule_action = true; 4061| 0| in_rule = false; 4062| 0| return '\n'; 4063| 0| } 4064| 0| } 4065| 0| /*LINTED*/break; 4066| 0| case 161: ------------------ | Branch (4066:2): [True: 0, False: 11.9M] ------------------ 4067| |/* rule 161 can match eol */ 4068| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4069| | 4070| 0|#line 571 "./scan.l" 4071| 0|{ 4072| 0| if (sf_skip_ws()){ ------------------ | | 1207| 0|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1203| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1207:28): [True: 0, False: 0] | | ------------------ ------------------ 4073| | /* We're in the middle of a (?x: ) pattern. */ 4074| | /* Push back everything starting at the "|" */ 4075| 0| int amt = (int) (strchr (yytext, '|') - yytext); 4076| 0| yyless(amt); ------------------ | | 290| 0| do \ | | 291| 0| { \ | | 292| 0| /* Undo effects of setting up yytext. */ \ | | 293| 0| int yyless_macro_arg = (n); \ | | 294| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 295| 0| *yy_cp = (yy_hold_char); \ | | 296| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 297| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2370| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 298| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 584| 0| do { \ | | | | 585| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 528| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 586| 0| \ | | | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 588| 0| \ | | | | 589| 0| (yy_hold_char) = *yy_cp; \ | | | | 590| 0| *yy_cp = '\0'; \ | | | | 591| 0| \ | | | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | | | 593| 0| } while(0) | | | | ------------------ | | | | | Branch (593:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 299| 0| } \ | | 300| 0| while ( 0 ) | | ------------------ | | | Branch (300:10): [Folded - Ignored] | | ------------------ ------------------ 4077| 0| } 4078| 0| else { 4079| 0| add_action("]""]"); 4080| 0| continued_action = true; 4081| 0| ++linenum; 4082| 0| return '\n'; 4083| 0| } 4084| 0| } 4085| 0| /*LINTED*/break; 4086| 0| case 162: ------------------ | Branch (4086:2): [True: 0, False: 11.9M] ------------------ 4087| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4088| | 4089| 0|#line 586 "./scan.l" 4090| 0|{ 4091| | 4092| 0| if (sf_skip_ws()){ ------------------ | | 1207| 0|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1203| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1207:28): [True: 0, False: 0] | | ------------------ ------------------ 4093| | /* We're in the middle of a (?x: ) pattern. */ 4094| 0| yy_push_state(COMMENT_DISCARD); ------------------ | | 2522| 0|#define COMMENT_DISCARD 23 ------------------ 4095| 0| } 4096| 0| else{ 4097| 0| yyless( yyleng - 2 ); /* put back '/', '*' */ ------------------ | | 290| 0| do \ | | 291| 0| { \ | | 292| 0| /* Undo effects of setting up yytext. */ \ | | 293| 0| int yyless_macro_arg = (n); \ | | 294| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 295| 0| *yy_cp = (yy_hold_char); \ | | 296| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 297| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2370| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 298| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 584| 0| do { \ | | | | 585| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 528| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 586| 0| \ | | | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 588| 0| \ | | | | 589| 0| (yy_hold_char) = *yy_cp; \ | | | | 590| 0| *yy_cp = '\0'; \ | | | | 591| 0| \ | | | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | | | 593| 0| } while(0) | | | | ------------------ | | | | | Branch (593:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 299| 0| } \ | | 300| 0| while ( 0 ) | | ------------------ | | | Branch (300:10): [Folded - Ignored] | | ------------------ ------------------ 4098| 0| bracelevel = 0; 4099| 0| continued_action = false; 4100| 0| BEGIN(ACTION); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(ACTION); ------------------ | | 2511| 0|#define ACTION 12 ------------------ 4101| 0| } 4102| 0| } 4103| 0| /*LINTED*/break; 4104| 32| case 163: ------------------ | Branch (4104:2): [True: 32, False: 11.9M] ------------------ 4105| 32|YY_RULE_SETUP ------------------ | | 2732| 32| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 32, False: 0] | | ------------------ | | 2733| 32| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 32|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 32| } \ | | 2735| 32| YY_USER_ACTION ------------------ 4106| | 4107| 32|#line 600 "./scan.l" 4108| 32|/* allow indented rules */ ; 4109| 32| /*LINTED*/break; 4110| 77| case 164: ------------------ | Branch (4110:2): [True: 77, False: 11.9M] ------------------ 4111| 77|YY_RULE_SETUP ------------------ | | 2732| 77| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 77, False: 0] | | ------------------ | | 2733| 77| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 77|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 77| } \ | | 2735| 77| YY_USER_ACTION ------------------ 4112| | 4113| 77|#line 602 "./scan.l" 4114| 77|{ 4115| 77| if (sf_skip_ws()){ ------------------ | | 1207| 77|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1204| 77|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1203| 77|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1207:28): [True: 0, False: 77] | | ------------------ ------------------ 4116| | /* We're in the middle of a (?x: ) pattern. */ 4117| 0| } 4118| 77| else{ 4119| | /* This rule is separate from the one below because 4120| | * otherwise we get variable trailing context, so 4121| | * we can't build the scanner using -{f,F}. 4122| | */ 4123| 77| bracelevel = 0; 4124| 77| continued_action = false; 4125| 77| BEGIN(ACTION); ------------------ | | 233| 77|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(ACTION); ------------------ | | 2511| 77|#define ACTION 12 ------------------ 4126| | 4127| 77| if ( in_rule ) ------------------ | Branch (4127:22): [True: 0, False: 77] ------------------ 4128| 0| { 4129| 0| doing_rule_action = true; 4130| 0| in_rule = false; 4131| 0| return '\n'; 4132| 0| } 4133| 77| } 4134| 77| } 4135| 77| /*LINTED*/break; 4136| 286| case 165: ------------------ | Branch (4136:2): [True: 286, False: 11.9M] ------------------ 4137| |/* rule 165 can match eol */ 4138| 286|YY_RULE_SETUP ------------------ | | 2732| 286| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 286, False: 0] | | ------------------ | | 2733| 286| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 286|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 286| } \ | | 2735| 286| YY_USER_ACTION ------------------ 4139| | 4140| 286|#line 624 "./scan.l" 4141| 286|{ 4142| 286| if (sf_skip_ws()){ ------------------ | | 1207| 286|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1204| 286|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1203| 286|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1207:28): [True: 0, False: 286] | | ------------------ ------------------ 4143| | /* We're in the middle of a (?x: ) pattern. */ 4144| 0| ++linenum; 4145| 0| } 4146| 286| else{ 4147| 286| bracelevel = 0; 4148| 286| continued_action = false; 4149| 286| BEGIN(ACTION); ------------------ | | 233| 286|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(ACTION); ------------------ | | 2511| 286|#define ACTION 12 ------------------ 4150| 286| unput( '\n' ); /* so sees it */ ------------------ | | 303| 286|#define unput(c) yyunput_r( c, (yytext_ptr) ) | | ------------------ | | | | 528| 286|#define yytext_ptr yytext | | ------------------ ------------------ 4151| | 4152| 286| if ( in_rule ) ------------------ | Branch (4152:22): [True: 0, False: 286] ------------------ 4153| 0| { 4154| 0| doing_rule_action = true; 4155| 0| in_rule = false; 4156| 0| return '\n'; 4157| 0| } 4158| 286| } 4159| 286| } 4160| 286| /*LINTED*/break; 4161| 286| case 166: ------------------ | Branch (4161:2): [True: 0, False: 11.9M] ------------------ 4162| 0|#line 645 "./scan.l" 4163| 0| case 167: ------------------ | Branch (4163:2): [True: 0, False: 11.9M] ------------------ 4164| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4165| | 4166| 0|#line 645 "./scan.l" 4167| 0|return EOF_OP; ------------------ | | 116| 0|#define EOF_OP 265 ------------------ 4168| 0| /*LINTED*/break; 4169| 0| case 168: ------------------ | Branch (4169:2): [True: 0, False: 11.9M] ------------------ 4170| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4171| | 4172| 0|#line 647 "./scan.l" 4173| 0|{ 4174| 0| sectnum = 3; 4175| 0| BEGIN(ctrl.no_section3_escape ? SECT3_NOESCAPE : SECT3); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(ctrl.no_section3_escape ? SECT3_NOESCAPE : SECT3); ------------------ | | 2524| 0|#define SECT3_NOESCAPE 25 ------------------ BEGIN(ctrl.no_section3_escape ? SECT3_NOESCAPE : SECT3); ------------------ | | 2502| 0|#define SECT3 3 ------------------ | Branch (4175:10): [True: 0, False: 0] ------------------ 4176| 0| yyterminate(); /* to stop the parser */ ------------------ | | 2704| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 187| 0|#define YY_NULL 0 | | ------------------ ------------------ 4177| | 4178| 0| } 4179| 0| /*LINTED*/break; 4180| 78| case 169: ------------------ | Branch (4180:2): [True: 78, False: 11.9M] ------------------ 4181| 78|YY_RULE_SETUP ------------------ | | 2732| 78| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 78, False: 0] | | ------------------ | | 2733| 78| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 78|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 78| } \ | | 2735| 78| YY_USER_ACTION ------------------ 4182| | 4183| 78|#line 654 "./scan.l" 4184| 78|{ 4185| 78| int cclval; 4186| | 4187| 78| if(yyleng < MAXLINE) ------------------ | | 99| 78|#define MAXLINE 2048 ------------------ | Branch (4187:7): [True: 78, False: 0] ------------------ 4188| 78| { 4189| 78| strncpy( nmstr, yytext, sizeof(nmstr) ); 4190| 78| } 4191| 0| else 4192| 0| { 4193| 0| synerr( _("Input line too long\n")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 4194| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 4195| 0| } 4196| | 4197| | /* Check to see if we've already encountered this 4198| | * ccl. 4199| | */ 4200| 78| if (0 /* <--- This "0" effectively disables the reuse of a ------------------ | Branch (4200:8): [Folded - Ignored] ------------------ 4201| | * character class (purely based on its source text). 4202| | * The reason it was disabled is so yacc/bison can parse 4203| | * ccl operations, such as ccl difference and union. 4204| | */ 4205| 78| && (cclval = ccllookup( nmstr )) != 0 ) ------------------ | Branch (4205:21): [True: 0, False: 0] ------------------ 4206| 0| { 4207| 0| if ( yyinput() != ']' ) ------------------ | Branch (4207:10): [True: 0, False: 0] ------------------ 4208| 0| synerr( _( "bad character class" ) ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 4209| | 4210| 0| yylval = cclval; 4211| 0| ++cclreuse; 4212| 0| return PREVCCL; ------------------ | | 115| 0|#define PREVCCL 264 ------------------ 4213| 0| } 4214| 78| else 4215| 78| { 4216| | /* We fudge a bit. We know that this ccl will 4217| | * soon be numbered as lastccl + 1 by cclinit. 4218| | */ 4219| 78| cclinstal( nmstr, lastccl + 1 ); 4220| | 4221| | /* Push back everything but the leading bracket 4222| | * so the ccl can be rescanned. 4223| | */ 4224| 78| yyless( 1 ); ------------------ | | 290| 78| do \ | | 291| 78| { \ | | 292| 78| /* Undo effects of setting up yytext. */ \ | | 293| 78| int yyless_macro_arg = (n); \ | | 294| 78| YY_LESS_LINENO(yyless_macro_arg);\ | | 295| 78| *yy_cp = (yy_hold_char); \ | | 296| 78| YY_RESTORE_YY_MORE_OFFSET \ | | 297| 78| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2370| 78|#define YY_MORE_ADJ 0 | | ------------------ | | 298| 78| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 584| 78| do { \ | | | | 585| 78| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 528| 78|#define yytext_ptr yytext | | | | ------------------ | | | | 586| 78| \ | | | | 587| 78| yyleng = (int) (yy_cp - yy_bp); \ | | | | 588| 78| \ | | | | 589| 78| (yy_hold_char) = *yy_cp; \ | | | | 590| 78| *yy_cp = '\0'; \ | | | | 591| 78| \ | | | | 592| 78| (yy_c_buf_p) = yy_cp; \ | | | | 593| 78| } while(0) | | | | ------------------ | | | | | Branch (593:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 299| 78| } \ | | 300| 78| while ( 0 ) | | ------------------ | | | Branch (300:10): [Folded - Ignored] | | ------------------ ------------------ 4225| | 4226| 78| BEGIN(FIRSTCCL); ------------------ | | 233| 78|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(FIRSTCCL); ------------------ | | 2509| 78|#define FIRSTCCL 10 ------------------ 4227| 78| return '['; 4228| 78| } 4229| 78| } 4230| 0| /*LINTED*/break; 4231| 0| case 170: ------------------ | Branch (4231:2): [True: 0, False: 11.9M] ------------------ 4232| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4233| | 4234| 0|#line 700 "./scan.l" 4235| 0|return CCL_OP_DIFF; ------------------ | | 157| 0|#define CCL_OP_DIFF 306 ------------------ 4236| 0| /*LINTED*/break; 4237| 0| case 171: ------------------ | Branch (4237:2): [True: 0, False: 11.9M] ------------------ 4238| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4239| | 4240| 0|#line 701 "./scan.l" 4241| 0|return CCL_OP_UNION; ------------------ | | 158| 0|#define CCL_OP_UNION 307 ------------------ 4242| 0| /*LINTED*/break; 4243| |/* Check for :space: at the end of the rule so we don't 4244| | * wrap the expanded regex in '(' ')' -- breaking trailing 4245| | * context. 4246| | */ 4247| 0| case 172: ------------------ | Branch (4247:2): [True: 0, False: 11.9M] ------------------ 4248| |/* rule 172 can match eol */ 4249| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4250| | 4251| 0|#line 708 "./scan.l" 4252| 0|{ 4253| 0| char *nmdefptr; 4254| 0| int end_is_ws, end_ch; 4255| | 4256| 0| end_ch = yytext[yyleng-1]; 4257| 0| end_is_ws = end_ch != '}' ? 1 : 0; ------------------ | Branch (4257:25): [True: 0, False: 0] ------------------ 4258| | 4259| 0| if(yyleng-1 < MAXLINE) ------------------ | | 99| 0|#define MAXLINE 2048 ------------------ | Branch (4259:8): [True: 0, False: 0] ------------------ 4260| 0| { 4261| 0| strncpy( nmstr, yytext + 1, sizeof(nmstr) ); 4262| 0| } 4263| 0| else 4264| 0| { 4265| 0| synerr( _("Input line too long\n")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 4266| 0| FLEX_EXIT(EXIT_FAILURE); ------------------ | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) ------------------ 4267| 0| } 4268| 0|nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */ 4269| | 4270| 0| if ( (nmdefptr = ndlookup( nmstr )) == 0 ) ------------------ | Branch (4270:9): [True: 0, False: 0] ------------------ 4271| 0| format_synerr( 4272| 0| _( "undefined definition {%s}" ), ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 4273| 0| nmstr ); 4274| | 4275| 0| else 4276| 0| { /* push back name surrounded by ()'s */ 4277| 0| size_t len = strlen( nmdefptr ); 4278| 0| if (end_is_ws) ------------------ | Branch (4278:21): [True: 0, False: 0] ------------------ 4279| 0| unput(end_ch); ------------------ | | 303| 0|#define unput(c) yyunput_r( c, (yytext_ptr) ) | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ ------------------ 4280| | 4281| 0| if ( ctrl.lex_compat || nmdefptr[0] == '^' || ------------------ | Branch (4281:10): [True: 0, False: 0] | Branch (4281:29): [True: 0, False: 0] ------------------ 4282| 0| (len > 0 && nmdefptr[len - 1] == '$') ------------------ | Branch (4282:11): [True: 0, False: 0] | Branch (4282:22): [True: 0, False: 0] ------------------ 4283| 0| || (end_is_ws && trlcontxt && !sf_skip_ws())) ------------------ | | 1207| 0|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1204| 0|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1203| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ ------------------ | Branch (4283:26): [True: 0, False: 0] | Branch (4283:39): [True: 0, False: 0] | Branch (4283:52): [True: 0, False: 0] ------------------ 4284| 0| { /* don't use ()'s after all */ 4285| 0| PUT_BACK_STRING(nmdefptr, 0); ------------------ | | 2456| 0| { size_t i = strlen( str ); \ | | 2457| 0| while ( i > start ) \ | | ------------------ | | | Branch (2457:12): [True: 0, False: 0] | | ------------------ | | 2458| 0| unput((str)[--i]); \ | | ------------------ | | | | 303| 0|#define unput(c) yyunput_r( c, (yytext_ptr) ) | | | | ------------------ | | | | | | 528| 0|#define yytext_ptr yytext | | | | ------------------ | | ------------------ | | 2459| 0| } ------------------ 4286| | 4287| 0| if ( nmdefptr[0] == '^' ) ------------------ | Branch (4287:11): [True: 0, False: 0] ------------------ 4288| 0| BEGIN(CARETISBOL); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CARETISBOL); ------------------ | | 2506| 0|#define CARETISBOL 7 ------------------ 4289| 0| } 4290| | 4291| 0| else 4292| 0| { 4293| 0| unput(')'); ------------------ | | 303| 0|#define unput(c) yyunput_r( c, (yytext_ptr) ) | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ ------------------ 4294| 0| PUT_BACK_STRING(nmdefptr, 0); ------------------ | | 2456| 0| { size_t i = strlen( str ); \ | | 2457| 0| while ( i > start ) \ | | ------------------ | | | Branch (2457:12): [True: 0, False: 0] | | ------------------ | | 2458| 0| unput((str)[--i]); \ | | ------------------ | | | | 303| 0|#define unput(c) yyunput_r( c, (yytext_ptr) ) | | | | ------------------ | | | | | | 528| 0|#define yytext_ptr yytext | | | | ------------------ | | ------------------ | | 2459| 0| } ------------------ 4295| 0| unput('('); ------------------ | | 303| 0|#define unput(c) yyunput_r( c, (yytext_ptr) ) | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ ------------------ 4296| 0| } 4297| 0| } 4298| 0| } 4299| 0| /*LINTED*/break; 4300| 21| case 173: ------------------ | Branch (4300:2): [True: 21, False: 11.9M] ------------------ 4301| 21|YY_RULE_SETUP ------------------ | | 2732| 21| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 21, False: 0] | | ------------------ | | 2733| 21| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 21|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 21| } \ | | 2735| 21| YY_USER_ACTION ------------------ 4302| | 4303| 21|#line 756 "./scan.l" 4304| 21|{ 4305| 21| if (sf_skip_ws()) ------------------ | | 1207| 21|#define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1204| 21|#define sf_top() (_sf_stk[_sf_top_ix]) | | ------------------ | | #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) | | ------------------ | | | | 1203| 21|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1207:28): [True: 0, False: 21] | | ------------------ ------------------ 4306| 0| yy_push_state(COMMENT_DISCARD); ------------------ | | 2522| 0|#define COMMENT_DISCARD 23 ------------------ 4307| 21| else{ 4308| | /* Push back the "*" and return "/" as usual. */ 4309| 21| yyless(1); ------------------ | | 290| 21| do \ | | 291| 21| { \ | | 292| 21| /* Undo effects of setting up yytext. */ \ | | 293| 21| int yyless_macro_arg = (n); \ | | 294| 21| YY_LESS_LINENO(yyless_macro_arg);\ | | 295| 21| *yy_cp = (yy_hold_char); \ | | 296| 21| YY_RESTORE_YY_MORE_OFFSET \ | | 297| 21| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2370| 21|#define YY_MORE_ADJ 0 | | ------------------ | | 298| 21| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 584| 21| do { \ | | | | 585| 21| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 528| 21|#define yytext_ptr yytext | | | | ------------------ | | | | 586| 21| \ | | | | 587| 21| yyleng = (int) (yy_cp - yy_bp); \ | | | | 588| 21| \ | | | | 589| 21| (yy_hold_char) = *yy_cp; \ | | | | 590| 21| *yy_cp = '\0'; \ | | | | 591| 21| \ | | | | 592| 21| (yy_c_buf_p) = yy_cp; \ | | | | 593| 21| } while(0) | | | | ------------------ | | | | | Branch (593:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 299| 21| } \ | | 300| 21| while ( 0 ) | | ------------------ | | | Branch (300:10): [Folded - Ignored] | | ------------------ ------------------ 4310| 21| return '/'; 4311| 21| } 4312| 21| } 4313| 0| /*LINTED*/break; 4314| 0| case 174: ------------------ | Branch (4314:2): [True: 0, False: 11.9M] ------------------ 4315| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4316| | 4317| 0|#line 766 "./scan.l" 4318| 0|{ 4319| 0| if (ctrl.lex_compat || ctrl.posix_compat){ ------------------ | Branch (4319:25): [True: 0, False: 0] | Branch (4319:44): [True: 0, False: 0] ------------------ 4320| | /* Push back the "?#" and treat it like a normal parens. */ 4321| 0| yyless(1); ------------------ | | 290| 0| do \ | | 291| 0| { \ | | 292| 0| /* Undo effects of setting up yytext. */ \ | | 293| 0| int yyless_macro_arg = (n); \ | | 294| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 295| 0| *yy_cp = (yy_hold_char); \ | | 296| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 297| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2370| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 298| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 584| 0| do { \ | | | | 585| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 528| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 586| 0| \ | | | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 588| 0| \ | | | | 589| 0| (yy_hold_char) = *yy_cp; \ | | | | 590| 0| *yy_cp = '\0'; \ | | | | 591| 0| \ | | | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | | | 593| 0| } while(0) | | | | ------------------ | | | | | Branch (593:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 299| 0| } \ | | 300| 0| while ( 0 ) | | ------------------ | | | Branch (300:10): [Folded - Ignored] | | ------------------ ------------------ 4322| 0| sf_push(); 4323| 0| return '('; 4324| 0| } 4325| 0| else 4326| 0| yy_push_state(EXTENDED_COMMENT); ------------------ | | 2521| 0|#define EXTENDED_COMMENT 22 ------------------ 4327| 0| } 4328| 0| /*LINTED*/break; 4329| 0| case 175: ------------------ | Branch (4329:2): [True: 0, False: 11.9M] ------------------ 4330| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4331| | 4332| 0|#line 776 "./scan.l" 4333| 0|{ 4334| 0| sf_push(); 4335| 0| if (ctrl.lex_compat || ctrl.posix_compat) ------------------ | Branch (4335:25): [True: 0, False: 0] | Branch (4335:44): [True: 0, False: 0] ------------------ 4336| | /* Push back the "?" and treat it like a normal parens. */ 4337| 0| yyless(1); ------------------ | | 290| 0| do \ | | 291| 0| { \ | | 292| 0| /* Undo effects of setting up yytext. */ \ | | 293| 0| int yyless_macro_arg = (n); \ | | 294| 0| YY_LESS_LINENO(yyless_macro_arg);\ | | 295| 0| *yy_cp = (yy_hold_char); \ | | 296| 0| YY_RESTORE_YY_MORE_OFFSET \ | | 297| 0| (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ | | ------------------ | | | | 2370| 0|#define YY_MORE_ADJ 0 | | ------------------ | | 298| 0| YY_DO_BEFORE_ACTION; /* set up yytext again */ \ | | ------------------ | | | | 584| 0| do { \ | | | | 585| 0| (yytext_ptr) = yy_bp; \ | | | | ------------------ | | | | | | 528| 0|#define yytext_ptr yytext | | | | ------------------ | | | | 586| 0| \ | | | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | | | 588| 0| \ | | | | 589| 0| (yy_hold_char) = *yy_cp; \ | | | | 590| 0| *yy_cp = '\0'; \ | | | | 591| 0| \ | | | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | | | 593| 0| } while(0) | | | | ------------------ | | | | | Branch (593:10): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 299| 0| } \ | | 300| 0| while ( 0 ) | | ------------------ | | | Branch (300:10): [Folded - Ignored] | | ------------------ ------------------ 4338| 0| else 4339| 0| BEGIN(GROUP_WITH_PARAMS); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(GROUP_WITH_PARAMS); ------------------ | | 2519| 0|#define GROUP_WITH_PARAMS 20 ------------------ 4340| 0| return '('; 4341| 0| } 4342| 0| /*LINTED*/break; 4343| 14| case 176: ------------------ | Branch (4343:2): [True: 14, False: 11.9M] ------------------ 4344| 14|YY_RULE_SETUP ------------------ | | 2732| 14| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 14, False: 0] | | ------------------ | | 2733| 14| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 14|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 14| } \ | | 2735| 14| YY_USER_ACTION ------------------ 4345| | 4346| 14|#line 785 "./scan.l" 4347| 14|sf_push(); return '('; 4348| 0| /*LINTED*/break; 4349| 20| case 177: ------------------ | Branch (4349:2): [True: 20, False: 11.9M] ------------------ 4350| 20|YY_RULE_SETUP ------------------ | | 2732| 20| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 20, False: 0] | | ------------------ | | 2733| 20| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 20|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 20| } \ | | 2735| 20| YY_USER_ACTION ------------------ 4351| | 4352| 20|#line 786 "./scan.l" 4353| 20|{ 4354| 20| if (_sf_top_ix > 0) { ------------------ | Branch (4354:25): [True: 11, False: 9] ------------------ 4355| 11| sf_pop(); 4356| 11| return ')'; 4357| 11| } else 4358| 9| synerr(_("unbalanced parenthesis")); ------------------ | | 85| 9|#define _(String) gettext (String) ------------------ 4359| 20| } 4360| 9| /*LINTED*/break; 4361| 529| case 178: ------------------ | Branch (4361:2): [True: 529, False: 11.9M] ------------------ 4362| 529|YY_RULE_SETUP ------------------ | | 2732| 529| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 529, False: 0] | | ------------------ | | 2733| 529| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 529|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 529| } \ | | 2735| 529| YY_USER_ACTION ------------------ 4363| | 4364| 529|#line 794 "./scan.l" 4365| 529|return (unsigned char) yytext[0]; 4366| 0| /*LINTED*/break; 4367| 5.81k| case 179: ------------------ | Branch (4367:2): [True: 5.81k, False: 11.8M] ------------------ 4368| 5.81k|YY_RULE_SETUP ------------------ | | 2732| 5.81k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 5.81k, False: 0] | | ------------------ | | 2733| 5.81k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 5.81k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 5.81k| } \ | | 2735| 5.81k| YY_USER_ACTION ------------------ 4369| | 4370| 5.81k|#line 795 "./scan.l" 4371| 5.81k|RETURNCHAR; ------------------ | | 2440| 5.81k| yylval = (unsigned char) yytext[0]; \ | | 2441| 5.81k| return CHAR; | | ------------------ | | | | 109| 5.81k|#define CHAR 258 | | ------------------ ------------------ 4372| 0| /*LINTED*/break; 4373| | 4374| | 4375| 91| case 180: ------------------ | Branch (4375:2): [True: 91, False: 11.9M] ------------------ 4376| |/* rule 180 can match eol */ 4377| 91|YY_RULE_SETUP ------------------ | | 2732| 91| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 91, False: 0] | | ------------------ | | 2733| 91| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 91|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 91| } \ | | 2735| 91| YY_USER_ACTION ------------------ 4378| | 4379| 91|#line 800 "./scan.l" 4380| 91|++linenum; /* Allow blank lines & continuations */ 4381| 91| /*LINTED*/break; 4382| 30| case 181: ------------------ | Branch (4382:2): [True: 30, False: 11.9M] ------------------ 4383| 30|YY_RULE_SETUP ------------------ | | 2732| 30| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 30, False: 0] | | ------------------ | | 2733| 30| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 30|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 30| } \ | | 2735| 30| YY_USER_ACTION ------------------ 4384| | 4385| 30|#line 801 "./scan.l" 4386| 30|return (unsigned char) yytext[0]; 4387| 0| /*LINTED*/break; 4388| 4| case 182: ------------------ | Branch (4388:2): [True: 4, False: 11.9M] ------------------ 4389| 4|YY_RULE_SETUP ------------------ | | 2732| 4| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 4, False: 0] | | ------------------ | | 2733| 4| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 4|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 4| } \ | | 2735| 4| YY_USER_ACTION ------------------ 4390| | 4391| 4|#line 802 "./scan.l" 4392| 4|BEGIN(SECT2); return '>'; ------------------ | | 233| 4|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); return '>'; ------------------ | | 2500| 4|#define SECT2 1 ------------------ 4393| 0| /*LINTED*/break; 4394| 0| case 183: ------------------ | Branch (4394:2): [True: 0, False: 11.9M] ------------------ 4395| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4396| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 4397| 0|YY_DO_BEFORE_ACTION; /* set up yytext */ ------------------ | | 584| 0| do { \ | | 585| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ | | 586| 0| \ | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 588| 0| \ | | 589| 0| (yy_hold_char) = *yy_cp; \ | | 590| 0| *yy_cp = '\0'; \ | | 591| 0| \ | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | 593| 0| } while(0) | | ------------------ | | | Branch (593:10): [Folded - Ignored] | | ------------------ ------------------ 4398| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4399| | 4400| 0|#line 803 "./scan.l" 4401| 0|BEGIN(CARETISBOL); return '>'; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CARETISBOL); return '>'; ------------------ | | 2506| 0|#define CARETISBOL 7 ------------------ 4402| 0| /*LINTED*/break; 4403| 134| case 184: ------------------ | Branch (4403:2): [True: 134, False: 11.9M] ------------------ 4404| 134|YY_RULE_SETUP ------------------ | | 2732| 134| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 134, False: 0] | | ------------------ | | 2733| 134| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 134|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 134| } \ | | 2735| 134| YY_USER_ACTION ------------------ 4405| | 4406| 134|#line 804 "./scan.l" 4407| 134|RETURNNAME; ------------------ | | 2444| 134| if(yyleng < MAXLINE) \ | | ------------------ | | | | 99| 134|#define MAXLINE 2048 | | ------------------ | | | Branch (2444:5): [True: 134, False: 0] | | ------------------ | | 2445| 134| { \ | | 2446| 134| strncpy( nmstr, yytext, sizeof(nmstr) ); \ | | 2447| 134| return NAME; \ | | ------------------ | | | | 114| 134|#define NAME 263 | | ------------------ | | 2448| 134| } \ | | 2449| 134| else \ | | 2450| 134| do { \ | | 2451| 0| synerr(_("Input line too long\n")); \ | | ------------------ | | | | 85| 0|#define _(String) gettext (String) | | ------------------ | | 2452| 0| FLEX_EXIT(EXIT_FAILURE); \ | | ------------------ | | | | 1127| 0|#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) | | ------------------ | | 2453| 0| } while (0) | | ------------------ | | | Branch (2453:12): [Folded - Ignored] | | ------------------ ------------------ 4408| 0| /*LINTED*/break; 4409| 3.37k| case 185: ------------------ | Branch (4409:2): [True: 3.37k, False: 11.9M] ------------------ 4410| 3.37k|YY_RULE_SETUP ------------------ | | 2732| 3.37k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 3.37k, False: 0] | | ------------------ | | 2733| 3.37k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 3.37k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 3.37k| } \ | | 2735| 3.37k| YY_USER_ACTION ------------------ 4411| | 4412| 3.37k|#line 805 "./scan.l" 4413| 3.37k|{ 4414| 3.37k| format_synerr( _( "bad : %s" ), ------------------ | | 85| 3.37k|#define _(String) gettext (String) ------------------ 4415| 3.37k| yytext ); 4416| 3.37k| } 4417| 3.37k| /*LINTED*/break; 4418| | 4419| 0| case 186: ------------------ | Branch (4419:2): [True: 0, False: 11.9M] ------------------ 4420| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4421| | 4422| 0|#line 811 "./scan.l" 4423| 0|BEGIN(SECT2); return '^'; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); return '^'; ------------------ | | 2500| 0|#define SECT2 1 ------------------ 4424| 0| /*LINTED*/break; 4425| | 4426| 961| case 187: ------------------ | Branch (4426:2): [True: 961, False: 11.9M] ------------------ 4427| 961|YY_RULE_SETUP ------------------ | | 2732| 961| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 961, False: 0] | | ------------------ | | 2733| 961| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 961|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 961| } \ | | 2735| 961| YY_USER_ACTION ------------------ 4428| | 4429| 961|#line 815 "./scan.l" 4430| 961|RETURNCHAR; ------------------ | | 2440| 961| yylval = (unsigned char) yytext[0]; \ | | 2441| 961| return CHAR; | | ------------------ | | | | 109| 961|#define CHAR 258 | | ------------------ ------------------ 4431| 0| /*LINTED*/break; 4432| 19| case 188: ------------------ | Branch (4432:2): [True: 19, False: 11.9M] ------------------ 4433| 19|YY_RULE_SETUP ------------------ | | 2732| 19| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 19, False: 0] | | ------------------ | | 2733| 19| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 19|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 19| } \ | | 2735| 19| YY_USER_ACTION ------------------ 4434| | 4435| 19|#line 816 "./scan.l" 4436| 19|BEGIN(SECT2); return '"'; ------------------ | | 233| 19|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); return '"'; ------------------ | | 2500| 19|#define SECT2 1 ------------------ 4437| 0| /*LINTED*/break; 4438| 10| case 189: ------------------ | Branch (4438:2): [True: 10, False: 11.9M] ------------------ 4439| |/* rule 189 can match eol */ 4440| 10|YY_RULE_SETUP ------------------ | | 2732| 10| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 10, False: 0] | | ------------------ | | 2733| 10| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 10|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 10| } \ | | 2735| 10| YY_USER_ACTION ------------------ 4441| | 4442| 10|#line 818 "./scan.l" 4443| 10|{ 4444| 10| synerr( _( "missing quote" ) ); ------------------ | | 85| 10|#define _(String) gettext (String) ------------------ 4445| 10| BEGIN(SECT2); ------------------ | | 233| 10|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 10|#define SECT2 1 ------------------ 4446| 10| ++linenum; 4447| 10| return '"'; 4448| 134| } 4449| 0| /*LINTED*/break; 4450| | 4451| | 4452| 0| case 190: ------------------ | Branch (4452:2): [True: 0, False: 11.9M] ------------------ 4453| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4454| | 4455| 0|#line 827 "./scan.l" 4456| 0|BEGIN(SECT2); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 0|#define SECT2 1 ------------------ 4457| 0| /*LINTED*/break; 4458| 0| case 191: ------------------ | Branch (4458:2): [True: 0, False: 11.9M] ------------------ 4459| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4460| | 4461| 0|#line 828 "./scan.l" 4462| 0|BEGIN(GROUP_MINUS_PARAMS); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(GROUP_MINUS_PARAMS); ------------------ | | 2520| 0|#define GROUP_MINUS_PARAMS 21 ------------------ 4463| 0| /*LINTED*/break; 4464| 0| case 192: ------------------ | Branch (4464:2): [True: 0, False: 11.9M] ------------------ 4465| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4466| | 4467| 0|#line 829 "./scan.l" 4468| 0|sf_set_case_ins(1); ------------------ | | 1208| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 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)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1208:34): [Folded - Ignored] | | ------------------ ------------------ 4469| 0| /*LINTED*/break; 4470| 0| case 193: ------------------ | Branch (4470:2): [True: 0, False: 11.9M] ------------------ 4471| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4472| | 4473| 0|#line 830 "./scan.l" 4474| 0|sf_set_dot_all(1); ------------------ | | 1209| 0|#define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1202| 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)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1202| 0|#define _SF_DOT_ALL ((scanflags_t) 0x0002) | | ------------------ | | | Branch (1209:34): [Folded - Ignored] | | ------------------ ------------------ 4475| 0| /*LINTED*/break; 4476| 0| case 194: ------------------ | Branch (4476:2): [True: 0, False: 11.9M] ------------------ 4477| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4478| | 4479| 0|#line 831 "./scan.l" 4480| 0|sf_set_skip_ws(1); ------------------ | | 1210| 0|#define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1203| 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)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1203| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1210:34): [Folded - Ignored] | | ------------------ ------------------ 4481| 0| /*LINTED*/break; 4482| | 4483| | 4484| 0| case 195: ------------------ | Branch (4484:2): [True: 0, False: 11.9M] ------------------ 4485| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4486| | 4487| 0|#line 834 "./scan.l" 4488| 0|BEGIN(SECT2); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 0|#define SECT2 1 ------------------ 4489| 0| /*LINTED*/break; 4490| 0| case 196: ------------------ | Branch (4490:2): [True: 0, False: 11.9M] ------------------ 4491| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4492| | 4493| 0|#line 835 "./scan.l" 4494| 0|sf_set_case_ins(0); ------------------ | | 1208| 0|#define sf_set_case_ins(X) ((X) ? (sf_top() |= _SF_CASE_INS) : (sf_top() &= ~_SF_CASE_INS)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 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)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1201| 0|#define _SF_CASE_INS ((scanflags_t) 0x0001) | | ------------------ | | | Branch (1208:34): [Folded - Ignored] | | ------------------ ------------------ 4495| 0| /*LINTED*/break; 4496| 0| case 197: ------------------ | Branch (4496:2): [True: 0, False: 11.9M] ------------------ 4497| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4498| | 4499| 0|#line 836 "./scan.l" 4500| 0|sf_set_dot_all(0); ------------------ | | 1209| 0|#define sf_set_dot_all(X) ((X) ? (sf_top() |= _SF_DOT_ALL) : (sf_top() &= ~_SF_DOT_ALL)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1202| 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)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1202| 0|#define _SF_DOT_ALL ((scanflags_t) 0x0002) | | ------------------ | | | Branch (1209:34): [Folded - Ignored] | | ------------------ ------------------ 4501| 0| /*LINTED*/break; 4502| 0| case 198: ------------------ | Branch (4502:2): [True: 0, False: 11.9M] ------------------ 4503| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4504| | 4505| 0|#line 837 "./scan.l" 4506| 0|sf_set_skip_ws(0); ------------------ | | 1210| 0|#define sf_set_skip_ws(X) ((X) ? (sf_top() |= _SF_SKIP_WS) : (sf_top() &= ~_SF_SKIP_WS)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1203| 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)) | | ------------------ | | | | 1204| 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)) | | ------------------ | | | | 1203| 0|#define _SF_SKIP_WS ((scanflags_t) 0x0004) | | ------------------ | | | Branch (1210:34): [Folded - Ignored] | | ------------------ ------------------ 4507| 0| /*LINTED*/break; 4508| | 4509| | 4510| 0| case 199: ------------------ | Branch (4510:2): [True: 0, False: 11.9M] ------------------ 4511| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4512| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 4513| 0|YY_DO_BEFORE_ACTION; /* set up yytext */ ------------------ | | 584| 0| do { \ | | 585| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ | | 586| 0| \ | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 588| 0| \ | | 589| 0| (yy_hold_char) = *yy_cp; \ | | 590| 0| *yy_cp = '\0'; \ | | 591| 0| \ | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | 593| 0| } while(0) | | ------------------ | | | Branch (593:10): [Folded - Ignored] | | ------------------ ------------------ 4514| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4515| | 4516| 0|#line 841 "./scan.l" 4517| 0|BEGIN(CCL); return '^'; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return '^'; ------------------ | | 2510| 0|#define CCL 11 ------------------ 4518| 0| /*LINTED*/break; 4519| 0| case 200: ------------------ | Branch (4519:2): [True: 0, False: 11.9M] ------------------ 4520| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4521| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 4522| 0|YY_DO_BEFORE_ACTION; /* set up yytext */ ------------------ | | 584| 0| do { \ | | 585| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ | | 586| 0| \ | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 588| 0| \ | | 589| 0| (yy_hold_char) = *yy_cp; \ | | 590| 0| *yy_cp = '\0'; \ | | 591| 0| \ | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | 593| 0| } while(0) | | ------------------ | | | Branch (593:10): [Folded - Ignored] | | ------------------ ------------------ 4523| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4524| | 4525| 0|#line 842 "./scan.l" 4526| 0|return '^'; 4527| 0| /*LINTED*/break; 4528| 73| case 201: ------------------ | Branch (4528:2): [True: 73, False: 11.9M] ------------------ 4529| 73|YY_RULE_SETUP ------------------ | | 2732| 73| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 73, False: 0] | | ------------------ | | 2733| 73| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 73|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 73| } \ | | 2735| 73| YY_USER_ACTION ------------------ 4530| | 4531| 73|#line 843 "./scan.l" 4532| 73|BEGIN(CCL); RETURNCHAR; ------------------ | | 233| 73|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); RETURNCHAR; ------------------ | | 2510| 73|#define CCL 11 ------------------ BEGIN(CCL); RETURNCHAR; ------------------ | | 2440| 73| yylval = (unsigned char) yytext[0]; \ | | 2441| 73| return CHAR; | | ------------------ | | | | 109| 73|#define CHAR 258 | | ------------------ ------------------ 4533| 0| /*LINTED*/break; 4534| | 4535| | 4536| 0| case 202: ------------------ | Branch (4536:2): [True: 0, False: 11.9M] ------------------ 4537| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4538| 0|(yy_c_buf_p) = yy_cp = yy_bp + 1; 4539| 0|YY_DO_BEFORE_ACTION; /* set up yytext */ ------------------ | | 584| 0| do { \ | | 585| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ | | 586| 0| \ | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 588| 0| \ | | 589| 0| (yy_hold_char) = *yy_cp; \ | | 590| 0| *yy_cp = '\0'; \ | | 591| 0| \ | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | 593| 0| } while(0) | | ------------------ | | | Branch (593:10): [Folded - Ignored] | | ------------------ ------------------ 4540| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4541| | 4542| 0|#line 847 "./scan.l" 4543| 0|return '-'; 4544| 0| /*LINTED*/break; 4545| 1.59k| case 203: ------------------ | Branch (4545:2): [True: 1.59k, False: 11.9M] ------------------ 4546| 1.59k|YY_RULE_SETUP ------------------ | | 2732| 1.59k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 1.59k, False: 0] | | ------------------ | | 2733| 1.59k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 1.59k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 1.59k| } \ | | 2735| 1.59k| YY_USER_ACTION ------------------ 4547| | 4548| 1.59k|#line 848 "./scan.l" 4549| 1.59k|RETURNCHAR; ------------------ | | 2440| 1.59k| yylval = (unsigned char) yytext[0]; \ | | 2441| 1.59k| return CHAR; | | ------------------ | | | | 109| 1.59k|#define CHAR 258 | | ------------------ ------------------ 4550| 0| /*LINTED*/break; 4551| 34| case 204: ------------------ | Branch (4551:2): [True: 34, False: 11.9M] ------------------ 4552| 34|YY_RULE_SETUP ------------------ | | 2732| 34| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 34, False: 0] | | ------------------ | | 2733| 34| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 34|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 34| } \ | | 2735| 34| YY_USER_ACTION ------------------ 4553| | 4554| 34|#line 849 "./scan.l" 4555| 34|BEGIN(SECT2); return ']'; ------------------ | | 233| 34|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); return ']'; ------------------ | | 2500| 34|#define SECT2 1 ------------------ 4556| 0| /*LINTED*/break; 4557| 44| case 205: ------------------ | Branch (4557:2): [True: 44, False: 11.9M] ------------------ 4558| |/* rule 205 can match eol */ 4559| 44|YY_RULE_SETUP ------------------ | | 2732| 44| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 44, False: 0] | | ------------------ | | 2733| 44| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 44|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 44| } \ | | 2735| 44| YY_USER_ACTION ------------------ 4560| | 4561| 44|#line 850 "./scan.l" 4562| 44|{ 4563| 44| synerr( _( "bad character class" ) ); ------------------ | | 85| 44|#define _(String) gettext (String) ------------------ 4564| 44| BEGIN(SECT2); ------------------ | | 233| 44|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 44|#define SECT2 1 ------------------ 4565| 44| return ']'; 4566| 134| } 4567| 0| /*LINTED*/break; 4568| | 4569| | 4570| 0| case 206: ------------------ | Branch (4570:2): [True: 0, False: 11.9M] ------------------ 4571| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4572| | 4573| 0|#line 858 "./scan.l" 4574| 0|BEGIN(CCL); return CCE_ALNUM; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_ALNUM; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_ALNUM; ------------------ | | 133| 0|#define CCE_ALNUM 282 ------------------ 4575| 0| /*LINTED*/break; 4576| 0| case 207: ------------------ | Branch (4576:2): [True: 0, False: 11.9M] ------------------ 4577| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4578| | 4579| 0|#line 859 "./scan.l" 4580| 0|BEGIN(CCL); return CCE_ALPHA; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_ALPHA; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_ALPHA; ------------------ | | 134| 0|#define CCE_ALPHA 283 ------------------ 4581| 0| /*LINTED*/break; 4582| 0| case 208: ------------------ | Branch (4582:2): [True: 0, False: 11.9M] ------------------ 4583| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4584| | 4585| 0|#line 860 "./scan.l" 4586| 0|BEGIN(CCL); return CCE_BLANK; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_BLANK; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_BLANK; ------------------ | | 135| 0|#define CCE_BLANK 284 ------------------ 4587| 0| /*LINTED*/break; 4588| 0| case 209: ------------------ | Branch (4588:2): [True: 0, False: 11.9M] ------------------ 4589| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4590| | 4591| 0|#line 861 "./scan.l" 4592| 0|BEGIN(CCL); return CCE_CNTRL; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_CNTRL; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_CNTRL; ------------------ | | 136| 0|#define CCE_CNTRL 285 ------------------ 4593| 0| /*LINTED*/break; 4594| 0| case 210: ------------------ | Branch (4594:2): [True: 0, False: 11.9M] ------------------ 4595| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4596| | 4597| 0|#line 862 "./scan.l" 4598| 0|BEGIN(CCL); return CCE_DIGIT; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_DIGIT; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_DIGIT; ------------------ | | 137| 0|#define CCE_DIGIT 286 ------------------ 4599| 0| /*LINTED*/break; 4600| 0| case 211: ------------------ | Branch (4600:2): [True: 0, False: 11.9M] ------------------ 4601| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4602| | 4603| 0|#line 863 "./scan.l" 4604| 0|BEGIN(CCL); return CCE_GRAPH; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_GRAPH; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_GRAPH; ------------------ | | 138| 0|#define CCE_GRAPH 287 ------------------ 4605| 0| /*LINTED*/break; 4606| 0| case 212: ------------------ | Branch (4606:2): [True: 0, False: 11.9M] ------------------ 4607| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4608| | 4609| 0|#line 864 "./scan.l" 4610| 0|BEGIN(CCL); return CCE_LOWER; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_LOWER; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_LOWER; ------------------ | | 139| 0|#define CCE_LOWER 288 ------------------ 4611| 0| /*LINTED*/break; 4612| 0| case 213: ------------------ | Branch (4612:2): [True: 0, False: 11.9M] ------------------ 4613| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4614| | 4615| 0|#line 865 "./scan.l" 4616| 0|BEGIN(CCL); return CCE_PRINT; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_PRINT; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_PRINT; ------------------ | | 140| 0|#define CCE_PRINT 289 ------------------ 4617| 0| /*LINTED*/break; 4618| 0| case 214: ------------------ | Branch (4618:2): [True: 0, False: 11.9M] ------------------ 4619| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4620| | 4621| 0|#line 866 "./scan.l" 4622| 0|BEGIN(CCL); return CCE_PUNCT; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_PUNCT; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_PUNCT; ------------------ | | 141| 0|#define CCE_PUNCT 290 ------------------ 4623| 0| /*LINTED*/break; 4624| 0| case 215: ------------------ | Branch (4624:2): [True: 0, False: 11.9M] ------------------ 4625| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4626| | 4627| 0|#line 867 "./scan.l" 4628| 0|BEGIN(CCL); return CCE_SPACE; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_SPACE; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_SPACE; ------------------ | | 142| 0|#define CCE_SPACE 291 ------------------ 4629| 0| /*LINTED*/break; 4630| 0| case 216: ------------------ | Branch (4630:2): [True: 0, False: 11.9M] ------------------ 4631| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4632| | 4633| 0|#line 868 "./scan.l" 4634| 0|BEGIN(CCL); return CCE_UPPER; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_UPPER; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_UPPER; ------------------ | | 143| 0|#define CCE_UPPER 292 ------------------ 4635| 0| /*LINTED*/break; 4636| 0| case 217: ------------------ | Branch (4636:2): [True: 0, False: 11.9M] ------------------ 4637| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4638| | 4639| 0|#line 869 "./scan.l" 4640| 0|BEGIN(CCL); return CCE_XDIGIT; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_XDIGIT; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_XDIGIT; ------------------ | | 144| 0|#define CCE_XDIGIT 293 ------------------ 4641| 0| /*LINTED*/break; 4642| 0| case 218: ------------------ | Branch (4642:2): [True: 0, False: 11.9M] ------------------ 4643| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4644| | 4645| 0|#line 871 "./scan.l" 4646| 0|BEGIN(CCL); return CCE_NEG_ALNUM; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_ALNUM; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_ALNUM; ------------------ | | 145| 0|#define CCE_NEG_ALNUM 294 ------------------ 4647| 0| /*LINTED*/break; 4648| 0| case 219: ------------------ | Branch (4648:2): [True: 0, False: 11.9M] ------------------ 4649| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4650| | 4651| 0|#line 872 "./scan.l" 4652| 0|BEGIN(CCL); return CCE_NEG_ALPHA; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_ALPHA; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_ALPHA; ------------------ | | 146| 0|#define CCE_NEG_ALPHA 295 ------------------ 4653| 0| /*LINTED*/break; 4654| 0| case 220: ------------------ | Branch (4654:2): [True: 0, False: 11.9M] ------------------ 4655| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4656| | 4657| 0|#line 873 "./scan.l" 4658| 0|BEGIN(CCL); return CCE_NEG_BLANK; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_BLANK; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_BLANK; ------------------ | | 147| 0|#define CCE_NEG_BLANK 296 ------------------ 4659| 0| /*LINTED*/break; 4660| 0| case 221: ------------------ | Branch (4660:2): [True: 0, False: 11.9M] ------------------ 4661| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4662| | 4663| 0|#line 874 "./scan.l" 4664| 0|BEGIN(CCL); return CCE_NEG_CNTRL; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_CNTRL; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_CNTRL; ------------------ | | 148| 0|#define CCE_NEG_CNTRL 297 ------------------ 4665| 0| /*LINTED*/break; 4666| 0| case 222: ------------------ | Branch (4666:2): [True: 0, False: 11.9M] ------------------ 4667| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4668| | 4669| 0|#line 875 "./scan.l" 4670| 0|BEGIN(CCL); return CCE_NEG_DIGIT; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_DIGIT; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_DIGIT; ------------------ | | 149| 0|#define CCE_NEG_DIGIT 298 ------------------ 4671| 0| /*LINTED*/break; 4672| 0| case 223: ------------------ | Branch (4672:2): [True: 0, False: 11.9M] ------------------ 4673| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4674| | 4675| 0|#line 876 "./scan.l" 4676| 0|BEGIN(CCL); return CCE_NEG_GRAPH; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_GRAPH; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_GRAPH; ------------------ | | 150| 0|#define CCE_NEG_GRAPH 299 ------------------ 4677| 0| /*LINTED*/break; 4678| 0| case 224: ------------------ | Branch (4678:2): [True: 0, False: 11.9M] ------------------ 4679| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4680| | 4681| 0|#line 877 "./scan.l" 4682| 0|BEGIN(CCL); return CCE_NEG_LOWER; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_LOWER; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_LOWER; ------------------ | | 151| 0|#define CCE_NEG_LOWER 300 ------------------ 4683| 0| /*LINTED*/break; 4684| 0| case 225: ------------------ | Branch (4684:2): [True: 0, False: 11.9M] ------------------ 4685| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4686| | 4687| 0|#line 878 "./scan.l" 4688| 0|BEGIN(CCL); return CCE_NEG_PRINT; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_PRINT; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_PRINT; ------------------ | | 152| 0|#define CCE_NEG_PRINT 301 ------------------ 4689| 0| /*LINTED*/break; 4690| 0| case 226: ------------------ | Branch (4690:2): [True: 0, False: 11.9M] ------------------ 4691| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4692| | 4693| 0|#line 879 "./scan.l" 4694| 0|BEGIN(CCL); return CCE_NEG_PUNCT; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_PUNCT; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_PUNCT; ------------------ | | 153| 0|#define CCE_NEG_PUNCT 302 ------------------ 4695| 0| /*LINTED*/break; 4696| 0| case 227: ------------------ | Branch (4696:2): [True: 0, False: 11.9M] ------------------ 4697| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4698| | 4699| 0|#line 880 "./scan.l" 4700| 0|BEGIN(CCL); return CCE_NEG_SPACE; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_SPACE; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_SPACE; ------------------ | | 154| 0|#define CCE_NEG_SPACE 303 ------------------ 4701| 0| /*LINTED*/break; 4702| 0| case 228: ------------------ | Branch (4702:2): [True: 0, False: 11.9M] ------------------ 4703| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4704| | 4705| 0|#line 881 "./scan.l" 4706| 0|BEGIN(CCL); return CCE_NEG_UPPER; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_UPPER; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_UPPER; ------------------ | | 155| 0|#define CCE_NEG_UPPER 304 ------------------ 4707| 0| /*LINTED*/break; 4708| 0| case 229: ------------------ | Branch (4708:2): [True: 0, False: 11.9M] ------------------ 4709| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4710| | 4711| 0|#line 882 "./scan.l" 4712| 0|BEGIN(CCL); return CCE_NEG_XDIGIT; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_NEG_XDIGIT; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_NEG_XDIGIT; ------------------ | | 156| 0|#define CCE_NEG_XDIGIT 305 ------------------ 4713| 0| /*LINTED*/break; 4714| 0| case 230: ------------------ | Branch (4714:2): [True: 0, False: 11.9M] ------------------ 4715| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4716| | 4717| 0|#line 883 "./scan.l" 4718| 0|{ 4719| 0| format_synerr( 4720| 0| _( "bad character class expression: %s" ), ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 4721| 0| yytext ); 4722| 0| BEGIN(CCL); return CCE_ALNUM; ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); return CCE_ALNUM; ------------------ | | 2510| 0|#define CCL 11 ------------------ BEGIN(CCL); return CCE_ALNUM; ------------------ | | 133| 0|#define CCE_ALNUM 282 ------------------ 4723| 134| } 4724| 0| /*LINTED*/break; 4725| | 4726| | 4727| 2| case 231: ------------------ | Branch (4727:2): [True: 2, False: 11.9M] ------------------ 4728| 2|YY_RULE_SETUP ------------------ | | 2732| 2| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 2, False: 0] | | ------------------ | | 2733| 2| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 2| } \ | | 2735| 2| YY_USER_ACTION ------------------ 4729| | 4730| 2|#line 892 "./scan.l" 4731| 2|{ 4732| 2| yylval = myctoi( yytext ); 4733| 2| return NUMBER; ------------------ | | 110| 2|#define NUMBER 259 ------------------ 4734| 134| } 4735| 0| /*LINTED*/break; 4736| 0| case 232: ------------------ | Branch (4736:2): [True: 0, False: 11.9M] ------------------ 4737| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4738| | 4739| 0|#line 897 "./scan.l" 4740| 0|return ','; 4741| 0| /*LINTED*/break; 4742| 0| case 233: ------------------ | Branch (4742:2): [True: 0, False: 11.9M] ------------------ 4743| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4744| | 4745| 0|#line 898 "./scan.l" 4746| 0|{ 4747| 0| BEGIN(SECT2); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 0|#define SECT2 1 ------------------ 4748| 0| if ( ctrl.lex_compat || ctrl.posix_compat ) ------------------ | Branch (4748:9): [True: 0, False: 0] | Branch (4748:28): [True: 0, False: 0] ------------------ 4749| 0| return END_REPEAT_POSIX; ------------------ | | 160| 0|#define END_REPEAT_POSIX 309 ------------------ 4750| 0| else 4751| 0| return END_REPEAT_FLEX; ------------------ | | 162| 0|#define END_REPEAT_FLEX 311 ------------------ 4752| 0| } 4753| 0| /*LINTED*/break; 4754| 2| case 234: ------------------ | Branch (4754:2): [True: 2, False: 11.9M] ------------------ 4755| 2|YY_RULE_SETUP ------------------ | | 2732| 2| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 2, False: 0] | | ------------------ | | 2733| 2| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 2| } \ | | 2735| 2| YY_USER_ACTION ------------------ 4756| | 4757| 2|#line 906 "./scan.l" 4758| 2|{ 4759| 2| synerr( _( "bad character inside {}'s" ) ); ------------------ | | 85| 2|#define _(String) gettext (String) ------------------ 4760| 2| BEGIN(SECT2); ------------------ | | 233| 2|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 2|#define SECT2 1 ------------------ 4761| 2| return '}'; 4762| 0| } 4763| 0| /*LINTED*/break; 4764| 0| case 235: ------------------ | Branch (4764:2): [True: 0, False: 11.9M] ------------------ 4765| |/* rule 235 can match eol */ 4766| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4767| | 4768| 0|#line 912 "./scan.l" 4769| 0|{ 4770| 0| synerr( _( "missing }" ) ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 4771| 0| BEGIN(SECT2); ------------------ | | 233| 0|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 0|#define SECT2 1 ------------------ 4772| 0| ++linenum; 4773| 0| return '}'; 4774| 0| } 4775| 0| /*LINTED*/break; 4776| | 4777| | 4778| 2| case 236: ------------------ | Branch (4778:2): [True: 2, False: 11.9M] ------------------ 4779| 2|YY_RULE_SETUP ------------------ | | 2732| 2| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 2, False: 0] | | ------------------ | | 2733| 2| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 2|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 2| } \ | | 2735| 2| YY_USER_ACTION ------------------ 4780| | 4781| 2|#line 922 "./scan.l" 4782| 2|bracelevel = 0; 4783| 2| /*LINTED*/break; 4784| 1.28k| case 237: ------------------ | Branch (4784:2): [True: 1.28k, False: 11.9M] ------------------ 4785| 1.28k|YY_RULE_SETUP ------------------ | | 2732| 1.28k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 1.28k, False: 0] | | ------------------ | | 2733| 1.28k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 1.28k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 1.28k| } \ | | 2735| 1.28k| YY_USER_ACTION ------------------ 4786| | 4787| 1.28k|#line 924 "./scan.l" 4788| 1.28k|ACTION_ECHO; yy_push_state( CODE_COMMENT ); ------------------ | | 2430| 1.28k|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; yy_push_state( CODE_COMMENT ); ------------------ | | 2523| 1.28k|#define CODE_COMMENT 24 ------------------ 4789| 1.28k| /*LINTED*/break; 4790| | 4791| 0| case 238: ------------------ | Branch (4791:2): [True: 0, False: 11.9M] ------------------ 4792| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4793| | 4794| 0|#line 927 "./scan.l" 4795| 0|{ 4796| 0| ACTION_ECHO; ------------------ | | 2430| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4797| 0| CHECK_REJECT(yytext); ------------------ | | 2462| 0| if ( all_upper( str ) ) \ | | ------------------ | | | Branch (2462:7): [True: 0, False: 0] | | ------------------ | | 2463| 0| reject = true; ------------------ 4798| 0| } 4799| 0| /*LINTED*/break; 4800| 0| case 239: ------------------ | Branch (4800:2): [True: 0, False: 11.9M] ------------------ 4801| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4802| | 4803| 0|#line 931 "./scan.l" 4804| 0|{ 4805| 0| add_action("]""]M4_HOOK_REJECT[""["); 4806| 0| CHECK_YYREJECT(yytext); ------------------ | | 2466| 0| if ( all_lower( str ) ) \ | | ------------------ | | | Branch (2466:7): [True: 0, False: 0] | | ------------------ | | 2467| 0| reject = true; ------------------ 4807| 0| } 4808| 0| /*LINTED*/break; 4809| 0| case 240: ------------------ | Branch (4809:2): [True: 0, False: 11.9M] ------------------ 4810| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4811| | 4812| 0|#line 935 "./scan.l" 4813| 0|{ 4814| 0| yymore_used = true; 4815| 0| if (ctrl.rewrite) ------------------ | Branch (4815:8): [True: 0, False: 0] ------------------ 4816| 0| context_call(yytext); 4817| 0| else 4818| 0| ACTION_ECHO; ------------------ | | 2430| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4819| 0| } 4820| 0| /*LINTED*/break; 4821| | 4822| 1.71k| case 241: ------------------ | Branch (4822:2): [True: 1.71k, False: 11.9M] ------------------ 4823| 1.71k|YY_RULE_SETUP ------------------ | | 2732| 1.71k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 1.71k, False: 0] | | ------------------ | | 2733| 1.71k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 1.71k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 1.71k| } \ | | 2735| 1.71k| YY_USER_ACTION ------------------ 4824| | 4825| 1.71k|#line 944 "./scan.l" 4826| 1.71k|ACTION_ECHO; ------------------ | | 2430| 1.71k|#define ACTION_ECHO add_action( yytext ) ------------------ 4827| 1.71k| /*LINTED*/break; 4828| 80| case 242: ------------------ | Branch (4828:2): [True: 80, False: 11.9M] ------------------ 4829| |/* rule 242 can match eol */ 4830| 80|YY_RULE_SETUP ------------------ | | 2732| 80| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 80, False: 0] | | ------------------ | | 2733| 80| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 80|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 80| } \ | | 2735| 80| YY_USER_ACTION ------------------ 4831| | 4832| 80|#line 945 "./scan.l" 4833| 80|{ 4834| 80| ++linenum; 4835| 80| ACTION_ECHO; ------------------ | | 2430| 80|#define ACTION_ECHO add_action( yytext ) ------------------ 4836| 80| if (bracelevel <= 0 || (doing_codeblock && indented_code)) { ------------------ | Branch (4836:7): [True: 2, False: 78] | Branch (4836:27): [True: 0, False: 78] | Branch (4836:46): [True: 0, False: 0] ------------------ 4837| 2| if ( doing_rule_action ) ------------------ | Branch (4837:18): [True: 0, False: 2] ------------------ 4838| 0| add_action( "\t]""]M4_HOOK_STATE_CASE_BREAK\n" ); 4839| | 4840| 2| doing_rule_action = doing_codeblock = false; 4841| 2| BEGIN(SECT2); ------------------ | | 233| 2|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 2|#define SECT2 1 ------------------ 4842| 2| } 4843| 80| } 4844| 80| /*LINTED*/break; 4845| | 4846| |/* yyreject and yymore() are checked for above, in PERCENT_BRACE_ACTION */ 4847| | 4848| 63.1k| case 243: ------------------ | Branch (4848:2): [True: 63.1k, False: 11.8M] ------------------ 4849| 63.1k|YY_RULE_SETUP ------------------ | | 2732| 63.1k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 63.1k, False: 0] | | ------------------ | | 2733| 63.1k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 63.1k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 63.1k| } \ | | 2735| 63.1k| YY_USER_ACTION ------------------ 4850| | 4851| 63.1k|#line 961 "./scan.l" 4852| 63.1k|ACTION_ECHO; ++bracelevel; ------------------ | | 2430| 63.1k|#define ACTION_ECHO add_action( yytext ) ------------------ 4853| 63.1k| /*LINTED*/break; 4854| 30.9k| case 244: ------------------ | Branch (4854:2): [True: 30.9k, False: 11.8M] ------------------ 4855| 30.9k|YY_RULE_SETUP ------------------ | | 2732| 30.9k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 30.9k, False: 0] | | ------------------ | | 2733| 30.9k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 30.9k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 30.9k| } \ | | 2735| 30.9k| YY_USER_ACTION ------------------ 4856| | 4857| 30.9k|#line 962 "./scan.l" 4858| 30.9k|ACTION_ECHO; --bracelevel; ------------------ | | 2430| 30.9k|#define ACTION_ECHO add_action( yytext ) ------------------ 4859| 30.9k| /*LINTED*/break; 4860| 0| case 245: ------------------ | Branch (4860:2): [True: 0, False: 11.9M] ------------------ 4861| |/* rule 245 can match eol */ 4862| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4863| | 4864| 0|#line 963 "./scan.l" 4865| 0|{ 4866| 0| if (ctrl.rewrite) ------------------ | Branch (4866:8): [True: 0, False: 0] ------------------ 4867| 0| context_call(yytext); 4868| 0| else 4869| 0| ACTION_ECHO; ------------------ | | 2430| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4870| 0| } 4871| 0| /*LINTED*/break; 4872| 0| case 246: ------------------ | Branch (4872:2): [True: 0, False: 11.9M] ------------------ 4873| |/* rule 246 can match eol */ 4874| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4875| | 4876| 0|#line 969 "./scan.l" 4877| 0|{ 4878| 0| add_action("]""]"); 4879| 0| add_action(yytext); 4880| 0| add_action("[""["); 4881| 0| } 4882| 0| /*LINTED*/break; 4883| 0| case 247: ------------------ | Branch (4883:2): [True: 0, False: 11.9M] ------------------ 4884| |/* rule 247 can match eol */ 4885| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4886| 0|YY_LINENO_REWIND_TO(yy_cp - 1); 4887| 0|(yy_c_buf_p) = yy_cp -= 1; 4888| 0|YY_DO_BEFORE_ACTION; /* set up yytext */ ------------------ | | 584| 0| do { \ | | 585| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ | | 586| 0| \ | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 588| 0| \ | | 589| 0| (yy_hold_char) = *yy_cp; \ | | 590| 0| *yy_cp = '\0'; \ | | 591| 0| \ | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | 593| 0| } while(0) | | ------------------ | | | Branch (593:10): [Folded - Ignored] | | ------------------ ------------------ 4889| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4890| | 4891| 0|#line 974 "./scan.l" 4892| 0|{ 4893| 0| if (ctrl.rewrite) ------------------ | Branch (4893:8): [True: 0, False: 0] ------------------ 4894| 0| context_member(yytext, "M4_PROPERTY_CONTEXT_FORMAT"); 4895| 0| else 4896| 0| ACTION_ECHO; ------------------ | | 2430| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4897| 0| } 4898| 0| /*LINTED*/break; 4899| 0| case 248: ------------------ | Branch (4899:2): [True: 0, False: 11.9M] ------------------ 4900| |/* rule 248 can match eol */ 4901| 0|*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ 4902| 0|YY_LINENO_REWIND_TO(yy_cp - 1); 4903| 0|(yy_c_buf_p) = yy_cp -= 1; 4904| 0|YY_DO_BEFORE_ACTION; /* set up yytext */ ------------------ | | 584| 0| do { \ | | 585| 0| (yytext_ptr) = yy_bp; \ | | ------------------ | | | | 528| 0|#define yytext_ptr yytext | | ------------------ | | 586| 0| \ | | 587| 0| yyleng = (int) (yy_cp - yy_bp); \ | | 588| 0| \ | | 589| 0| (yy_hold_char) = *yy_cp; \ | | 590| 0| *yy_cp = '\0'; \ | | 591| 0| \ | | 592| 0| (yy_c_buf_p) = yy_cp; \ | | 593| 0| } while(0) | | ------------------ | | | Branch (593:10): [Folded - Ignored] | | ------------------ ------------------ 4905| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 4906| | 4907| 0|#line 980 "./scan.l" 4908| 0|{ 4909| 0| if (ctrl.rewrite) ------------------ | Branch (4909:8): [True: 0, False: 0] ------------------ 4910| 0| context_member(yytext, "M4_PROPERTY_BUFFERSTACK_CONTEXT_FORMAT"); 4911| 0| else 4912| 0| ACTION_ECHO; ------------------ | | 2430| 0|#define ACTION_ECHO add_action( yytext ) ------------------ 4913| 0| } 4914| 0| /*LINTED*/break; 4915| 979k| case 249: ------------------ | Branch (4915:2): [True: 979k, False: 10.9M] ------------------ 4916| 979k|YY_RULE_SETUP ------------------ | | 2732| 979k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 979k, False: 0] | | ------------------ | | 2733| 979k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 979k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 979k| } \ | | 2735| 979k| YY_USER_ACTION ------------------ 4917| | 4918| 979k|#line 986 "./scan.l" 4919| 979k|ACTION_ECHO; ------------------ | | 2430| 979k|#define ACTION_ECHO add_action( yytext ) ------------------ 4920| 979k| /*LINTED*/break; 4921| 801k| case 250: ------------------ | Branch (4921:2): [True: 801k, False: 11.1M] ------------------ 4922| 801k|YY_RULE_SETUP ------------------ | | 2732| 801k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 801k, False: 0] | | ------------------ | | 2733| 801k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 801k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 801k| } \ | | 2735| 801k| YY_USER_ACTION ------------------ 4923| | 4924| 801k|#line 987 "./scan.l" 4925| 801k|ACTION_ECHO; ------------------ | | 2430| 801k|#define ACTION_ECHO add_action( yytext ) ------------------ 4926| 801k| /*LINTED*/break; 4927| 2.20k| case 251: ------------------ | Branch (4927:2): [True: 2.20k, False: 11.9M] ------------------ 4928| 2.20k|YY_RULE_SETUP ------------------ | | 2732| 2.20k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 2.20k, False: 0] | | ------------------ | | 2733| 2.20k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 2.20k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 2.20k| } \ | | 2735| 2.20k| YY_USER_ACTION ------------------ 4929| | 4930| 2.20k|#line 988 "./scan.l" 4931| 2.20k|ACTION_ECHO; /* character constant */ ------------------ | | 2430| 2.20k|#define ACTION_ECHO add_action( yytext ) ------------------ 4932| 2.20k| /*LINTED*/break; 4933| 46.5k| case 252: ------------------ | Branch (4933:2): [True: 46.5k, False: 11.8M] ------------------ 4934| 46.5k|YY_RULE_SETUP ------------------ | | 2732| 46.5k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 46.5k, False: 0] | | ------------------ | | 2733| 46.5k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 46.5k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 46.5k| } \ | | 2735| 46.5k| YY_USER_ACTION ------------------ 4935| | 4936| 46.5k|#line 989 "./scan.l" 4937| 46.5k|ACTION_ECHO; BEGIN(CHARACTER_CONSTANT); ------------------ | | 2430| 46.5k|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; BEGIN(CHARACTER_CONSTANT); ------------------ | | 233| 46.5k|#define BEGIN (yy_start) = 1 + 2 * ------------------ ACTION_ECHO; BEGIN(CHARACTER_CONSTANT); ------------------ | | 2525| 46.5k|#define CHARACTER_CONSTANT 26 ------------------ 4938| 46.5k| /*LINTED*/break; 4939| 23.3k| case 253: ------------------ | Branch (4939:2): [True: 23.3k, False: 11.8M] ------------------ 4940| 23.3k|YY_RULE_SETUP ------------------ | | 2732| 23.3k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 23.3k, False: 0] | | ------------------ | | 2733| 23.3k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 23.3k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 23.3k| } \ | | 2735| 23.3k| YY_USER_ACTION ------------------ 4941| | 4942| 23.3k|#line 990 "./scan.l" 4943| 23.3k|ACTION_ECHO; BEGIN(ACTION_STRING); ------------------ | | 2430| 23.3k|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; BEGIN(ACTION_STRING); ------------------ | | 233| 23.3k|#define BEGIN (yy_start) = 1 + 2 * ------------------ ACTION_ECHO; BEGIN(ACTION_STRING); ------------------ | | 2514| 23.3k|#define ACTION_STRING 15 ------------------ 4944| 23.3k| /*LINTED*/break; 4945| 298k| case 254: ------------------ | Branch (4945:2): [True: 298k, False: 11.6M] ------------------ 4946| |/* rule 254 can match eol */ 4947| 298k|YY_RULE_SETUP ------------------ | | 2732| 298k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 298k, False: 0] | | ------------------ | | 2733| 298k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 298k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 298k| } \ | | 2735| 298k| YY_USER_ACTION ------------------ 4948| | 4949| 298k|#line 991 "./scan.l" 4950| 298k|{ 4951| 298k| ++linenum; 4952| 298k| ACTION_ECHO; ------------------ | | 2430| 298k|#define ACTION_ECHO add_action( yytext ) ------------------ 4953| 298k| if (bracelevel <= 0) { ------------------ | Branch (4953:21): [True: 341, False: 298k] ------------------ 4954| 341| if ( doing_rule_action ) ------------------ | Branch (4954:25): [True: 0, False: 341] ------------------ 4955| 0| add_action( "\t]""]M4_HOOK_STATE_CASE_BREAK\n" ); 4956| | 4957| 341| doing_rule_action = false; 4958| 341| BEGIN(SECT2); ------------------ | | 233| 341|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(SECT2); ------------------ | | 2500| 341|#define SECT2 1 ------------------ 4959| 341| } 4960| 298k| } 4961| 298k| /*LINTED*/break; 4962| 74.5k| case 255: ------------------ | Branch (4962:2): [True: 74.5k, False: 11.8M] ------------------ 4963| 74.5k|YY_RULE_SETUP ------------------ | | 2732| 74.5k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 74.5k, False: 0] | | ------------------ | | 2733| 74.5k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 74.5k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 74.5k| } \ | | 2735| 74.5k| YY_USER_ACTION ------------------ 4964| | 4965| 74.5k|#line 1002 "./scan.l" 4966| 74.5k|ACTION_ECHO; ------------------ | | 2430| 74.5k|#define ACTION_ECHO add_action( yytext ) ------------------ 4967| 74.5k| /*LINTED*/break; 4968| | 4969| | 4970| 46.6k| case 256: ------------------ | Branch (4970:2): [True: 46.6k, False: 11.8M] ------------------ 4971| 46.6k|YY_RULE_SETUP ------------------ | | 2732| 46.6k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 46.6k, False: 0] | | ------------------ | | 2733| 46.6k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 46.6k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 46.6k| } \ | | 2735| 46.6k| YY_USER_ACTION ------------------ 4972| | 4973| 46.6k|#line 1006 "./scan.l" 4974| 46.6k|ACTION_ECHO; ------------------ | | 2430| 46.6k|#define ACTION_ECHO add_action( yytext ) ------------------ 4975| 46.6k| /*LINTED*/break; 4976| 13.1k| case 257: ------------------ | Branch (4976:2): [True: 13.1k, False: 11.8M] ------------------ 4977| 13.1k|YY_RULE_SETUP ------------------ | | 2732| 13.1k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 13.1k, False: 0] | | ------------------ | | 2733| 13.1k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 13.1k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 13.1k| } \ | | 2735| 13.1k| YY_USER_ACTION ------------------ 4978| | 4979| 13.1k|#line 1007 "./scan.l" 4980| 13.1k|ACTION_ECHO; BEGIN(ACTION); ------------------ | | 2430| 13.1k|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; BEGIN(ACTION); ------------------ | | 233| 13.1k|#define BEGIN (yy_start) = 1 + 2 * ------------------ ACTION_ECHO; BEGIN(ACTION); ------------------ | | 2511| 13.1k|#define ACTION 12 ------------------ 4981| 13.1k| /*LINTED*/break; 4982| | 4983| | 4984| 66.9k| case 258: ------------------ | Branch (4984:2): [True: 66.9k, False: 11.8M] ------------------ 4985| 66.9k|YY_RULE_SETUP ------------------ | | 2732| 66.9k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 66.9k, False: 0] | | ------------------ | | 2733| 66.9k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 66.9k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 66.9k| } \ | | 2735| 66.9k| YY_USER_ACTION ------------------ 4986| | 4987| 66.9k|#line 1010 "./scan.l" 4988| 66.9k|ACTION_ECHO; ------------------ | | 2430| 66.9k|#define ACTION_ECHO add_action( yytext ) ------------------ 4989| 66.9k| /*LINTED*/break; 4990| 34.4k| case 259: ------------------ | Branch (4990:2): [True: 34.4k, False: 11.8M] ------------------ 4991| 34.4k|YY_RULE_SETUP ------------------ | | 2732| 34.4k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 34.4k, False: 0] | | ------------------ | | 2733| 34.4k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 34.4k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 34.4k| } \ | | 2735| 34.4k| YY_USER_ACTION ------------------ 4992| | 4993| 34.4k|#line 1011 "./scan.l" 4994| 34.4k|ACTION_ECHO; BEGIN(ACTION); ------------------ | | 2430| 34.4k|#define ACTION_ECHO add_action( yytext ) ------------------ ACTION_ECHO; BEGIN(ACTION); ------------------ | | 233| 34.4k|#define BEGIN (yy_start) = 1 + 2 * ------------------ ACTION_ECHO; BEGIN(ACTION); ------------------ | | 2511| 34.4k|#define ACTION 12 ------------------ 4995| 34.4k| /*LINTED*/break; 4996| | 4997| | 4998| 226| case 260: ------------------ | Branch (4998:2): [True: 226, False: 11.9M] ------------------ 4999| |/* rule 260 can match eol */ 5000| 226|YY_RULE_SETUP ------------------ | | 2732| 226| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 226, False: 0] | | ------------------ | | 2733| 226| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 226|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 226| } \ | | 2735| 226| YY_USER_ACTION ------------------ 5001| | 5002| 226|#line 1014 "./scan.l" 5003| 226|ACTION_ECHO; ------------------ | | 2430| 226|#define ACTION_ECHO add_action( yytext ) ------------------ 5004| 226| /*LINTED*/break; 5005| 16.3k| case 261: ------------------ | Branch (5005:2): [True: 16.3k, False: 11.8M] ------------------ 5006| |/* rule 261 can match eol */ 5007| 16.3k|YY_RULE_SETUP ------------------ | | 2732| 16.3k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 16.3k, False: 0] | | ------------------ | | 2733| 16.3k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 16.3k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 16.3k| } \ | | 2735| 16.3k| YY_USER_ACTION ------------------ 5008| | 5009| 16.3k|#line 1015 "./scan.l" 5010| 16.3k|ACTION_ECHO; ------------------ | | 2430| 16.3k|#define ACTION_ECHO add_action( yytext ) ------------------ 5011| 16.3k| /*LINTED*/break; 5012| 22.2k| case 262: ------------------ | Branch (5012:2): [True: 22.2k, False: 11.8M] ------------------ 5013| |/* rule 262 can match eol */ 5014| 22.2k|YY_RULE_SETUP ------------------ | | 2732| 22.2k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 22.2k, False: 0] | | ------------------ | | 2733| 22.2k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 22.2k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 22.2k| } \ | | 2735| 22.2k| YY_USER_ACTION ------------------ 5015| | 5016| 22.2k|#line 1016 "./scan.l" 5017| 22.2k|++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 2430| 22.2k|#define ACTION_ECHO add_action( yytext ) ------------------ ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 233| 21|#define BEGIN (yy_start) = 1 + 2 * ------------------ ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 2500| 21|#define SECT2 1 ------------------ ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 233| 22.2k|#define BEGIN (yy_start) = 1 + 2 * ------------------ ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); } ------------------ | | 2511| 22.2k|#define ACTION 12 ------------------ | Branch (5017:29): [True: 21, False: 22.2k] ------------------ 5018| 22.2k| /*LINTED*/break; 5019| 35.0k| case 263: ------------------ | Branch (5019:2): [True: 35.0k, False: 11.8M] ------------------ 5020| 35.0k|YY_RULE_SETUP ------------------ | | 2732| 35.0k| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 35.0k, False: 0] | | ------------------ | | 2733| 35.0k| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 35.0k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 35.0k| } \ | | 2735| 35.0k| YY_USER_ACTION ------------------ 5021| | 5022| 35.0k|#line 1017 "./scan.l" 5023| 35.0k|ACTION_ECHO; ------------------ | | 2430| 35.0k|#define ACTION_ECHO add_action( yytext ) ------------------ 5024| 35.0k| /*LINTED*/break; 5025| | 5026| 0|case YY_STATE_EOF(COMMENT): ------------------ | | 243| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5026:1): [True: 0, False: 11.9M] ------------------ 5027| 163|case YY_STATE_EOF(CODE_COMMENT): ------------------ | | 243| 163|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 163|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5027:1): [True: 163, False: 11.9M] ------------------ 5028| 163|case YY_STATE_EOF(COMMENT_DISCARD): ------------------ | | 243| 163|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 163|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5028:1): [True: 0, False: 11.9M] ------------------ 5029| 369|case YY_STATE_EOF(ACTION): ------------------ | | 243| 369|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 369|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5029:1): [True: 206, False: 11.9M] ------------------ 5030| 434|case YY_STATE_EOF(ACTION_STRING): ------------------ | | 243| 434|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 434|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5030:1): [True: 65, False: 11.9M] ------------------ 5031| 473|case YY_STATE_EOF(CHARACTER_CONSTANT): ------------------ | | 243| 473|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 473|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5031:1): [True: 39, False: 11.9M] ------------------ 5032| 473|#line 1020 "./scan.l" 5033| 473|{ 5034| 473| synerr( _( "EOF encountered inside an action" ) ); ------------------ | | 85| 473|#define _(String) gettext (String) ------------------ 5035| 473| yyterminate(); ------------------ | | 2704| 473|#define yyterminate() return YY_NULL | | ------------------ | | | | 187| 473|#define YY_NULL 0 | | ------------------ ------------------ 5036| 434| } 5037| 0| /*LINTED*/break; 5038| 0|case YY_STATE_EOF(EXTENDED_COMMENT): ------------------ | | 243| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5038:1): [True: 0, False: 11.9M] ------------------ 5039| 0|case YY_STATE_EOF(GROUP_WITH_PARAMS): ------------------ | | 243| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5039:1): [True: 0, False: 11.9M] ------------------ 5040| 0|case YY_STATE_EOF(GROUP_MINUS_PARAMS): ------------------ | | 243| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5040:1): [True: 0, False: 11.9M] ------------------ 5041| 0|#line 1025 "./scan.l" 5042| 0|{ 5043| 0| synerr( _( "EOF encountered inside pattern" ) ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 5044| 0| yyterminate(); ------------------ | | 2704| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 187| 0|#define YY_NULL 0 | | ------------------ ------------------ 5045| 0| } 5046| 0| /*LINTED*/break; 5047| 32| case 264: ------------------ | Branch (5047:2): [True: 32, False: 11.9M] ------------------ 5048| 32|YY_RULE_SETUP ------------------ | | 2732| 32| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 32, False: 0] | | ------------------ | | 2733| 32| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 32|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 32| } \ | | 2735| 32| YY_USER_ACTION ------------------ 5049| | 5050| 32|#line 1030 "./scan.l" 5051| 32|{ 5052| 32| yylval = myesc( (unsigned char *) yytext ); 5053| | 5054| 32| if ( YY_START == FIRSTCCL ) ------------------ | | 240| 32|#define YY_START (((yy_start) - 1) / 2) ------------------ if ( YY_START == FIRSTCCL ) ------------------ | | 2509| 32|#define FIRSTCCL 10 ------------------ | Branch (5054:9): [True: 5, False: 27] ------------------ 5055| 5| BEGIN(CCL); ------------------ | | 233| 5|#define BEGIN (yy_start) = 1 + 2 * ------------------ BEGIN(CCL); ------------------ | | 2510| 5|#define CCL 11 ------------------ 5056| | 5057| 32| return CHAR; ------------------ | | 109| 32|#define CHAR 258 ------------------ 5058| 0| } 5059| 0| /*LINTED*/break; 5060| | 5061| 0| case 265: ------------------ | Branch (5061:2): [True: 0, False: 11.9M] ------------------ 5062| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 5063| | 5064| 0|#line 1040 "./scan.l" 5065| 0|fputs(escaped_qstart, yyout); 5066| 0| /*LINTED*/break; 5067| 0| case 266: ------------------ | Branch (5067:2): [True: 0, False: 11.9M] ------------------ 5068| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 5069| | 5070| 0|#line 1041 "./scan.l" 5071| 0|fputs(escaped_qend, yyout); 5072| 0| /*LINTED*/break; 5073| 0| case 267: ------------------ | Branch (5073:2): [True: 0, False: 11.9M] ------------------ 5074| |/* rule 267 can match eol */ 5075| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 5076| | 5077| 0|#line 1042 "./scan.l" 5078| 0|ECHO; ------------------ | | 2639| 0|#define ECHO yyecho() | | ------------------ | | | | 2635| 0|#define yyecho() do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | | | ------------------ | | | | | Branch (2635:27): [True: 0, False: 0] | | | | | Branch (2635:84): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 5079| 0| /*LINTED*/break; 5080| 0| case 268: ------------------ | Branch (5080:2): [True: 0, False: 11.9M] ------------------ 5081| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 5082| | 5083| 0|#line 1043 "./scan.l" 5084| 0|ECHO; ------------------ | | 2639| 0|#define ECHO yyecho() | | ------------------ | | | | 2635| 0|#define yyecho() do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | | | ------------------ | | | | | Branch (2635:27): [True: 0, False: 0] | | | | | Branch (2635:84): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 5085| 0| /*LINTED*/break; 5086| 0|case YY_STATE_EOF(SECT3): ------------------ | | 243| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5086:1): [True: 0, False: 11.9M] ------------------ 5087| 0|#line 1044 "./scan.l" 5088| 0|{ 5089| 0| sectnum = 0; 5090| 0| yyterminate(); ------------------ | | 2704| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 187| 0|#define YY_NULL 0 | | ------------------ ------------------ 5091| 0| } 5092| 0| /*LINTED*/break; 5093| | 5094| | 5095| 0| case 269: ------------------ | Branch (5095:2): [True: 0, False: 11.9M] ------------------ 5096| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 5097| | 5098| 0|#line 1050 "./scan.l" 5099| 0|fprintf(yyout, "[""[%s]""]", escaped_qstart); 5100| 0| /*LINTED*/break; 5101| 0| case 270: ------------------ | Branch (5101:2): [True: 0, False: 11.9M] ------------------ 5102| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 5103| | 5104| 0|#line 1051 "./scan.l" 5105| 0|fprintf(yyout, "[""[%s]""]", escaped_qend); 5106| 0| /*LINTED*/break; 5107| 0| case 271: ------------------ | Branch (5107:2): [True: 0, False: 11.9M] ------------------ 5108| |/* rule 271 can match eol */ 5109| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 5110| | 5111| 0|#line 1052 "./scan.l" 5112| 0|ECHO; ------------------ | | 2639| 0|#define ECHO yyecho() | | ------------------ | | | | 2635| 0|#define yyecho() do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | | | ------------------ | | | | | Branch (2635:27): [True: 0, False: 0] | | | | | Branch (2635:84): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 5113| 0| /*LINTED*/break; 5114| 0| case 272: ------------------ | Branch (5114:2): [True: 0, False: 11.9M] ------------------ 5115| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 5116| | 5117| 0|#line 1053 "./scan.l" 5118| 0|ECHO; ------------------ | | 2639| 0|#define ECHO yyecho() | | ------------------ | | | | 2635| 0|#define yyecho() do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | | | ------------------ | | | | | Branch (2635:27): [True: 0, False: 0] | | | | | Branch (2635:84): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 5119| 0| /*LINTED*/break; 5120| 0|case YY_STATE_EOF(SECT3_NOESCAPE): ------------------ | | 243| 0|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 0|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5120:1): [True: 0, False: 11.9M] ------------------ 5121| 0|#line 1054 "./scan.l" 5122| 0|{ 5123| 0| sectnum = 0; 5124| 0| yyterminate(); ------------------ | | 2704| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 187| 0|#define YY_NULL 0 | | ------------------ ------------------ 5125| 0| } 5126| 0| /*LINTED*/break; 5127| | 5128| 11| case 273: ------------------ | Branch (5128:2): [True: 11, False: 11.9M] ------------------ 5129| |/* rule 273 can match eol */ 5130| 11|YY_RULE_SETUP ------------------ | | 2732| 11| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 11, False: 0] | | ------------------ | | 2733| 11| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 11|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 11| } \ | | 2735| 11| YY_USER_ACTION ------------------ 5131| | 5132| 11|#line 1059 "./scan.l" 5133| 11|format_synerr( _( "bad character: %s" ), yytext ); ------------------ | | 85| 11|#define _(String) gettext (String) ------------------ 5134| 11| /*LINTED*/break; 5135| 0| case 274: ------------------ | Branch (5135:2): [True: 0, False: 11.9M] ------------------ 5136| 0|YY_RULE_SETUP ------------------ | | 2732| 0| if ( yyleng > 0 ) { \ | | ------------------ | | | Branch (2732:8): [True: 0, False: 0] | | ------------------ | | 2733| 0| YY_CURRENT_BUFFER_LVALUE->yyatbol = (yytext[yyleng - 1] == '\n'); \ | | ------------------ | | | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ | | 2734| 0| } \ | | 2735| 0| YY_USER_ACTION ------------------ 5137| | 5138| 0|#line 1061 "./scan.l" 5139| 0|yypanic("flex scanner jammed" ); 5140| 0| /*LINTED*/break; 5141| 0|#line 5142 "stage1scan.c" 5142| 0|#line 5143 "stage1scan.c" 5143| 12| case YY_STATE_EOF(INITIAL): ------------------ | | 243| 12|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 12|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5143:2): [True: 12, False: 11.9M] ------------------ 5144| | /* FALLTHROUGH */ 5145| 21| case YY_STATE_EOF(SECT2): ------------------ | | 243| 21|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 21|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5145:2): [True: 9, False: 11.9M] ------------------ 5146| | /* FALLTHROUGH */ 5147| 26| case YY_STATE_EOF(CODEBLOCK): ------------------ | | 243| 26|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 26|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5147:2): [True: 5, False: 11.9M] ------------------ 5148| | /* FALLTHROUGH */ 5149| 52| case YY_STATE_EOF(PICKUPDEF): ------------------ | | 243| 52|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 52|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5149:2): [True: 26, False: 11.9M] ------------------ 5150| | /* FALLTHROUGH */ 5151| 126| case YY_STATE_EOF(SC): ------------------ | | 243| 126|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 126|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5151:2): [True: 74, False: 11.9M] ------------------ 5152| | /* FALLTHROUGH */ 5153| 126| case YY_STATE_EOF(CARETISBOL): ------------------ | | 243| 126|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 126|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5153:2): [True: 0, False: 11.9M] ------------------ 5154| | /* FALLTHROUGH */ 5155| 126| case YY_STATE_EOF(NUM): ------------------ | | 243| 126|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 126|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5155:2): [True: 0, False: 11.9M] ------------------ 5156| | /* FALLTHROUGH */ 5157| 128| case YY_STATE_EOF(QUOTE): ------------------ | | 243| 128|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 128|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5157:2): [True: 2, False: 11.9M] ------------------ 5158| | /* FALLTHROUGH */ 5159| 128| case YY_STATE_EOF(FIRSTCCL): ------------------ | | 243| 128|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 128|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5159:2): [True: 0, False: 11.9M] ------------------ 5160| | /* FALLTHROUGH */ 5161| 138| case YY_STATE_EOF(CCL): ------------------ | | 243| 138|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 138|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5161:2): [True: 10, False: 11.9M] ------------------ 5162| | /* FALLTHROUGH */ 5163| 138| case YY_STATE_EOF(RECOVER): ------------------ | | 243| 138|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 138|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5163:2): [True: 0, False: 11.9M] ------------------ 5164| | /* FALLTHROUGH */ 5165| 158| case YY_STATE_EOF(PERCENT_BRACE_ACTION): ------------------ | | 243| 158|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 158|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5165:2): [True: 20, False: 11.9M] ------------------ 5166| | /* FALLTHROUGH */ 5167| 158| case YY_STATE_EOF(OPTION): ------------------ | | 243| 158|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 158|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5167:2): [True: 0, False: 11.9M] ------------------ 5168| | /* FALLTHROUGH */ 5169| 158| case YY_STATE_EOF(LINEDIR): ------------------ | | 243| 158|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 158|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ | Branch (5169:2): [True: 0, False: 11.9M] ------------------ 5170| | /* FALLTHROUGH */ 5171| 158| yyterminate(); ------------------ | | 2704| 158|#define yyterminate() return YY_NULL | | ------------------ | | | | 187| 158|#define YY_NULL 0 | | ------------------ ------------------ 5172| | 5173| 8.84M| case YY_END_OF_BUFFER: ------------------ | | 543| 8.84M|#define YY_END_OF_BUFFER 275 ------------------ | Branch (5173:4): [True: 8.84M, False: 3.05M] ------------------ 5174| 8.84M| { 5175| | /* Amount of text matched not including the EOB char. */ 5176| 8.84M| int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; ------------------ | | 528| 8.84M|#define yytext_ptr yytext ------------------ 5177| | 5178| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 5179| 8.84M| *yy_cp = (yy_hold_char); 5180| 8.84M| YY_RESTORE_YY_MORE_OFFSET 5181| | 5182| 8.84M| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { ------------------ | | 399| 8.84M|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { ------------------ | | 356| 8.84M|#define YY_BUFFER_NEW 0 ------------------ | Branch (5182:10): [True: 632, False: 8.84M] ------------------ 5183| | /* We're scanning a new file or input source. It's 5184| | * possible that this happened because the user 5185| | * just pointed yyin at a new source and called 5186| | * yylex(). If so, then we have to assure 5187| | * consistency between yy_current_buffer() and our 5188| | * globals. Here is the right place to do so, because 5189| | * this is the first action (other than possibly a 5190| | * back-up) that will match for the new input source. 5191| | */ 5192| 632| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 399| 632|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5193| | 5194| 632| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 399| 632|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5195| | 5196| 632| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 399| 632|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 357| 632|#define YY_BUFFER_NORMAL 1 ------------------ 5197| 632| } 5198| | 5199| | /* Note that here we test for yy_c_buf_p "<=" to the position 5200| | * of the first EOB in the buffer, since yy_c_buf_p will 5201| | * already have been incremented past the NUL character 5202| | * (since all states make transitions on EOB to the 5203| | * end-of-buffer state). Contrast this with the test 5204| | * in input(). 5205| | */ 5206| 8.84M| if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) { /* This was really a NUL. */ ------------------ | | 399| 8.84M|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (5206:10): [True: 8.83M, False: 6.20k] ------------------ 5207| 8.83M| yy_state_type yy_next_state; 5208| | 5209| 8.83M| (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; ------------------ | | 528| 8.83M|#define yytext_ptr yytext ------------------ 5210| | 5211| 8.83M| yy_current_state = yy_get_previous_state( ); 5212| | 5213| | /* Okay, we're now positioned to make the NUL 5214| | * transition. We couldn't have 5215| | * yy_get_previous_state() go ahead and do it 5216| | * for us because it doesn't know how to deal 5217| | * with the possibility of jamming (and we don't 5218| | * want to build jamming into it because then it 5219| | * will run more slowly). 5220| | */ 5221| | 5222| 8.83M| yy_next_state = yy_try_NUL_trans( yy_current_state ); 5223| | 5224| 8.83M| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 528| 8.83M|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 2370| 8.83M|#define YY_MORE_ADJ 0 ------------------ 5225| | 5226| 8.83M| if ( yy_next_state ) { ------------------ | Branch (5226:11): [True: 8.78M, False: 48.8k] ------------------ 5227| | /* Consume the NUL. */ 5228| 8.78M| yy_cp = ++(yy_c_buf_p); 5229| 8.78M| yy_current_state = yy_next_state; 5230| 8.78M| goto yy_match; 5231| 8.78M| } else { 5232| | 5233| | /* Still need to initialize yy_cp, though 5234| | * yy_current_state was set up by 5235| | * yy_get_previous_state(). 5236| | */ 5237| 48.8k| yy_cp = (yy_c_buf_p); 5238| | 5239| 48.8k| goto yy_find_action; 5240| 48.8k| } 5241| 8.83M| } else { /* not a NUL */ 5242| 6.20k| switch ( yy_get_next_buffer( ) ) { ------------------ | Branch (5242:15): [True: 0, False: 6.20k] ------------------ 5243| 632| case EOB_ACT_END_OF_FILE: ------------------ | | 282| 632|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (5243:6): [True: 632, False: 5.56k] ------------------ 5244| 632| (yy_did_buffer_switch_on_eof) = 0; 5245| | 5246| 632| if ( yywrap( ) ) { ------------------ | Branch (5246:12): [True: 632, False: 0] ------------------ 5247| | /* Note: because we've taken care in 5248| | * yy_get_next_buffer() to have set up 5249| | * yytext, we can now set up 5250| | * yy_c_buf_p so that if some total 5251| | * hoser (like flex itself) wants to 5252| | * call the scanner after we return the 5253| | * YY_NULL, it'll still work - another 5254| | * YY_NULL will get returned. 5255| | */ 5256| 632| (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 528| 632|#define yytext_ptr yytext ------------------ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 2370| 632|#define YY_MORE_ADJ 0 ------------------ 5257| | 5258| 632| yy_act = YY_STATE_EOF(yystart()); ------------------ | | 243| 632|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 543| 632|#define YY_END_OF_BUFFER 275 | | ------------------ ------------------ 5259| 632| goto do_action; 5260| 632| } else { 5261| 0| if ( ! (yy_did_buffer_switch_on_eof) ) { ------------------ | Branch (5261:13): [True: 0, False: 0] ------------------ 5262| 0| YY_NEW_FILE; ------------------ | | 245| 0|#define YY_NEW_FILE yyrestart( yyin ) ------------------ 5263| 0| } 5264| 0| } 5265| 0| break; 5266| 4.73k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 281| 4.73k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (5266:6): [True: 4.73k, False: 1.46k] ------------------ 5267| 4.73k| (yy_c_buf_p) = 5268| 4.73k| (yytext_ptr) + yy_amount_of_matched_text; ------------------ | | 528| 4.73k|#define yytext_ptr yytext ------------------ 5269| | 5270| 4.73k| yy_current_state = yy_get_previous_state( ); 5271| | 5272| 4.73k| yy_cp = (yy_c_buf_p); 5273| 4.73k| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 528| 4.73k|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 2370| 4.73k|#define YY_MORE_ADJ 0 ------------------ 5274| 4.73k| goto yy_match; 5275| | 5276| 835| case EOB_ACT_LAST_MATCH: ------------------ | | 283| 835|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (5276:6): [True: 835, False: 5.36k] ------------------ 5277| 835| (yy_c_buf_p) = 5278| 835| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; ------------------ | | 399| 835|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5279| | 5280| 835| yy_current_state = yy_get_previous_state( ); 5281| | 5282| 835| yy_cp = (yy_c_buf_p); 5283| 835| yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 528| 835|#define yytext_ptr yytext ------------------ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ------------------ | | 2370| 835|#define YY_MORE_ADJ 0 ------------------ 5284| 835| goto yy_find_action; 5285| 6.20k| } /* end EOB inner switch */ 5286| 6.20k| } /* end if */ 5287| 0| break; 5288| 8.84M| } /* case YY_END_OF_BUFFER */ 5289| 0| default: ------------------ | Branch (5289:4): [True: 0, False: 11.9M] ------------------ 5290| 0| YY_FATAL_ERROR("fatal flex scanner internal error--no action found" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 5291| 11.9M| } /* end of action switch */ 5292| 11.9M| } /* end of scanning one token */ 5293| 10.0k| } /* end of user's declarations */ 5294| 10.0k|} /* end of yylex */ yyrestart: 5650| 632|{ 5651| 632| size_t new_size = 0; 5652| 632| yy_state_type *new_state_buf = 0; 5653| | 5654| 632| if ( yy_current_buffer() == NULL ) { ------------------ | | 391| 632|#define yy_current_buffer() ( (yy_buffer_stack) \ | | ------------------ | | | Branch (391:31): [True: 632, False: 0] | | ------------------ | | 392| 632| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 393| 632| : NULL) ------------------ | Branch (5654:7): [True: 0, False: 632] ------------------ 5655| 0| yyensure_buffer_stack (); 5656| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5657| 0| yy_create_buffer( yyin, YY_BUF_SIZE ); ------------------ | | 2626| 0|#define YY_BUF_SIZE (2 * YY_READ_BUF_SIZE) | | ------------------ | | | | 2619| 0|#define YY_READ_BUF_SIZE BUFSIZ | | ------------------ ------------------ 5658| 0| } 5659| | 5660| 632| yy_init_buffer( YY_CURRENT_BUFFER_LVALUE, input_file ); ------------------ | | 399| 632|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5661| 632| yy_load_buffer_state( ); 5662| | 5663| | /* We don't actually know whether we did this switch during 5664| | * EOF (yywrap()) processing, but the only time this flag 5665| | * is looked at is after yywrap() is called, so it's safe 5666| | * to go ahead and always set it. 5667| | */ 5668| 632| (yy_did_buffer_switch_on_eof) = 1; 5669| 632|} yy_create_buffer: 5729| 1|{ 5730| 1| yybuffer b; 5731| | 5732| 1| b = (yybuffer) yyalloc( sizeof( struct yy_buffer_state ) ); 5733| 1| if ( b == NULL ) { ------------------ | Branch (5733:8): [True: 0, False: 1] ------------------ 5734| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 5735| 0| } 5736| 1| b->yy_buf_size = size; 5737| | 5738| | /* yy_ch_buf has to be 2 characters longer than the size given because 5739| | * we need to put in 2 end-of-buffer characters. 5740| | */ 5741| 1| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); 5742| 1| if ( b->yy_ch_buf == NULL ) { ------------------ | Branch (5742:7): [True: 0, False: 1] ------------------ 5743| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 5744| 0| } 5745| 1| b->yy_is_our_buffer = 1; 5746| | 5747| 1| yy_init_buffer( b, file ); 5748| | 5749| 1| return b; 5750| 1|} yy_flush_buffer: 5817| 633|{ 5818| 633| if ( b == NULL ) { ------------------ | Branch (5818:8): [True: 0, False: 633] ------------------ 5819| 0| return; 5820| 0| } 5821| 633| b->yy_n_chars = 0; 5822| | 5823| | /* We always need two end-of-buffer characters. The first causes 5824| | * a transition to the end-of-buffer state. The second causes 5825| | * a jam in that state. 5826| | */ 5827| 633| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 246| 633|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 5828| 633| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 246| 633|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 5829| | 5830| 633| b->yy_buf_pos = &b->yy_ch_buf[0]; 5831| | 5832| 633| b->yyatbol = 1; 5833| 633| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 356| 633|#define YY_BUFFER_NEW 0 ------------------ 5834| | 5835| 633| if ( b == yy_current_buffer() ) { ------------------ | | 391| 633|#define yy_current_buffer() ( (yy_buffer_stack) \ | | ------------------ | | | Branch (391:31): [True: 633, False: 0] | | ------------------ | | 392| 633| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 393| 633| : NULL) ------------------ | Branch (5835:7): [True: 632, False: 1] ------------------ 5836| 632| yy_load_buffer_state( ); 5837| 632| } 5838| 633|} yyalloc: 6228| 4|void *yyalloc (yy_size_t size ) { 6229| 4| return malloc(size); 6230| 4|} yyrealloc: 6232| 6|void *yyrealloc (void * ptr, yy_size_t size ) { 6233| | 6234| | /* The cast to (char *) in the following accommodates both 6235| | * implementations that use char* generic pointers, and those 6236| | * that use void* generic pointers. It works with the latter 6237| | * because both ANSI C and C++ allow castless assignment from 6238| | * any pointer type to void*, and deal with argument conversions 6239| | * as though doing an assignment. 6240| | */ 6241| 6| return realloc(ptr, size); 6242| 6|} yywrap: 6253| 632| { 6254| 632| if ( --num_input_files > 0 ) ------------------ | Branch (6254:7): [True: 0, False: 632] ------------------ 6255| 0| { 6256| 0| set_input_file( *++input_files ); 6257| 0| return 0; 6258| 0| } 6259| | 6260| 632| else 6261| 632| return 1; 6262| 632| } set_input_file: 6268| 632| { 6269| 632| if ( file && strcmp( file, "-" ) ) ------------------ | Branch (6269:7): [True: 632, False: 0] | Branch (6269:15): [True: 632, False: 0] ------------------ 6270| 632| { 6271| 632| infilename = xstrdup(file); 6272| 632| yyin = fopen( infilename, "r" ); 6273| | 6274| 632| if ( yyin == NULL ) ------------------ | Branch (6274:8): [True: 0, False: 632] ------------------ 6275| 0| lerr( _( "can't open %s" ), file ); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 6276| 632| } 6277| | 6278| 0| else 6279| 0| { 6280| 0| yyin = stdin; 6281| 0| infilename = xstrdup(""); 6282| 0| } 6283| | 6284| 632| linenum = 1; 6285| 632| } stage1scan.c:yy_get_next_buffer: 5306| 6.20k|{ 5307| 6.20k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 399| 6.20k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5308| 6.20k| char *source = (yytext_ptr); ------------------ | | 528| 6.20k|#define yytext_ptr yytext ------------------ 5309| 6.20k| int number_to_move, i; 5310| 6.20k| int ret_val; 5311| | 5312| 6.20k| if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) { ------------------ | | 399| 6.20k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (5312:7): [True: 0, False: 6.20k] ------------------ 5313| 0| YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 5314| 0| } 5315| 6.20k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) { ------------------ | | 399| 6.20k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (5315:7): [True: 0, False: 6.20k] ------------------ 5316| | /* Don't try to fill the buffer, so this is an EOF. */ 5317| 0| if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) { ------------------ | | 528| 0|#define yytext_ptr yytext ------------------ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) { ------------------ | | 2370| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (5317:8): [True: 0, False: 0] ------------------ 5318| | /* We matched a single character, the EOB, so 5319| | * treat this as a final EOF. 5320| | */ 5321| 0| return EOB_ACT_END_OF_FILE; ------------------ | | 282| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 5322| 0| } else { 5323| | /* We matched some text prior to the EOB, first 5324| | * process it. 5325| | */ 5326| 0| return EOB_ACT_LAST_MATCH; ------------------ | | 283| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 5327| 0| } 5328| 0| } 5329| | 5330| | /* Try to read more data. */ 5331| | 5332| | /* First move last chars to start of buffer. */ 5333| 6.20k| number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); ------------------ | | 528| 6.20k|#define yytext_ptr yytext ------------------ 5334| | 5335| 87.5M| for ( i = 0; i < number_to_move; ++i ) { ------------------ | Branch (5335:15): [True: 87.5M, False: 6.20k] ------------------ 5336| 87.5M| *(dest++) = *(source++); 5337| 87.5M| } 5338| 6.20k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) { ------------------ | | 399| 6.20k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) { ------------------ | | 368| 6.20k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (5338:7): [True: 835, False: 5.36k] ------------------ 5339| | /* don't do the read, it's not guaranteed to return an EOF, 5340| | * just force an EOF 5341| | */ 5342| 835| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; ------------------ | | 399| 835|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5343| 5.36k| } else { 5344| 5.36k| int num_to_read = 5345| 5.36k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 399| 5.36k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5346| | 5347| 5.37k| while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ ------------------ | Branch (5347:11): [True: 6, False: 5.36k] ------------------ 5348| | 5349| | /* just a shorter name for the current buffer */ 5350| 6| yybuffer b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 399| 6|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5351| | 5352| 6| int yy_c_buf_p_offset = 5353| 6| (int) ((yy_c_buf_p) - b->yy_ch_buf); 5354| | 5355| 6| if ( b->yy_is_our_buffer ) { ------------------ | Branch (5355:9): [True: 6, False: 0] ------------------ 5356| 6| int new_size = b->yy_buf_size * 2; 5357| | 5358| 6| if ( new_size <= 0 ) { ------------------ | Branch (5358:10): [True: 0, False: 6] ------------------ 5359| 0| b->yy_buf_size += b->yy_buf_size / 8; 5360| 6| } else { 5361| 6| b->yy_buf_size *= 2; 5362| 6| } 5363| 6| b->yy_ch_buf = (char *) 5364| | /* Include room in for 2 EOB chars. */ 5365| 6| yyrealloc( (void *) b->yy_ch_buf, 5366| 6| (yy_size_t) (b->yy_buf_size + 2) ); 5367| 6| } else { 5368| | /* Can't grow it, we don't own it. */ 5369| 0| b->yy_ch_buf = NULL; 5370| 0| } 5371| 6| if ( ! b->yy_ch_buf ) { ------------------ | Branch (5371:9): [True: 0, False: 6] ------------------ 5372| 0| YY_FATAL_ERROR( ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 5373| 0| "fatal error - scanner input buffer overflow" ); 5374| 0| } 5375| 6| (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 5376| | 5377| 6| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 399| 6|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5378| 6| number_to_move - 1; 5379| | 5380| 6| } 5381| | 5382| 5.36k| if ( num_to_read > YY_READ_BUF_SIZE ) { ------------------ | | 2619| 5.36k|#define YY_READ_BUF_SIZE BUFSIZ ------------------ | Branch (5382:8): [True: 5.35k, False: 13] ------------------ 5383| 5.35k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 2619| 5.35k|#define YY_READ_BUF_SIZE BUFSIZ ------------------ 5384| 5.35k| } 5385| | /* Read in more data. */ 5386| 5.36k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 2659| 5.36k|#define YY_INPUT(buf,result,max_size) do {result = yyread(buf, max_size );} while (0) | | ------------------ | | | Branch (2659:84): [Folded - Ignored] | | ------------------ ------------------ 5387| 5.36k| (yy_n_chars), num_to_read ); 5388| | 5389| 5.36k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ------------------ | | 399| 5.36k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5390| 5.36k| } 5391| | 5392| 6.20k| if ( (yy_n_chars) == 0 ) { ------------------ | Branch (5392:7): [True: 1.46k, False: 4.73k] ------------------ 5393| 1.46k| if ( number_to_move == YY_MORE_ADJ ) { ------------------ | | 2370| 1.46k|#define YY_MORE_ADJ 0 ------------------ | Branch (5393:8): [True: 632, False: 835] ------------------ 5394| 632| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 282| 632|#define EOB_ACT_END_OF_FILE 1 ------------------ 5395| 632| yyrestart( yyin ); 5396| 835| } else { 5397| 835| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 283| 835|#define EOB_ACT_LAST_MATCH 2 ------------------ 5398| 835| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 399| 835|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5399| 835| YY_BUFFER_EOF_PENDING; ------------------ | | 368| 835|#define YY_BUFFER_EOF_PENDING 2 ------------------ 5400| 835| } 5401| 4.73k| } else { 5402| 4.73k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 281| 4.73k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 5403| 4.73k| } 5404| 6.20k| if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 399| 6.20k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (5404:6): [True: 0, False: 6.20k] ------------------ 5405| | /* Extend the array by 50%, plus the number we really need. */ 5406| 0| int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 5407| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5408| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5409| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) { ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (5409:8): [True: 0, False: 0] ------------------ 5410| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 5411| 0| } 5412| | /* "- 2" to take care of EOB's */ 5413| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5414| 0| } 5415| | 5416| 6.20k| (yy_n_chars) += number_to_move; 5417| 6.20k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ------------------ | | 399| 6.20k|#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; ------------------ | | 246| 6.20k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 5418| 6.20k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 399| 6.20k|#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; ------------------ | | 246| 6.20k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 5419| | 5420| 6.20k| (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 528| 6.20k|#define yytext_ptr yytext ------------------ (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 399| 6.20k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5421| | 5422| 6.20k| return ret_val; 5423| 6.20k|} stage1scan.c:yyread: 2665| 5.36k|static int yyread(char *buf, size_t max_size ) { 2666| | 2667| 5.36k| int result; 2668| | 2669| 5.36k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) { ------------------ | | 399| 5.36k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (2669:7): [True: 0, False: 5.36k] ------------------ 2670| 0| int c = '*'; 2671| 0| int n; 2672| 0| for ( n = 0; n < max_size && ------------------ | Branch (2672:16): [True: 0, False: 0] ------------------ 2673| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) { ------------------ | Branch (2673:10): [True: 0, False: 0] | Branch (2673:39): [True: 0, False: 0] ------------------ 2674| 0| buf[n] = (char) c; 2675| 0| } 2676| 0| if ( c == '\n' ) { ------------------ | Branch (2676:8): [True: 0, False: 0] ------------------ 2677| 0| buf[n++] = (char) c; 2678| 0| } 2679| 0| if ( c == EOF && ferror( yyin ) ) { ------------------ | Branch (2679:8): [True: 0, False: 0] | Branch (2679:20): [True: 0, False: 0] ------------------ 2680| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 2681| 0| } 2682| 0| result = n; 2683| 5.36k| } else { 2684| 5.36k| errno=0; 2685| 5.36k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) { ------------------ | Branch (2685:11): [True: 632, False: 4.73k] | Branch (2685:78): [True: 0, False: 632] ------------------ 2686| 0| if( errno != EINTR) { ------------------ | Branch (2686:8): [True: 0, False: 0] ------------------ 2687| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 2688| 0| break; 2689| 0| } 2690| 0| errno=0; 2691| 0| clearerr(yyin); 2692| 0| } 2693| 5.36k| } 2694| | 2695| 5.36k| return result; 2696| 5.36k|} stage1scan.c:yy_get_previous_state: 5429| 8.84M|{ 5430| 8.84M| yy_state_type yy_current_state; 5431| 8.84M| char *yy_cp; 5432| | 5433| | /* Generate the code to find the start state. */ 5434| | 5435| 8.84M| yy_current_state = (yy_start); 5436| 8.84M|yy_current_state += yyatbol(); ------------------ | | 467| 8.84M|#define yyatbol() (YY_CURRENT_BUFFER_LVALUE->yyatbol) | | ------------------ | | | | 399| 8.84M|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] | | ------------------ ------------------ 5437| | /* Set up for storing up states. */ 5438| | 5439| 38.6G| for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { ------------------ | | 528| 8.84M|#define yytext_ptr yytext ------------------ for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { ------------------ | | 2370| 8.84M|#define YY_MORE_ADJ 0 ------------------ | Branch (5439:44): [True: 38.6G, False: 8.84M] ------------------ 5440| | /* Generate the code to find the next state. */ 5441| | 5442| 38.6G| int yy_c = (*yy_cp ? *(yy_ec+YY_SC_TO_UI(*yy_cp)) : YY_NUL_EC); ------------------ | | 193| 753M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ int yy_c = (*yy_cp ? *(yy_ec+YY_SC_TO_UI(*yy_cp)) : YY_NUL_EC); ------------------ | | 546| 37.8G|#define YY_NUL_EC 1 ------------------ | Branch (5442:14): [True: 753M, False: 37.8G] ------------------ 5443| | /* Save the backing-up info \before/ computing the next state 5444| | * because we always compute one more state than needed - we 5445| | * always proceed until we reach a jam state 5446| | */ 5447| | 5448| | /* Generate code to keep backing-up information. */ 5449| | 5450| 38.6G| if ( yy_accept[yy_current_state] ) { ------------------ | Branch (5450:8): [True: 38.6G, False: 4.41M] ------------------ 5451| | 5452| 38.6G| (yy_last_accepting_state) = yy_current_state; 5453| 38.6G| (yy_last_accepting_cpos) = yy_cp; 5454| 38.6G| } 5455| | 5456| 77.2G| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { ------------------ | Branch (5456:10): [True: 38.6G, False: 38.6G] ------------------ 5457| 38.6G| yy_current_state = (int) yy_def[yy_current_state]; 5458| | 5459| | /* We've arranged it so that templates are never chained 5460| | * to one another. This means we can afford to make a 5461| | * very simple test to see if we need to convert to 5462| | * yy_c's meta-equivalence class without worrying 5463| | * about erroneously looking up the meta-equivalence 5464| | * class twice 5465| | */ 5466| | 5467| | /* lastdfa + 2 == YY_JAMSTATE + 1 is the beginning of the templates */ 5468| 38.6G| if (yy_current_state >= YY_JAMSTATE + 1) { ------------------ | | 545| 38.6G|#define YY_JAMSTATE 1327 ------------------ | Branch (5468:7): [True: 38.6G, False: 912k] ------------------ 5469| 38.6G| yy_c = yy_meta[yy_c]; 5470| 38.6G| } 5471| | 5472| 38.6G| } 5473| 38.6G| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 5474| | 5475| 38.6G| } 5476| | 5477| 8.84M| return yy_current_state; 5478| 8.84M|} stage1scan.c:yy_try_NUL_trans: 5488| 8.83M|{ 5489| 8.83M| int yy_is_jam; 5490| | /* Generate code for handling NUL's, if needed. */ 5491| | 5492| | /* First, deal with backing up and setting up yy_cp if the scanner 5493| | * finds that it should JAM on the NUL. 5494| | * 5495| | * Only generate a definition for "yy_cp" if we'll generate code 5496| | * that uses it. Otherwise lint and the like complain. 5497| | */ 5498| 8.83M| char *yy_cp = (yy_c_buf_p); 5499| | 5500| 8.83M| int yy_c = YY_NUL_EC; ------------------ | | 546| 8.83M|#define YY_NUL_EC 1 ------------------ 5501| | /* Save the backing-up info \before/ computing the next state 5502| | * because we always compute one more state than needed - we 5503| | * always proceed until we reach a jam state 5504| | */ 5505| | 5506| | /* Generate code to keep backing-up information. */ 5507| | 5508| 8.83M| if ( yy_accept[yy_current_state] ) { ------------------ | Branch (5508:8): [True: 8.78M, False: 51.9k] ------------------ 5509| | 5510| 8.78M| (yy_last_accepting_state) = yy_current_state; 5511| 8.78M| (yy_last_accepting_cpos) = yy_cp; 5512| 8.78M| } 5513| | 5514| 17.6M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { ------------------ | Branch (5514:10): [True: 8.82M, False: 8.83M] ------------------ 5515| 8.82M| yy_current_state = (int) yy_def[yy_current_state]; 5516| | 5517| | /* We've arranged it so that templates are never chained 5518| | * to one another. This means we can afford to make a 5519| | * very simple test to see if we need to convert to 5520| | * yy_c's meta-equivalence class without worrying 5521| | * about erroneously looking up the meta-equivalence 5522| | * class twice 5523| | */ 5524| | 5525| | /* lastdfa + 2 == YY_JAMSTATE + 1 is the beginning of the templates */ 5526| 8.82M| if (yy_current_state >= YY_JAMSTATE + 1) { ------------------ | | 545| 8.82M|#define YY_JAMSTATE 1327 ------------------ | Branch (5526:7): [True: 8.77M, False: 54.7k] ------------------ 5527| 8.77M| yy_c = yy_meta[yy_c]; 5528| 8.77M| } 5529| | 5530| 8.82M| } 5531| 8.83M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 5532| | 5533| 8.83M|yy_is_jam = (yy_current_state == YY_JAMSTATE); ------------------ | | 545| 8.83M|#define YY_JAMSTATE 1327 ------------------ 5534| | 5535| 8.83M| return yy_is_jam ? 0 : yy_current_state; ------------------ | Branch (5535:10): [True: 48.8k, False: 8.78M] ------------------ 5536| 8.83M|} stage1scan.c:yyunput_r: 5540| 286|{ 5541| 286| char *yy_cp; 5542| | 5543| 286| yy_cp = (yy_c_buf_p); 5544| | 5545| | /* undo effects of setting up yytext */ 5546| 286| *yy_cp = (yy_hold_char); 5547| | 5548| 286| if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { ------------------ | | 399| 286|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (5548:7): [True: 0, False: 286] ------------------ 5549| | /* need to shift things up to make room */ 5550| | /* +2 for EOB chars. */ 5551| 0| int number_to_move = (yy_n_chars) + 2; 5552| 0| char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5553| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5554| 0| char *source = 5555| 0| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5556| | 5557| 0| while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) { ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (5557:11): [True: 0, False: 0] ------------------ 5558| 0| *--dest = *--source; 5559| 0| } 5560| 0| yy_cp += (int) (dest - source); 5561| 0| yy_bp += (int) (dest - source); 5562| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5563| 0| (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5564| | 5565| 0| if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { ------------------ | | 399| 0|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ | Branch (5565:8): [True: 0, False: 0] ------------------ 5566| 0| YY_FATAL_ERROR( "flex scanner push-back overflow" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 5567| 0| } 5568| 0| } 5569| | 5570| 286| *--yy_cp = (char) c; 5571| | 5572| 286| (yytext_ptr) = yy_bp; ------------------ | | 528| 286|#define yytext_ptr yytext ------------------ 5573| 286| (yy_hold_char) = *yy_cp; 5574| 286| (yy_c_buf_p) = yy_cp; 5575| 286|} stage1scan.c:yy_load_buffer_state: 5711| 1.26k|{ 5712| 1.26k| (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 399| 1.26k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5713| 1.26k| (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 528| 1.26k|#define yytext_ptr yytext ------------------ (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 399| 1.26k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5714| | 5715| 1.26k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 399| 1.26k|#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ------------------ 5716| | 5717| 1.26k| (yy_hold_char) = *(yy_c_buf_p); 5718| 1.26k|} stage1scan.c:yy_init_buffer: 5780| 633|{ 5781| 633| int oerrno = errno; 5782| | 5783| 633| yy_flush_buffer( b ); 5784| | 5785| 633| b->yy_input_file = file; 5786| | 5787| | /* b->yy_input_file should never by NULL but we'll handle it cleanly 5788| | * on the off chance. 5789| | */ 5790| 633| if (b->yy_input_file == NULL){ ------------------ | Branch (5790:6): [True: 0, False: 633] ------------------ 5791| 0| b->yy_fill_buffer = 0; 5792| 633| } else { 5793| 633| b->yy_fill_buffer = 1; 5794| 633| } 5795| | 5796| | /* If b is the current buffer, then yy_init_buffer was _probably_ 5797| | * called from yyrestart() or through yy_get_next_buffer. 5798| | * In that case, we don't want to reset the lineno or column. 5799| | */ 5800| 633| if (b != yy_current_buffer()) { ------------------ | | 391| 633|#define yy_current_buffer() ( (yy_buffer_stack) \ | | ------------------ | | | Branch (391:31): [True: 633, False: 0] | | ------------------ | | 392| 633| ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ | | 393| 633| : NULL) ------------------ | Branch (5800:6): [True: 1, False: 632] ------------------ 5801| 1| b->yy_bs_lineno = 1; 5802| 1| b->yy_bs_column = 0; 5803| 1| } 5804| | 5805| 633| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ------------------ | Branch (5805:32): [True: 633, False: 0] ------------------ 5806| | 5807| 633| errno = oerrno; 5808| 633|} stage1scan.c:yyensure_buffer_stack: 5902| 1|{ 5903| 1| yy_size_t num_to_alloc; 5904| | 5905| 1| if ((yy_buffer_stack) == NULL) { ------------------ | Branch (5905:6): [True: 1, False: 0] ------------------ 5906| | /* First allocation is just for 2 elements, since we don't know if this 5907| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 5908| | * immediate realloc on the next call. 5909| | */ 5910| 1| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 5911| 1| (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 5912| 1| (num_to_alloc * sizeof(struct yy_buffer_state*) 5913| 1| ); 5914| 1| if ( (yy_buffer_stack == NULL) ) { ------------------ | Branch (5914:8): [True: 0, False: 1] ------------------ 5915| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 5916| 0| } 5917| | 5918| 1| memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 5919| | 5920| 1| (yy_buffer_stack_max) = num_to_alloc; 5921| 1| (yy_buffer_stack_top) = 0; 5922| 1| return; 5923| 1| } 5924| | 5925| 0| if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1) { ------------------ | Branch (5925:6): [True: 0, False: 0] ------------------ 5926| | /* Increase the buffer to prepare for a possible push. */ 5927| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 5928| | 5929| 0| num_to_alloc = (yy_buffer_stack_max) + grow_size; 5930| 0| (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 5931| 0| ((yy_buffer_stack), 5932| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 5933| 0| ); 5934| 0| if ((yy_buffer_stack) == NULL) { ------------------ | Branch (5934:7): [True: 0, False: 0] ------------------ 5935| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 5936| 0| } 5937| | /* zero only the new slots.*/ 5938| 0| memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 5939| 0| (yy_buffer_stack_max) = num_to_alloc; 5940| 0| } 5941| 0|} stage1scan.c:yy_push_state: 6030| 1.28k|{ 6031| 1.28k| if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) ) { ------------------ | Branch (6031:8): [True: 1, False: 1.28k] ------------------ 6032| 1| yy_size_t new_size; 6033| | 6034| 1| (yy_start_stack_depth) += YY_START_STACK_INCR; ------------------ | | 2709| 1|#define YY_START_STACK_INCR 25 ------------------ 6035| 1| new_size = (yy_size_t) (yy_start_stack_depth) * sizeof( int ); 6036| | 6037| 1| if ( ! (yy_start_stack) ) { ------------------ | Branch (6037:8): [True: 1, False: 0] ------------------ 6038| 1| (yy_start_stack) = (int *) yyalloc( new_size ); 6039| | 6040| 1| } else { 6041| 0| (yy_start_stack) = (int *) yyrealloc( 6042| 0| (void *) (yy_start_stack), new_size ); 6043| 0| } 6044| 1| if ( ! (yy_start_stack) ) { ------------------ | Branch (6044:8): [True: 0, False: 1] ------------------ 6045| 0| YY_FATAL_ERROR( "out of memory expanding start-condition stack" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 6046| 0| } 6047| 1| } 6048| 1.28k| (yy_start_stack)[(yy_start_stack_ptr)++] = yystart(); ------------------ | | 238| 1.28k|#define yystart() (((yy_start) - 1) / 2) ------------------ 6049| | 6050| 1.28k| yybegin(_new_state); ------------------ | | 231| 1.28k|#define yybegin(s) (yy_start) = 1 + 2 * (s) ------------------ 6051| 1.28k|} stage1scan.c:yy_pop_state: 6055| 1.28k|{ 6056| 1.28k| if ( --(yy_start_stack_ptr) < 0 ) { ------------------ | Branch (6056:8): [True: 0, False: 1.28k] ------------------ 6057| 0| YY_FATAL_ERROR( "start-condition stack underflow" ); ------------------ | | 2653| 0|#define YY_FATAL_ERROR(msg) yypanic( msg ) ------------------ 6058| 0| } 6059| 1.28k| yybegin((yy_start_stack)[(yy_start_stack_ptr)]); ------------------ | | 231| 1.28k|#define yybegin(s) (yy_start) = 1 + 2 * (s) ------------------ 6060| 1.28k|} cclinstal: 115| 78|{ 116| | /* We don't bother checking the return status because we are not 117| | * called unless the symbol is new. 118| | */ 119| | 120| 78| (void) addsym (xstrdup(ccltxt), 121| 78| (char *) 0, cclnum, ccltab, CCL_HASH_SIZE); ------------------ | | 53| 78|#define CCL_HASH_SIZE 101 ------------------ 122| 78|} ndinstal: 178| 22|{ 179| | 180| 22| if (addsym (xstrdup(name), ------------------ | Branch (180:6): [True: 17, False: 5] ------------------ 181| 22| xstrdup(definition), 0, 182| 22| ndtbl, NAME_TABLE_HASH_SIZE)) ------------------ | | 51| 22|#define NAME_TABLE_HASH_SIZE 101 ------------------ 183| 17| synerr (_("name defined twice")); ------------------ | | 85| 17|#define _(String) gettext (String) ------------------ 184| 22|} scinstal: 221| 632|{ 222| | 223| 632| if (++lastsc >= current_max_scs) ------------------ | Branch (223:6): [True: 0, False: 632] ------------------ 224| 0| scextend (); 225| | 226| 632| scname[lastsc] = xstrdup(str); 227| | 228| 632| if (addsym(scname[lastsc], NULL, lastsc, ------------------ | Branch (228:6): [True: 631, False: 1] ------------------ 229| 632| sctbl, START_COND_HASH_SIZE)) ------------------ | | 52| 632|#define START_COND_HASH_SIZE 101 ------------------ 230| 631| format_pinpoint_message (_ ------------------ | | 85| 631|#define _(String) gettext (String) ------------------ 231| 631| ("start condition %s declared twice"), 232| 631|str); 233| | 234| 632| scset[lastsc] = mkstate (SYM_EPSILON); ------------------ | | 219| 632|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 632|#define CSIZE 256 | | ------------------ ------------------ 235| 632| scbol[lastsc] = mkstate (SYM_EPSILON); ------------------ | | 219| 632|#define SYM_EPSILON (CSIZE + 1) /* to mark transitions on the symbol epsilon */ | | ------------------ | | | | 91| 632|#define CSIZE 256 | | ------------------ ------------------ 236| 632| scxclu[lastsc] = xcluflg; 237| 632| sceof[lastsc] = false; 238| 632|} sym.c:addsym: 74| 732|{ 75| 732| int hash_val = hashfunct (sym, table_size); 76| 732| struct hash_entry *sym_entry = table[hash_val]; 77| 732| struct hash_entry *new_entry; 78| 732| struct hash_entry *successor; 79| | 80| 743| while (sym_entry) { ------------------ | Branch (80:9): [True: 701, False: 42] ------------------ 81| 701| if (!strcmp (sym, sym_entry->name)) { /* entry already exists */ ------------------ | Branch (81:7): [True: 690, False: 11] ------------------ 82| 690| return -1; 83| 690| } 84| | 85| 11| sym_entry = sym_entry->next; 86| 11| } 87| | 88| | /* create new entry */ 89| 42| new_entry = malloc(sizeof(struct hash_entry)); 90| | 91| 42| if (new_entry == NULL) ------------------ | Branch (91:6): [True: 0, False: 42] ------------------ 92| 0| flexfatal (_("symbol table memory allocation failed")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 93| | 94| 42| if ((successor = table[hash_val]) != 0) { ------------------ | Branch (94:6): [True: 6, False: 36] ------------------ 95| 6| new_entry->next = successor; 96| 6| successor->prev = new_entry; 97| 6| } 98| 36| else 99| 36| new_entry->next = NULL; 100| | 101| 42| new_entry->prev = NULL; 102| 42| new_entry->name = sym; 103| 42| new_entry->str_val = str_def; 104| 42| new_entry->int_val = int_def; 105| | 106| 42| table[hash_val] = new_entry; 107| | 108| 42| return 0; 109| 732|} sym.c:hashfunct: 159| 732|{ 160| 732| int hashval; 161| 732| int locstr; 162| | 163| 732| hashval = 0; 164| 732| locstr = 0; 165| | 166| 5.90k| while (str[locstr]) { ------------------ | Branch (166:9): [True: 5.17k, False: 732] ------------------ 167| 5.17k| hashval = (hashval << 1) + (unsigned char) str[locstr++]; 168| 5.17k| hashval %= hash_size; 169| 5.17k| } 170| | 171| 732| return hashval; 172| 732|} yylex: 44| 10.7k|{ 45| 10.7k| int toktype; 46| 10.7k| static int beglin = false; 47| | 48| 10.7k| if (eofseen) { ------------------ | Branch (48:6): [True: 631, False: 10.0k] ------------------ 49| 631| toktype = EOF; 50| 10.0k| } else { 51| 10.0k| toktype = flexscan (); 52| 10.0k| } 53| 10.7k| if (toktype == EOF || toktype == 0) { ------------------ | Branch (53:6): [True: 631, False: 10.0k] | Branch (53:24): [True: 632, False: 9.44k] ------------------ 54| 1.26k| eofseen = 1; 55| | 56| 1.26k| if (sectnum == 1) { ------------------ | Branch (56:7): [True: 631, False: 632] ------------------ 57| 631| synerr (_("premature EOF")); ------------------ | | 85| 631|#define _(String) gettext (String) ------------------ 58| 631| sectnum = 2; 59| 631| toktype = SECTEND; ------------------ | | 111| 631|#define SECTEND 260 ------------------ 60| 631| } 61| | 62| 632| else 63| 632| toktype = 0; 64| 1.26k| } 65| | 66| 10.7k| if (env.trace) { ------------------ | Branch (66:6): [True: 0, False: 10.7k] ------------------ 67| 0| if (beglin) { ------------------ | Branch (67:7): [True: 0, False: 0] ------------------ 68| 0| fprintf (stderr, "%d\t", num_rules + 1); 69| 0| beglin = 0; 70| 0| } 71| | 72| 0| switch (toktype) { 73| 0| case '<': ------------------ | Branch (73:3): [True: 0, False: 0] ------------------ 74| 0| case '>': ------------------ | Branch (74:3): [True: 0, False: 0] ------------------ 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| (void) putc (toktype, stderr); 94| 0| break; 95| | 96| 0| case '\n': ------------------ | Branch (96:3): [True: 0, False: 0] ------------------ 97| 0| (void) putc ('\n', stderr); 98| | 99| 0| if (sectnum == 2) ------------------ | Branch (99:8): [True: 0, False: 0] ------------------ 100| 0| beglin = 1; 101| | 102| 0| break; 103| | 104| 0| case SCDECL: ------------------ | | 112| 0|#define SCDECL 261 ------------------ | Branch (104:3): [True: 0, False: 0] ------------------ 105| 0| fputs ("%s", stderr); 106| 0| break; 107| | 108| 0| case XSCDECL: ------------------ | | 113| 0|#define XSCDECL 262 ------------------ | Branch (108:3): [True: 0, False: 0] ------------------ 109| 0| fputs ("%x", stderr); 110| 0| break; 111| | 112| 0| case SECTEND: ------------------ | | 111| 0|#define SECTEND 260 ------------------ | Branch (112:3): [True: 0, False: 0] ------------------ 113| 0| fputs ("%%\n", stderr); 114| | 115| | /* We set beglin to be true so we'll start 116| | * writing out numbers as we echo rules. 117| | * flexscan() has already assigned sectnum. 118| | */ 119| 0| if (sectnum == 2) ------------------ | Branch (119:8): [True: 0, False: 0] ------------------ 120| 0| beglin = 1; 121| | 122| 0| break; 123| | 124| 0| case NAME: ------------------ | | 114| 0|#define NAME 263 ------------------ | Branch (124:3): [True: 0, False: 0] ------------------ 125| 0| fprintf (stderr, "'%s'", nmstr); 126| 0| break; 127| | 128| 0| case CHAR: ------------------ | | 109| 0|#define CHAR 258 ------------------ | Branch (128:3): [True: 0, False: 0] ------------------ 129| 0| switch (yylval) { 130| 0| case '<': ------------------ | Branch (130:4): [True: 0, False: 0] ------------------ 131| 0| case '>': ------------------ | Branch (131:4): [True: 0, False: 0] ------------------ 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| fprintf (stderr, "\\%c", yylval); 151| 0| break; 152| | 153| 0| default: ------------------ | Branch (153:4): [True: 0, False: 0] ------------------ 154| 0| if (!isascii (yylval) || !isprint (yylval)) { ------------------ | Branch (154:9): [True: 0, False: 0] | Branch (154:30): [True: 0, False: 0] ------------------ 155| 0| if(env.trace_hex) ------------------ | Branch (155:9): [True: 0, False: 0] ------------------ 156| 0| fprintf (stderr, "\\x%02x", (unsigned int) yylval); 157| 0| else 158| 0| fprintf (stderr, "\\%.3o", (unsigned int) yylval); 159| 0| } else 160| 0| (void) putc (yylval, stderr); 161| 0| break; 162| 0| } 163| | 164| 0| break; 165| | 166| 0| case NUMBER: ------------------ | | 110| 0|#define NUMBER 259 ------------------ | Branch (166:3): [True: 0, False: 0] ------------------ 167| 0| fprintf (stderr, "%d", yylval); 168| 0| break; 169| | 170| 0| case PREVCCL: ------------------ | | 115| 0|#define PREVCCL 264 ------------------ | Branch (170:3): [True: 0, False: 0] ------------------ 171| 0| fprintf (stderr, "[%d]", yylval); 172| 0| break; 173| | 174| 0| case EOF_OP: ------------------ | | 116| 0|#define EOF_OP 265 ------------------ | Branch (174:3): [True: 0, False: 0] ------------------ 175| 0| fprintf (stderr, "<>"); 176| 0| break; 177| | 178| 0| case TOK_OPTION: ------------------ | | 117| 0|#define TOK_OPTION 266 ------------------ | Branch (178:3): [True: 0, False: 0] ------------------ 179| 0| fprintf (stderr, "%s ", yytext); 180| 0| break; 181| | 182| 0| case TOK_OUTFILE: ------------------ | | 118| 0|#define TOK_OUTFILE 267 ------------------ | Branch (182:3): [True: 0, False: 0] ------------------ 183| 0| case TOK_PREFIX: ------------------ | | 119| 0|#define TOK_PREFIX 268 ------------------ | Branch (183:3): [True: 0, False: 0] ------------------ 184| 0| case CCE_ALNUM: ------------------ | | 133| 0|#define CCE_ALNUM 282 ------------------ | Branch (184:3): [True: 0, False: 0] ------------------ 185| 0| case CCE_ALPHA: ------------------ | | 134| 0|#define CCE_ALPHA 283 ------------------ | Branch (185:3): [True: 0, False: 0] ------------------ 186| 0| case CCE_BLANK: ------------------ | | 135| 0|#define CCE_BLANK 284 ------------------ | Branch (186:3): [True: 0, False: 0] ------------------ 187| 0| case CCE_CNTRL: ------------------ | | 136| 0|#define CCE_CNTRL 285 ------------------ | Branch (187:3): [True: 0, False: 0] ------------------ 188| 0| case CCE_DIGIT: ------------------ | | 137| 0|#define CCE_DIGIT 286 ------------------ | Branch (188:3): [True: 0, False: 0] ------------------ 189| 0| case CCE_GRAPH: ------------------ | | 138| 0|#define CCE_GRAPH 287 ------------------ | Branch (189:3): [True: 0, False: 0] ------------------ 190| 0| case CCE_LOWER: ------------------ | | 139| 0|#define CCE_LOWER 288 ------------------ | Branch (190:3): [True: 0, False: 0] ------------------ 191| 0| case CCE_PRINT: ------------------ | | 140| 0|#define CCE_PRINT 289 ------------------ | Branch (191:3): [True: 0, False: 0] ------------------ 192| 0| case CCE_PUNCT: ------------------ | | 141| 0|#define CCE_PUNCT 290 ------------------ | Branch (192:3): [True: 0, False: 0] ------------------ 193| 0| case CCE_SPACE: ------------------ | | 142| 0|#define CCE_SPACE 291 ------------------ | Branch (193:3): [True: 0, False: 0] ------------------ 194| 0| case CCE_UPPER: ------------------ | | 143| 0|#define CCE_UPPER 292 ------------------ | Branch (194:3): [True: 0, False: 0] ------------------ 195| 0| case CCE_XDIGIT: ------------------ | | 144| 0|#define CCE_XDIGIT 293 ------------------ | Branch (195:3): [True: 0, False: 0] ------------------ 196| 0| fprintf (stderr, "%s", yytext); 197| 0| break; 198| | 199| 0| case 0: ------------------ | Branch (199:3): [True: 0, False: 0] ------------------ 200| 0| fprintf (stderr, _("End Marker\n")); ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 201| 0| break; 202| | 203| 0| default: ------------------ | Branch (203:3): [True: 0, False: 0] ------------------ 204| 0| fprintf (stderr, 205| 0| _ ------------------ | | 85| 0|#define _(String) gettext (String) ------------------ 206| 0| ("*Something Weird* - tok: %d val: %d\n"), 207| 0| toktype, yylval); 208| 0| break; 209| 0| } 210| 0| } 211| | 212| 10.7k| return toktype; 213| 10.7k|} LLVMFuzzerTestOneInput: 23| 632|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 24| 632| char filename[256]; 25| 632| sprintf(filename, "/tmp/libfuzzer.%d", getpid()); 26| | 27| 632| FILE *fp = fopen(filename, "wb"); 28| 632| if (!fp) { ------------------ | Branch (28:7): [True: 0, False: 632] ------------------ 29| 0| return 0; 30| 0| } 31| 632| fwrite(data, size, 1, fp); 32| 632| fclose(fp); 33| | 34| 632| my_argv[0] = "/tmp/fakefuzzer"; 35| 632| my_argv[1] = filename; 36| 632| my_argv[2] = NULL; 37| | 38| 632| flex_main(2, my_argv); 39| | 40| 632| unlink(filename); 41| 632| return 0; 42| 632|}