aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--tools/perf/Makefile47
-rw-r--r--tools/perf/util/annotate.c8
-rw-r--r--tools/perf/util/evsel.c2
-rw-r--r--tools/perf/util/hist.c157
-rw-r--r--tools/perf/util/parse-events-bison.c1917
-rw-r--r--tools/perf/util/parse-events-bison.h81
-rw-r--r--tools/perf/util/parse-events-flex.c2272
-rw-r--r--tools/perf/util/parse-events-flex.h316
-rw-r--r--tools/perf/util/parse-events.l1
-rw-r--r--tools/perf/util/pmu-bison.c1663
-rw-r--r--tools/perf/util/pmu-bison.h73
-rw-r--r--tools/perf/util/pmu-flex.c1821
-rw-r--r--tools/perf/util/pmu-flex.h316
-rw-r--r--tools/perf/util/probe-finder.c4
-rw-r--r--tools/perf/util/symbol.c3
15 files changed, 135 insertions, 8546 deletions
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 2f4288638806..820371f10d1b 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -61,8 +61,6 @@ ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
61 61
62CC = $(CROSS_COMPILE)gcc 62CC = $(CROSS_COMPILE)gcc
63AR = $(CROSS_COMPILE)ar 63AR = $(CROSS_COMPILE)ar
64FLEX = $(CROSS_COMPILE)flex
65BISON= $(CROSS_COMPILE)bison
66 64
67# Additional ARCH settings for x86 65# Additional ARCH settings for x86
68ifeq ($(ARCH),i386) 66ifeq ($(ARCH),i386)
@@ -184,7 +182,7 @@ endif
184 182
185### --- END CONFIGURATION SECTION --- 183### --- END CONFIGURATION SECTION ---
186 184
187BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE 185BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include -I$(OUTPUT)/util -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
188BASIC_LDFLAGS = 186BASIC_LDFLAGS =
189 187
190# Guard against environment variables 188# Guard against environment variables
@@ -236,6 +234,25 @@ endif
236 234
237export PERL_PATH 235export PERL_PATH
238 236
237FLEX = $(CROSS_COMPILE)flex
238BISON= $(CROSS_COMPILE)bison
239
240event-parser:
241 $(QUIET_BISON)$(BISON) -v util/parse-events.y -d -o $(OUTPUT)util/parse-events-bison.c
242 $(QUIET_FLEX)$(FLEX) --header-file=$(OUTPUT)util/parse-events-flex.h -t util/parse-events.l > $(OUTPUT)util/parse-events-flex.c
243
244$(OUTPUT)util/parse-events-flex.c: event-parser
245$(OUTPUT)util/parse-events-bison.c: event-parser
246
247pmu-parser:
248 $(QUIET_BISON)$(BISON) -v util/pmu.y -d -o $(OUTPUT)util/pmu-bison.c
249 $(QUIET_FLEX)$(FLEX) --header-file=$(OUTPUT)util/pmu-flex.h -t util/pmu.l > $(OUTPUT)util/pmu-flex.c
250
251$(OUTPUT)util/pmu-flex.c: pmu-parser
252$(OUTPUT)util/pmu-bison.c: pmu-parser
253
254$(OUTPUT)util/parse-events.o: event-parser pmu-parser
255
239LIB_FILE=$(OUTPUT)libperf.a 256LIB_FILE=$(OUTPUT)libperf.a
240 257
241LIB_H += ../../include/linux/perf_event.h 258LIB_H += ../../include/linux/perf_event.h
@@ -754,6 +771,15 @@ $(OUTPUT)perf.o perf.spec \
754.SUFFIXES: 771.SUFFIXES:
755.SUFFIXES: .o .c .S .s 772.SUFFIXES: .o .c .S .s
756 773
774# These two need to be here so that when O= is not used they take precedence
775# over the general rule for .o
776
777$(OUTPUT)util/%-flex.o: $(OUTPUT)util/%-flex.c $(OUTPUT)PERF-CFLAGS
778 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Iutil/ -Wno-redundant-decls -Wno-switch-default -Wno-unused-function $<
779
780$(OUTPUT)util/%-bison.o: $(OUTPUT)util/%-bison.c $(OUTPUT)PERF-CFLAGS
781 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -Iutil/ -Wno-redundant-decls -Wno-switch-default -Wno-unused-function $<
782
757$(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS 783$(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
758 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $< 784 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
759$(OUTPUT)%.i: %.c $(OUTPUT)PERF-CFLAGS 785$(OUTPUT)%.i: %.c $(OUTPUT)PERF-CFLAGS
@@ -790,12 +816,6 @@ $(OUTPUT)util/ui/browsers/map.o: util/ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
790$(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS 816$(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
791 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $< 817 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
792 818
793$(OUTPUT)util/parse-events-flex.o: util/parse-events-flex.c $(OUTPUT)PERF-CFLAGS
794 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Wno-redundant-decls -Wno-switch-default -Wno-unused-function $<
795
796$(OUTPUT)util/pmu-flex.o: util/pmu-flex.c $(OUTPUT)PERF-CFLAGS
797 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Wno-redundant-decls -Wno-switch-default -Wno-unused-function $<
798
799$(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS 819$(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
800 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $< 820 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
801 821
@@ -883,14 +903,6 @@ cscope:
883 $(RM) cscope* 903 $(RM) cscope*
884 $(FIND) . -name '*.[hcS]' -print | xargs cscope -b 904 $(FIND) . -name '*.[hcS]' -print | xargs cscope -b
885 905
886event-parser:
887 $(QUIET_BISON)$(BISON) -v util/parse-events.y -d -o util/parse-events-bison.c
888 $(QUIET_FLEX)$(FLEX) --header-file=util/parse-events-flex.h -t util/parse-events.l > util/parse-events-flex.c
889
890pmu-parser:
891 $(QUIET_BISON)$(BISON) -v util/pmu.y -d -o util/pmu-bison.c
892 $(QUIET_FLEX)$(FLEX) --header-file=util/pmu-flex.h -t util/pmu.l > util/pmu-flex.c
893
894### Detect prefix changes 906### Detect prefix changes
895TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\ 907TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\
896 $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ) 908 $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)
@@ -978,6 +990,7 @@ clean:
978 $(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope* 990 $(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope*
979 $(MAKE) -C Documentation/ clean 991 $(MAKE) -C Documentation/ clean
980 $(RM) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS 992 $(RM) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS
993 $(RM) $(OUTPUT)util/*-{bison,flex}*
981 $(python-clean) 994 $(python-clean)
982 995
983.PHONY: all install clean strip 996.PHONY: all install clean strip
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index e5a462f1d07c..199f69ec656f 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -28,8 +28,8 @@ int symbol__annotate_init(struct map *map __used, struct symbol *sym)
28int symbol__alloc_hist(struct symbol *sym) 28int symbol__alloc_hist(struct symbol *sym)
29{ 29{
30 struct annotation *notes = symbol__annotation(sym); 30 struct annotation *notes = symbol__annotation(sym);
31 size_t sizeof_sym_hist = (sizeof(struct sym_hist) + 31 const size_t size = sym->end - sym->start + 1;
32 (sym->end - sym->start) * sizeof(u64)); 32 size_t sizeof_sym_hist = (sizeof(struct sym_hist) + size * sizeof(u64));
33 33
34 notes->src = zalloc(sizeof(*notes->src) + symbol_conf.nr_events * sizeof_sym_hist); 34 notes->src = zalloc(sizeof(*notes->src) + symbol_conf.nr_events * sizeof_sym_hist);
35 if (notes->src == NULL) 35 if (notes->src == NULL)
@@ -64,7 +64,7 @@ int symbol__inc_addr_samples(struct symbol *sym, struct map *map,
64 64
65 pr_debug3("%s: addr=%#" PRIx64 "\n", __func__, map->unmap_ip(map, addr)); 65 pr_debug3("%s: addr=%#" PRIx64 "\n", __func__, map->unmap_ip(map, addr));
66 66
67 if (addr >= sym->end) 67 if (addr > sym->end)
68 return 0; 68 return 0;
69 69
70 offset = addr - sym->start; 70 offset = addr - sym->start;
@@ -408,7 +408,7 @@ static int symbol__get_source_line(struct symbol *sym, struct map *map,
408 if (!notes->src->lines) 408 if (!notes->src->lines)
409 return -1; 409 return -1;
410 410
411 start = map->unmap_ip(map, sym->start); 411 start = map__rip_2objdump(map, sym->start);
412 412
413 for (i = 0; i < len; i++) { 413 for (i = 0; i < len; i++) {
414 char *path = NULL; 414 char *path = NULL;
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index d9da62a7234f..8c13dbcb84b9 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -580,6 +580,8 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
580 return -EFAULT; 580 return -EFAULT;
581 581
582 data->raw_data = (void *) pdata; 582 data->raw_data = (void *) pdata;
583
584 array = (void *)array + data->raw_size + sizeof(u32);
583 } 585 }
584 586
585 if (type & PERF_SAMPLE_BRANCH_STACK) { 587 if (type & PERF_SAMPLE_BRANCH_STACK) {
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index c61235f81260..2ec4b60aff6c 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -607,7 +607,7 @@ static void init_rem_hits(void)
607 rem_hits.ms.sym = rem_sq_bracket; 607 rem_hits.ms.sym = rem_sq_bracket;
608} 608}
609 609
610static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self, 610static size_t __callchain__fprintf_graph(FILE *fp, struct rb_root *root,
611 u64 total_samples, int depth, 611 u64 total_samples, int depth,
612 int depth_mask, int left_margin) 612 int depth_mask, int left_margin)
613{ 613{
@@ -615,21 +615,16 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
615 struct callchain_node *child; 615 struct callchain_node *child;
616 struct callchain_list *chain; 616 struct callchain_list *chain;
617 int new_depth_mask = depth_mask; 617 int new_depth_mask = depth_mask;
618 u64 new_total;
619 u64 remaining; 618 u64 remaining;
620 size_t ret = 0; 619 size_t ret = 0;
621 int i; 620 int i;
622 uint entries_printed = 0; 621 uint entries_printed = 0;
623 622
624 if (callchain_param.mode == CHAIN_GRAPH_REL) 623 remaining = total_samples;
625 new_total = self->children_hit;
626 else
627 new_total = total_samples;
628
629 remaining = new_total;
630 624
631 node = rb_first(&self->rb_root); 625 node = rb_first(root);
632 while (node) { 626 while (node) {
627 u64 new_total;
633 u64 cumul; 628 u64 cumul;
634 629
635 child = rb_entry(node, struct callchain_node, rb_node); 630 child = rb_entry(node, struct callchain_node, rb_node);
@@ -657,11 +652,17 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
657 list_for_each_entry(chain, &child->val, list) { 652 list_for_each_entry(chain, &child->val, list) {
658 ret += ipchain__fprintf_graph(fp, chain, depth, 653 ret += ipchain__fprintf_graph(fp, chain, depth,
659 new_depth_mask, i++, 654 new_depth_mask, i++,
660 new_total, 655 total_samples,
661 cumul, 656 cumul,
662 left_margin); 657 left_margin);
663 } 658 }
664 ret += __callchain__fprintf_graph(fp, child, new_total, 659
660 if (callchain_param.mode == CHAIN_GRAPH_REL)
661 new_total = child->children_hit;
662 else
663 new_total = total_samples;
664
665 ret += __callchain__fprintf_graph(fp, &child->rb_root, new_total,
665 depth + 1, 666 depth + 1,
666 new_depth_mask | (1 << depth), 667 new_depth_mask | (1 << depth),
667 left_margin); 668 left_margin);
@@ -671,61 +672,75 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
671 } 672 }
672 673
673 if (callchain_param.mode == CHAIN_GRAPH_REL && 674 if (callchain_param.mode == CHAIN_GRAPH_REL &&
674 remaining && remaining != new_total) { 675 remaining && remaining != total_samples) {
675 676
676 if (!rem_sq_bracket) 677 if (!rem_sq_bracket)
677 return ret; 678 return ret;
678 679
679 new_depth_mask &= ~(1 << (depth - 1)); 680 new_depth_mask &= ~(1 << (depth - 1));
680
681 ret += ipchain__fprintf_graph(fp, &rem_hits, depth, 681 ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
682 new_depth_mask, 0, new_total, 682 new_depth_mask, 0, total_samples,
683 remaining, left_margin); 683 remaining, left_margin);
684 } 684 }
685 685
686 return ret; 686 return ret;
687} 687}
688 688
689static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self, 689static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
690 u64 total_samples, int left_margin) 690 u64 total_samples, int left_margin)
691{ 691{
692 struct callchain_node *cnode;
692 struct callchain_list *chain; 693 struct callchain_list *chain;
694 u32 entries_printed = 0;
693 bool printed = false; 695 bool printed = false;
696 struct rb_node *node;
694 int i = 0; 697 int i = 0;
695 int ret = 0; 698 int ret;
696 u32 entries_printed = 0;
697
698 list_for_each_entry(chain, &self->val, list) {
699 if (!i++ && sort__first_dimension == SORT_SYM)
700 continue;
701
702 if (!printed) {
703 ret += callchain__fprintf_left_margin(fp, left_margin);
704 ret += fprintf(fp, "|\n");
705 ret += callchain__fprintf_left_margin(fp, left_margin);
706 ret += fprintf(fp, "---");
707
708 left_margin += 3;
709 printed = true;
710 } else
711 ret += callchain__fprintf_left_margin(fp, left_margin);
712 699
713 if (chain->ms.sym) 700 /*
714 ret += fprintf(fp, " %s\n", chain->ms.sym->name); 701 * If have one single callchain root, don't bother printing
715 else 702 * its percentage (100 % in fractal mode and the same percentage
716 ret += fprintf(fp, " %p\n", (void *)(long)chain->ip); 703 * than the hist in graph mode). This also avoid one level of column.
704 */
705 node = rb_first(root);
706 if (node && !rb_next(node)) {
707 cnode = rb_entry(node, struct callchain_node, rb_node);
708 list_for_each_entry(chain, &cnode->val, list) {
709 /*
710 * If we sort by symbol, the first entry is the same than
711 * the symbol. No need to print it otherwise it appears as
712 * displayed twice.
713 */
714 if (!i++ && sort__first_dimension == SORT_SYM)
715 continue;
716 if (!printed) {
717 ret += callchain__fprintf_left_margin(fp, left_margin);
718 ret += fprintf(fp, "|\n");
719 ret += callchain__fprintf_left_margin(fp, left_margin);
720 ret += fprintf(fp, "---");
721 left_margin += 3;
722 printed = true;
723 } else
724 ret += callchain__fprintf_left_margin(fp, left_margin);
725
726 if (chain->ms.sym)
727 ret += fprintf(fp, " %s\n", chain->ms.sym->name);
728 else
729 ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
717 730
718 if (++entries_printed == callchain_param.print_limit) 731 if (++entries_printed == callchain_param.print_limit)
719 break; 732 break;
733 }
734 root = &cnode->rb_root;
720 } 735 }
721 736
722 ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin); 737 return __callchain__fprintf_graph(fp, root, total_samples,
723 738 1, 1, left_margin);
724 return ret;
725} 739}
726 740
727static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self, 741static size_t __callchain__fprintf_flat(FILE *fp,
728 u64 total_samples) 742 struct callchain_node *self,
743 u64 total_samples)
729{ 744{
730 struct callchain_list *chain; 745 struct callchain_list *chain;
731 size_t ret = 0; 746 size_t ret = 0;
@@ -733,7 +748,7 @@ static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
733 if (!self) 748 if (!self)
734 return 0; 749 return 0;
735 750
736 ret += callchain__fprintf_flat(fp, self->parent, total_samples); 751 ret += __callchain__fprintf_flat(fp, self->parent, total_samples);
737 752
738 753
739 list_for_each_entry(chain, &self->val, list) { 754 list_for_each_entry(chain, &self->val, list) {
@@ -749,44 +764,58 @@ static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
749 return ret; 764 return ret;
750} 765}
751 766
752static size_t hist_entry_callchain__fprintf(struct hist_entry *he, 767static size_t callchain__fprintf_flat(FILE *fp, struct rb_root *self,
753 u64 total_samples, int left_margin, 768 u64 total_samples)
754 FILE *fp)
755{ 769{
756 struct rb_node *rb_node;
757 struct callchain_node *chain;
758 size_t ret = 0; 770 size_t ret = 0;
759 u32 entries_printed = 0; 771 u32 entries_printed = 0;
772 struct rb_node *rb_node;
773 struct callchain_node *chain;
760 774
761 rb_node = rb_first(&he->sorted_chain); 775 rb_node = rb_first(self);
762 while (rb_node) { 776 while (rb_node) {
763 double percent; 777 double percent;
764 778
765 chain = rb_entry(rb_node, struct callchain_node, rb_node); 779 chain = rb_entry(rb_node, struct callchain_node, rb_node);
766 percent = chain->hit * 100.0 / total_samples; 780 percent = chain->hit * 100.0 / total_samples;
767 switch (callchain_param.mode) { 781
768 case CHAIN_FLAT: 782 ret = percent_color_fprintf(fp, " %6.2f%%\n", percent);
769 ret += percent_color_fprintf(fp, " %6.2f%%\n", 783 ret += __callchain__fprintf_flat(fp, chain, total_samples);
770 percent);
771 ret += callchain__fprintf_flat(fp, chain, total_samples);
772 break;
773 case CHAIN_GRAPH_ABS: /* Falldown */
774 case CHAIN_GRAPH_REL:
775 ret += callchain__fprintf_graph(fp, chain, total_samples,
776 left_margin);
777 case CHAIN_NONE:
778 default:
779 break;
780 }
781 ret += fprintf(fp, "\n"); 784 ret += fprintf(fp, "\n");
782 if (++entries_printed == callchain_param.print_limit) 785 if (++entries_printed == callchain_param.print_limit)
783 break; 786 break;
787
784 rb_node = rb_next(rb_node); 788 rb_node = rb_next(rb_node);
785 } 789 }
786 790
787 return ret; 791 return ret;
788} 792}
789 793
794static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
795 u64 total_samples, int left_margin,
796 FILE *fp)
797{
798 switch (callchain_param.mode) {
799 case CHAIN_GRAPH_REL:
800 return callchain__fprintf_graph(fp, &he->sorted_chain, he->period,
801 left_margin);
802 break;
803 case CHAIN_GRAPH_ABS:
804 return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
805 left_margin);
806 break;
807 case CHAIN_FLAT:
808 return callchain__fprintf_flat(fp, &he->sorted_chain, total_samples);
809 break;
810 case CHAIN_NONE:
811 break;
812 default:
813 pr_err("Bad callchain mode\n");
814 }
815
816 return 0;
817}
818
790void hists__output_recalc_col_len(struct hists *hists, int max_rows) 819void hists__output_recalc_col_len(struct hists *hists, int max_rows)
791{ 820{
792 struct rb_node *next = rb_first(&hists->entries); 821 struct rb_node *next = rb_first(&hists->entries);
diff --git a/tools/perf/util/parse-events-bison.c b/tools/perf/util/parse-events-bison.c
deleted file mode 100644
index 4a4e02aff34e..000000000000
--- a/tools/perf/util/parse-events-bison.c
+++ /dev/null
@@ -1,1917 +0,0 @@
1/* A Bison parser, made by GNU Bison 2.5. */
2
3/* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20/* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33/* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36/* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43/* Identify Bison output. */
44#define YYBISON 1
45
46/* Bison version. */
47#define YYBISON_VERSION "2.5"
48
49/* Skeleton name. */
50#define YYSKELETON_NAME "yacc.c"
51
52/* Pure parsers. */
53#define YYPURE 0
54
55/* Push parsers. */
56#define YYPUSH 0
57
58/* Pull parsers. */
59#define YYPULL 1
60
61/* Using locations. */
62#define YYLSP_NEEDED 0
63
64/* Substitute the variable and function names. */
65#define yyparse parse_events_parse
66#define yylex parse_events_lex
67#define yyerror parse_events_error
68#define yylval parse_events_lval
69#define yychar parse_events_char
70#define yydebug parse_events_debug
71#define yynerrs parse_events_nerrs
72
73
74/* Copy the first part of user declarations. */
75
76/* Line 268 of yacc.c */
77#line 7 "util/parse-events.y"
78
79
80#define YYDEBUG 1
81
82#include <linux/compiler.h>
83#include <linux/list.h>
84#include "types.h"
85#include "util.h"
86#include "parse-events.h"
87
88extern int parse_events_lex (void);
89
90#define ABORT_ON(val) \
91do { \
92 if (val) \
93 YYABORT; \
94} while (0)
95
96
97
98/* Line 268 of yacc.c */
99#line 100 "util/parse-events-bison.c"
100
101/* Enabling traces. */
102#ifndef YYDEBUG
103# define YYDEBUG 0
104#endif
105
106/* Enabling verbose error messages. */
107#ifdef YYERROR_VERBOSE
108# undef YYERROR_VERBOSE
109# define YYERROR_VERBOSE 1
110#else
111# define YYERROR_VERBOSE 0
112#endif
113
114/* Enabling the token table. */
115#ifndef YYTOKEN_TABLE
116# define YYTOKEN_TABLE 0
117#endif
118
119
120/* Tokens. */
121#ifndef YYTOKENTYPE
122# define YYTOKENTYPE
123 /* Put the tokens into the symbol table, so that GDB and other debuggers
124 know about them. */
125 enum yytokentype {
126 PE_VALUE = 258,
127 PE_VALUE_SYM = 259,
128 PE_RAW = 260,
129 PE_TERM = 261,
130 PE_NAME = 262,
131 PE_MODIFIER_EVENT = 263,
132 PE_MODIFIER_BP = 264,
133 PE_NAME_CACHE_TYPE = 265,
134 PE_NAME_CACHE_OP_RESULT = 266,
135 PE_PREFIX_MEM = 267,
136 PE_PREFIX_RAW = 268,
137 PE_ERROR = 269
138 };
139#endif
140
141
142
143#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
144typedef union YYSTYPE
145{
146
147/* Line 293 of yacc.c */
148#line 46 "util/parse-events.y"
149
150 char *str;
151 unsigned long num;
152 struct list_head *head;
153 struct parse_events__term *term;
154
155
156
157/* Line 293 of yacc.c */
158#line 159 "util/parse-events-bison.c"
159} YYSTYPE;
160# define YYSTYPE_IS_TRIVIAL 1
161# define yystype YYSTYPE /* obsolescent; will be withdrawn */
162# define YYSTYPE_IS_DECLARED 1
163#endif
164
165
166/* Copy the second part of user declarations. */
167
168
169/* Line 343 of yacc.c */
170#line 171 "util/parse-events-bison.c"
171
172#ifdef short
173# undef short
174#endif
175
176#ifdef YYTYPE_UINT8
177typedef YYTYPE_UINT8 yytype_uint8;
178#else
179typedef unsigned char yytype_uint8;
180#endif
181
182#ifdef YYTYPE_INT8
183typedef YYTYPE_INT8 yytype_int8;
184#elif (defined __STDC__ || defined __C99__FUNC__ \
185 || defined __cplusplus || defined _MSC_VER)
186typedef signed char yytype_int8;
187#else
188typedef short int yytype_int8;
189#endif
190
191#ifdef YYTYPE_UINT16
192typedef YYTYPE_UINT16 yytype_uint16;
193#else
194typedef unsigned short int yytype_uint16;
195#endif
196
197#ifdef YYTYPE_INT16
198typedef YYTYPE_INT16 yytype_int16;
199#else
200typedef short int yytype_int16;
201#endif
202
203#ifndef YYSIZE_T
204# ifdef __SIZE_TYPE__
205# define YYSIZE_T __SIZE_TYPE__
206# elif defined size_t
207# define YYSIZE_T size_t
208# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
209 || defined __cplusplus || defined _MSC_VER)
210# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
211# define YYSIZE_T size_t
212# else
213# define YYSIZE_T unsigned int
214# endif
215#endif
216
217#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
218
219#ifndef YY_
220# if defined YYENABLE_NLS && YYENABLE_NLS
221# if ENABLE_NLS
222# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
223# define YY_(msgid) dgettext ("bison-runtime", msgid)
224# endif
225# endif
226# ifndef YY_
227# define YY_(msgid) msgid
228# endif
229#endif
230
231/* Suppress unused-variable warnings by "using" E. */
232#if ! defined lint || defined __GNUC__
233# define YYUSE(e) ((void) (e))
234#else
235# define YYUSE(e) /* empty */
236#endif
237
238/* Identity function, used to suppress warnings about constant conditions. */
239#ifndef lint
240# define YYID(n) (n)
241#else
242#if (defined __STDC__ || defined __C99__FUNC__ \
243 || defined __cplusplus || defined _MSC_VER)
244static int
245YYID (int yyi)
246#else
247static int
248YYID (yyi)
249 int yyi;
250#endif
251{
252 return yyi;
253}
254#endif
255
256#if ! defined yyoverflow || YYERROR_VERBOSE
257
258/* The parser invokes alloca or malloc; define the necessary symbols. */
259
260# ifdef YYSTACK_USE_ALLOCA
261# if YYSTACK_USE_ALLOCA
262# ifdef __GNUC__
263# define YYSTACK_ALLOC __builtin_alloca
264# elif defined __BUILTIN_VA_ARG_INCR
265# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
266# elif defined _AIX
267# define YYSTACK_ALLOC __alloca
268# elif defined _MSC_VER
269# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
270# define alloca _alloca
271# else
272# define YYSTACK_ALLOC alloca
273# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
274 || defined __cplusplus || defined _MSC_VER)
275# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
276# ifndef EXIT_SUCCESS
277# define EXIT_SUCCESS 0
278# endif
279# endif
280# endif
281# endif
282# endif
283
284# ifdef YYSTACK_ALLOC
285 /* Pacify GCC's `empty if-body' warning. */
286# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
287# ifndef YYSTACK_ALLOC_MAXIMUM
288 /* The OS might guarantee only one guard page at the bottom of the stack,
289 and a page size can be as small as 4096 bytes. So we cannot safely
290 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
291 to allow for a few compiler-allocated temporary stack slots. */
292# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
293# endif
294# else
295# define YYSTACK_ALLOC YYMALLOC
296# define YYSTACK_FREE YYFREE
297# ifndef YYSTACK_ALLOC_MAXIMUM
298# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
299# endif
300# if (defined __cplusplus && ! defined EXIT_SUCCESS \
301 && ! ((defined YYMALLOC || defined malloc) \
302 && (defined YYFREE || defined free)))
303# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
304# ifndef EXIT_SUCCESS
305# define EXIT_SUCCESS 0
306# endif
307# endif
308# ifndef YYMALLOC
309# define YYMALLOC malloc
310# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
311 || defined __cplusplus || defined _MSC_VER)
312void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
313# endif
314# endif
315# ifndef YYFREE
316# define YYFREE free
317# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
318 || defined __cplusplus || defined _MSC_VER)
319void free (void *); /* INFRINGES ON USER NAME SPACE */
320# endif
321# endif
322# endif
323#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
324
325
326#if (! defined yyoverflow \
327 && (! defined __cplusplus \
328 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
329
330/* A type that is properly aligned for any stack member. */
331union yyalloc
332{
333 yytype_int16 yyss_alloc;
334 YYSTYPE yyvs_alloc;
335};
336
337/* The size of the maximum gap between one aligned stack and the next. */
338# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
339
340/* The size of an array large to enough to hold all stacks, each with
341 N elements. */
342# define YYSTACK_BYTES(N) \
343 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
344 + YYSTACK_GAP_MAXIMUM)
345
346# define YYCOPY_NEEDED 1
347
348/* Relocate STACK from its old location to the new one. The
349 local variables YYSIZE and YYSTACKSIZE give the old and new number of
350 elements in the stack, and YYPTR gives the new location of the
351 stack. Advance YYPTR to a properly aligned location for the next
352 stack. */
353# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
354 do \
355 { \
356 YYSIZE_T yynewbytes; \
357 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
358 Stack = &yyptr->Stack_alloc; \
359 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
360 yyptr += yynewbytes / sizeof (*yyptr); \
361 } \
362 while (YYID (0))
363
364#endif
365
366#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
367/* Copy COUNT objects from FROM to TO. The source and destination do
368 not overlap. */
369# ifndef YYCOPY
370# if defined __GNUC__ && 1 < __GNUC__
371# define YYCOPY(To, From, Count) \
372 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
373# else
374# define YYCOPY(To, From, Count) \
375 do \
376 { \
377 YYSIZE_T yyi; \
378 for (yyi = 0; yyi < (Count); yyi++) \
379 (To)[yyi] = (From)[yyi]; \
380 } \
381 while (YYID (0))
382# endif
383# endif
384#endif /* !YYCOPY_NEEDED */
385
386/* YYFINAL -- State number of the termination state. */
387#define YYFINAL 25
388/* YYLAST -- Last index in YYTABLE. */
389#define YYLAST 43
390
391/* YYNTOKENS -- Number of terminals. */
392#define YYNTOKENS 20
393/* YYNNTS -- Number of nonterminals. */
394#define YYNNTS 15
395/* YYNRULES -- Number of rules. */
396#define YYNRULES 35
397/* YYNRULES -- Number of states. */
398#define YYNSTATES 57
399
400/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
401#define YYUNDEFTOK 2
402#define YYMAXUTOK 269
403
404#define YYTRANSLATE(YYX) \
405 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
406
407/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
408static const yytype_uint8 yytranslate[] =
409{
410 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
411 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
412 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
413 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
414 2, 2, 2, 2, 15, 17, 2, 16, 2, 2,
415 2, 2, 2, 2, 2, 2, 2, 2, 18, 2,
416 2, 19, 2, 2, 2, 2, 2, 2, 2, 2,
417 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
418 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
419 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
420 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
421 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
422 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
423 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
424 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
425 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
426 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
429 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
430 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
431 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
432 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
433 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
434 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
435 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
436 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
437};
438
439#if YYDEBUG
440/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
441 YYRHS. */
442static const yytype_uint8 yyprhs[] =
443{
444 0, 0, 3, 7, 9, 12, 14, 16, 18, 21,
445 23, 26, 29, 32, 37, 42, 45, 51, 55, 57,
446 63, 67, 71, 75, 77, 81, 83, 87, 91, 93,
447 97, 99, 101, 102, 104, 106
448};
449
450/* YYRHS -- A `-1'-separated list of the rules' RHS. */
451static const yytype_int8 yyrhs[] =
452{
453 21, 0, -1, 21, 15, 22, -1, 22, -1, 23,
454 8, -1, 23, -1, 24, -1, 25, -1, 26, 33,
455 -1, 27, -1, 28, 33, -1, 29, 33, -1, 30,
456 33, -1, 7, 16, 31, 16, -1, 4, 16, 31,
457 16, -1, 4, 34, -1, 10, 17, 11, 17, 11,
458 -1, 10, 17, 11, -1, 10, -1, 12, 3, 18,
459 9, 33, -1, 12, 3, 33, -1, 7, 18, 7,
460 -1, 3, 18, 3, -1, 5, -1, 31, 15, 32,
461 -1, 32, -1, 7, 19, 7, -1, 7, 19, 3,
462 -1, 7, -1, 6, 19, 3, -1, 6, -1, 18,
463 -1, -1, 16, -1, 18, -1, -1
464};
465
466/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
467static const yytype_uint8 yyrline[] =
468{
469 0, 55, 55, 55, 58, 69, 74, 75, 76, 77,
470 78, 79, 80, 83, 90, 99, 108, 113, 118, 124,
471 129, 135, 141, 147, 153, 163, 175, 184, 193, 202,
472 210, 218, 218, 220, 220, 220
473};
474#endif
475
476#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
477/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
478 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
479static const char *const yytname[] =
480{
481 "$end", "error", "$undefined", "PE_VALUE", "PE_VALUE_SYM", "PE_RAW",
482 "PE_TERM", "PE_NAME", "PE_MODIFIER_EVENT", "PE_MODIFIER_BP",
483 "PE_NAME_CACHE_TYPE", "PE_NAME_CACHE_OP_RESULT", "PE_PREFIX_MEM",
484 "PE_PREFIX_RAW", "PE_ERROR", "','", "'/'", "'-'", "':'", "'='",
485 "$accept", "events", "event", "event_def", "event_pmu",
486 "event_legacy_symbol", "event_legacy_cache", "event_legacy_mem",
487 "event_legacy_tracepoint", "event_legacy_numeric", "event_legacy_raw",
488 "event_config", "event_term", "sep_dc", "sep_slash_dc", 0
489};
490#endif
491
492# ifdef YYPRINT
493/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
494 token YYLEX-NUM. */
495static const yytype_uint16 yytoknum[] =
496{
497 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
498 265, 266, 267, 268, 269, 44, 47, 45, 58, 61
499};
500# endif
501
502/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
503static const yytype_uint8 yyr1[] =
504{
505 0, 20, 21, 21, 22, 22, 23, 23, 23, 23,
506 23, 23, 23, 24, 25, 25, 26, 26, 26, 27,
507 27, 28, 29, 30, 31, 31, 32, 32, 32, 32,
508 32, 33, 33, 34, 34, 34
509};
510
511/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
512static const yytype_uint8 yyr2[] =
513{
514 0, 2, 3, 1, 2, 1, 1, 1, 2, 1,
515 2, 2, 2, 4, 4, 2, 5, 3, 1, 5,
516 3, 3, 3, 1, 3, 1, 3, 3, 1, 3,
517 1, 1, 0, 1, 1, 0
518};
519
520/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
521 Performed when YYTABLE doesn't specify something else to do. Zero
522 means the default is an error. */
523static const yytype_uint8 yydefact[] =
524{
525 0, 0, 35, 23, 0, 18, 0, 0, 3, 5,
526 6, 7, 32, 9, 32, 32, 32, 0, 33, 34,
527 15, 0, 0, 0, 32, 1, 0, 4, 31, 8,
528 10, 11, 12, 22, 30, 28, 0, 25, 0, 21,
529 17, 31, 20, 2, 0, 0, 0, 14, 13, 0,
530 32, 29, 27, 26, 24, 16, 19
531};
532
533/* YYDEFGOTO[NTERM-NUM]. */
534static const yytype_int8 yydefgoto[] =
535{
536 -1, 7, 8, 9, 10, 11, 12, 13, 14, 15,
537 16, 36, 37, 29, 20
538};
539
540/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
541 STATE-NUM. */
542#define YYPACT_NINF -15
543static const yytype_int8 yypact[] =
544{
545 1, -4, -9, -15, -1, 10, 22, 3, -15, 18,
546 -15, -15, 11, -15, 11, 11, 11, 25, 13, -15,
547 -15, 13, 23, 20, 14, -15, 1, -15, -15, -15,
548 -15, -15, -15, -15, 15, 16, 6, -15, 8, -15,
549 21, 24, -15, -15, 34, 9, 13, -15, -15, 28,
550 11, -15, -15, -15, -15, -15, -15
551};
552
553/* YYPGOTO[NTERM-NUM]. */
554static const yytype_int8 yypgoto[] =
555{
556 -15, -15, 17, -15, -15, -15, -15, -15, -15, -15,
557 -15, 19, -5, -14, -15
558};
559
560/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
561 positive, shift that token. If negative, reduce the rule which
562 number is the opposite. If YYTABLE_NINF, syntax error. */
563#define YYTABLE_NINF -1
564static const yytype_uint8 yytable[] =
565{
566 30, 31, 32, 25, 1, 2, 3, 18, 4, 19,
567 42, 5, 52, 6, 17, 21, 53, 22, 26, 34,
568 35, 46, 47, 46, 48, 24, 27, 23, 33, 28,
569 39, 40, 41, 50, 44, 45, 56, 51, 49, 55,
570 38, 54, 0, 43
571};
572
573#define yypact_value_is_default(yystate) \
574 ((yystate) == (-15))
575
576#define yytable_value_is_error(yytable_value) \
577 YYID (0)
578
579static const yytype_int8 yycheck[] =
580{
581 14, 15, 16, 0, 3, 4, 5, 16, 7, 18,
582 24, 10, 3, 12, 18, 16, 7, 18, 15, 6,
583 7, 15, 16, 15, 16, 3, 8, 17, 3, 18,
584 7, 11, 18, 9, 19, 19, 50, 3, 17, 11,
585 21, 46, -1, 26
586};
587
588/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
589 symbol of state STATE-NUM. */
590static const yytype_uint8 yystos[] =
591{
592 0, 3, 4, 5, 7, 10, 12, 21, 22, 23,
593 24, 25, 26, 27, 28, 29, 30, 18, 16, 18,
594 34, 16, 18, 17, 3, 0, 15, 8, 18, 33,
595 33, 33, 33, 3, 6, 7, 31, 32, 31, 7,
596 11, 18, 33, 22, 19, 19, 15, 16, 16, 17,
597 9, 3, 3, 7, 32, 11, 33
598};
599
600#define yyerrok (yyerrstatus = 0)
601#define yyclearin (yychar = YYEMPTY)
602#define YYEMPTY (-2)
603#define YYEOF 0
604
605#define YYACCEPT goto yyacceptlab
606#define YYABORT goto yyabortlab
607#define YYERROR goto yyerrorlab
608
609
610/* Like YYERROR except do call yyerror. This remains here temporarily
611 to ease the transition to the new meaning of YYERROR, for GCC.
612 Once GCC version 2 has supplanted version 1, this can go. However,
613 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
614 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
615 discussed. */
616
617#define YYFAIL goto yyerrlab
618#if defined YYFAIL
619 /* This is here to suppress warnings from the GCC cpp's
620 -Wunused-macros. Normally we don't worry about that warning, but
621 some users do, and we want to make it easy for users to remove
622 YYFAIL uses, which will produce warnings from Bison 2.5. */
623#endif
624
625#define YYRECOVERING() (!!yyerrstatus)
626
627#define YYBACKUP(Token, Value) \
628do \
629 if (yychar == YYEMPTY && yylen == 1) \
630 { \
631 yychar = (Token); \
632 yylval = (Value); \
633 YYPOPSTACK (1); \
634 goto yybackup; \
635 } \
636 else \
637 { \
638 yyerror (list_all, list_event, idx, YY_("syntax error: cannot back up")); \
639 YYERROR; \
640 } \
641while (YYID (0))
642
643
644#define YYTERROR 1
645#define YYERRCODE 256
646
647
648/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
649 If N is 0, then set CURRENT to the empty location which ends
650 the previous symbol: RHS[0] (always defined). */
651
652#define YYRHSLOC(Rhs, K) ((Rhs)[K])
653#ifndef YYLLOC_DEFAULT
654# define YYLLOC_DEFAULT(Current, Rhs, N) \
655 do \
656 if (YYID (N)) \
657 { \
658 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
659 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
660 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
661 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
662 } \
663 else \
664 { \
665 (Current).first_line = (Current).last_line = \
666 YYRHSLOC (Rhs, 0).last_line; \
667 (Current).first_column = (Current).last_column = \
668 YYRHSLOC (Rhs, 0).last_column; \
669 } \
670 while (YYID (0))
671#endif
672
673
674/* This macro is provided for backward compatibility. */
675
676#ifndef YY_LOCATION_PRINT
677# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
678#endif
679
680
681/* YYLEX -- calling `yylex' with the right arguments. */
682
683#ifdef YYLEX_PARAM
684# define YYLEX yylex (YYLEX_PARAM)
685#else
686# define YYLEX yylex ()
687#endif
688
689/* Enable debugging if requested. */
690#if YYDEBUG
691
692# ifndef YYFPRINTF
693# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
694# define YYFPRINTF fprintf
695# endif
696
697# define YYDPRINTF(Args) \
698do { \
699 if (yydebug) \
700 YYFPRINTF Args; \
701} while (YYID (0))
702
703# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
704do { \
705 if (yydebug) \
706 { \
707 YYFPRINTF (stderr, "%s ", Title); \
708 yy_symbol_print (stderr, \
709 Type, Value, list_all, list_event, idx); \
710 YYFPRINTF (stderr, "\n"); \
711 } \
712} while (YYID (0))
713
714
715/*--------------------------------.
716| Print this symbol on YYOUTPUT. |
717`--------------------------------*/
718
719/*ARGSUSED*/
720#if (defined __STDC__ || defined __C99__FUNC__ \
721 || defined __cplusplus || defined _MSC_VER)
722static void
723yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *list_all, struct list_head *list_event, int *idx)
724#else
725static void
726yy_symbol_value_print (yyoutput, yytype, yyvaluep, list_all, list_event, idx)
727 FILE *yyoutput;
728 int yytype;
729 YYSTYPE const * const yyvaluep;
730 struct list_head *list_all;
731 struct list_head *list_event;
732 int *idx;
733#endif
734{
735 if (!yyvaluep)
736 return;
737 YYUSE (list_all);
738 YYUSE (list_event);
739 YYUSE (idx);
740# ifdef YYPRINT
741 if (yytype < YYNTOKENS)
742 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
743# else
744 YYUSE (yyoutput);
745# endif
746 switch (yytype)
747 {
748 default:
749 break;
750 }
751}
752
753
754/*--------------------------------.
755| Print this symbol on YYOUTPUT. |
756`--------------------------------*/
757
758#if (defined __STDC__ || defined __C99__FUNC__ \
759 || defined __cplusplus || defined _MSC_VER)
760static void
761yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *list_all, struct list_head *list_event, int *idx)
762#else
763static void
764yy_symbol_print (yyoutput, yytype, yyvaluep, list_all, list_event, idx)
765 FILE *yyoutput;
766 int yytype;
767 YYSTYPE const * const yyvaluep;
768 struct list_head *list_all;
769 struct list_head *list_event;
770 int *idx;
771#endif
772{
773 if (yytype < YYNTOKENS)
774 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
775 else
776 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
777
778 yy_symbol_value_print (yyoutput, yytype, yyvaluep, list_all, list_event, idx);
779 YYFPRINTF (yyoutput, ")");
780}
781
782/*------------------------------------------------------------------.
783| yy_stack_print -- Print the state stack from its BOTTOM up to its |
784| TOP (included). |
785`------------------------------------------------------------------*/
786
787#if (defined __STDC__ || defined __C99__FUNC__ \
788 || defined __cplusplus || defined _MSC_VER)
789static void
790yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
791#else
792static void
793yy_stack_print (yybottom, yytop)
794 yytype_int16 *yybottom;
795 yytype_int16 *yytop;
796#endif
797{
798 YYFPRINTF (stderr, "Stack now");
799 for (; yybottom <= yytop; yybottom++)
800 {
801 int yybot = *yybottom;
802 YYFPRINTF (stderr, " %d", yybot);
803 }
804 YYFPRINTF (stderr, "\n");
805}
806
807# define YY_STACK_PRINT(Bottom, Top) \
808do { \
809 if (yydebug) \
810 yy_stack_print ((Bottom), (Top)); \
811} while (YYID (0))
812
813
814/*------------------------------------------------.
815| Report that the YYRULE is going to be reduced. |
816`------------------------------------------------*/
817
818#if (defined __STDC__ || defined __C99__FUNC__ \
819 || defined __cplusplus || defined _MSC_VER)
820static void
821yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct list_head *list_all, struct list_head *list_event, int *idx)
822#else
823static void
824yy_reduce_print (yyvsp, yyrule, list_all, list_event, idx)
825 YYSTYPE *yyvsp;
826 int yyrule;
827 struct list_head *list_all;
828 struct list_head *list_event;
829 int *idx;
830#endif
831{
832 int yynrhs = yyr2[yyrule];
833 int yyi;
834 unsigned long int yylno = yyrline[yyrule];
835 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
836 yyrule - 1, yylno);
837 /* The symbols being reduced. */
838 for (yyi = 0; yyi < yynrhs; yyi++)
839 {
840 YYFPRINTF (stderr, " $%d = ", yyi + 1);
841 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
842 &(yyvsp[(yyi + 1) - (yynrhs)])
843 , list_all, list_event, idx);
844 YYFPRINTF (stderr, "\n");
845 }
846}
847
848# define YY_REDUCE_PRINT(Rule) \
849do { \
850 if (yydebug) \
851 yy_reduce_print (yyvsp, Rule, list_all, list_event, idx); \
852} while (YYID (0))
853
854/* Nonzero means print parse trace. It is left uninitialized so that
855 multiple parsers can coexist. */
856int yydebug;
857#else /* !YYDEBUG */
858# define YYDPRINTF(Args)
859# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
860# define YY_STACK_PRINT(Bottom, Top)
861# define YY_REDUCE_PRINT(Rule)
862#endif /* !YYDEBUG */
863
864
865/* YYINITDEPTH -- initial size of the parser's stacks. */
866#ifndef YYINITDEPTH
867# define YYINITDEPTH 200
868#endif
869
870/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
871 if the built-in stack extension method is used).
872
873 Do not make this value too large; the results are undefined if
874 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
875 evaluated with infinite-precision integer arithmetic. */
876
877#ifndef YYMAXDEPTH
878# define YYMAXDEPTH 10000
879#endif
880
881
882#if YYERROR_VERBOSE
883
884# ifndef yystrlen
885# if defined __GLIBC__ && defined _STRING_H
886# define yystrlen strlen
887# else
888/* Return the length of YYSTR. */
889#if (defined __STDC__ || defined __C99__FUNC__ \
890 || defined __cplusplus || defined _MSC_VER)
891static YYSIZE_T
892yystrlen (const char *yystr)
893#else
894static YYSIZE_T
895yystrlen (yystr)
896 const char *yystr;
897#endif
898{
899 YYSIZE_T yylen;
900 for (yylen = 0; yystr[yylen]; yylen++)
901 continue;
902 return yylen;
903}
904# endif
905# endif
906
907# ifndef yystpcpy
908# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
909# define yystpcpy stpcpy
910# else
911/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
912 YYDEST. */
913#if (defined __STDC__ || defined __C99__FUNC__ \
914 || defined __cplusplus || defined _MSC_VER)
915static char *
916yystpcpy (char *yydest, const char *yysrc)
917#else
918static char *
919yystpcpy (yydest, yysrc)
920 char *yydest;
921 const char *yysrc;
922#endif
923{
924 char *yyd = yydest;
925 const char *yys = yysrc;
926
927 while ((*yyd++ = *yys++) != '\0')
928 continue;
929
930 return yyd - 1;
931}
932# endif
933# endif
934
935# ifndef yytnamerr
936/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
937 quotes and backslashes, so that it's suitable for yyerror. The
938 heuristic is that double-quoting is unnecessary unless the string
939 contains an apostrophe, a comma, or backslash (other than
940 backslash-backslash). YYSTR is taken from yytname. If YYRES is
941 null, do not copy; instead, return the length of what the result
942 would have been. */
943static YYSIZE_T
944yytnamerr (char *yyres, const char *yystr)
945{
946 if (*yystr == '"')
947 {
948 YYSIZE_T yyn = 0;
949 char const *yyp = yystr;
950
951 for (;;)
952 switch (*++yyp)
953 {
954 case '\'':
955 case ',':
956 goto do_not_strip_quotes;
957
958 case '\\':
959 if (*++yyp != '\\')
960 goto do_not_strip_quotes;
961 /* Fall through. */
962 default:
963 if (yyres)
964 yyres[yyn] = *yyp;
965 yyn++;
966 break;
967
968 case '"':
969 if (yyres)
970 yyres[yyn] = '\0';
971 return yyn;
972 }
973 do_not_strip_quotes: ;
974 }
975
976 if (! yyres)
977 return yystrlen (yystr);
978
979 return yystpcpy (yyres, yystr) - yyres;
980}
981# endif
982
983/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
984 about the unexpected token YYTOKEN for the state stack whose top is
985 YYSSP.
986
987 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
988 not large enough to hold the message. In that case, also set
989 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
990 required number of bytes is too large to store. */
991static int
992yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
993 yytype_int16 *yyssp, int yytoken)
994{
995 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
996 YYSIZE_T yysize = yysize0;
997 YYSIZE_T yysize1;
998 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
999 /* Internationalized format string. */
1000 const char *yyformat = 0;
1001 /* Arguments of yyformat. */
1002 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1003 /* Number of reported tokens (one for the "unexpected", one per
1004 "expected"). */
1005 int yycount = 0;
1006
1007 /* There are many possibilities here to consider:
1008 - Assume YYFAIL is not used. It's too flawed to consider. See
1009 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1010 for details. YYERROR is fine as it does not invoke this
1011 function.
1012 - If this state is a consistent state with a default action, then
1013 the only way this function was invoked is if the default action
1014 is an error action. In that case, don't check for expected
1015 tokens because there are none.
1016 - The only way there can be no lookahead present (in yychar) is if
1017 this state is a consistent state with a default action. Thus,
1018 detecting the absence of a lookahead is sufficient to determine
1019 that there is no unexpected or expected token to report. In that
1020 case, just report a simple "syntax error".
1021 - Don't assume there isn't a lookahead just because this state is a
1022 consistent state with a default action. There might have been a
1023 previous inconsistent state, consistent state with a non-default
1024 action, or user semantic action that manipulated yychar.
1025 - Of course, the expected token list depends on states to have
1026 correct lookahead information, and it depends on the parser not
1027 to perform extra reductions after fetching a lookahead from the
1028 scanner and before detecting a syntax error. Thus, state merging
1029 (from LALR or IELR) and default reductions corrupt the expected
1030 token list. However, the list is correct for canonical LR with
1031 one exception: it will still contain any token that will not be
1032 accepted due to an error action in a later state.
1033 */
1034 if (yytoken != YYEMPTY)
1035 {
1036 int yyn = yypact[*yyssp];
1037 yyarg[yycount++] = yytname[yytoken];
1038 if (!yypact_value_is_default (yyn))
1039 {
1040 /* Start YYX at -YYN if negative to avoid negative indexes in
1041 YYCHECK. In other words, skip the first -YYN actions for
1042 this state because they are default actions. */
1043 int yyxbegin = yyn < 0 ? -yyn : 0;
1044 /* Stay within bounds of both yycheck and yytname. */
1045 int yychecklim = YYLAST - yyn + 1;
1046 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1047 int yyx;
1048
1049 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1050 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1051 && !yytable_value_is_error (yytable[yyx + yyn]))
1052 {
1053 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1054 {
1055 yycount = 1;
1056 yysize = yysize0;
1057 break;
1058 }
1059 yyarg[yycount++] = yytname[yyx];
1060 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1061 if (! (yysize <= yysize1
1062 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1063 return 2;
1064 yysize = yysize1;
1065 }
1066 }
1067 }
1068
1069 switch (yycount)
1070 {
1071# define YYCASE_(N, S) \
1072 case N: \
1073 yyformat = S; \
1074 break
1075 YYCASE_(0, YY_("syntax error"));
1076 YYCASE_(1, YY_("syntax error, unexpected %s"));
1077 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1078 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1079 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1080 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1081# undef YYCASE_
1082 }
1083
1084 yysize1 = yysize + yystrlen (yyformat);
1085 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1086 return 2;
1087 yysize = yysize1;
1088
1089 if (*yymsg_alloc < yysize)
1090 {
1091 *yymsg_alloc = 2 * yysize;
1092 if (! (yysize <= *yymsg_alloc
1093 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1094 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1095 return 1;
1096 }
1097
1098 /* Avoid sprintf, as that infringes on the user's name space.
1099 Don't have undefined behavior even if the translation
1100 produced a string with the wrong number of "%s"s. */
1101 {
1102 char *yyp = *yymsg;
1103 int yyi = 0;
1104 while ((*yyp = *yyformat) != '\0')
1105 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1106 {
1107 yyp += yytnamerr (yyp, yyarg[yyi++]);
1108 yyformat += 2;
1109 }
1110 else
1111 {
1112 yyp++;
1113 yyformat++;
1114 }
1115 }
1116 return 0;
1117}
1118#endif /* YYERROR_VERBOSE */
1119
1120/*-----------------------------------------------.
1121| Release the memory associated to this symbol. |
1122`-----------------------------------------------*/
1123
1124/*ARGSUSED*/
1125#if (defined __STDC__ || defined __C99__FUNC__ \
1126 || defined __cplusplus || defined _MSC_VER)
1127static void
1128yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct list_head *list_all, struct list_head *list_event, int *idx)
1129#else
1130static void
1131yydestruct (yymsg, yytype, yyvaluep, list_all, list_event, idx)
1132 const char *yymsg;
1133 int yytype;
1134 YYSTYPE *yyvaluep;
1135 struct list_head *list_all;
1136 struct list_head *list_event;
1137 int *idx;
1138#endif
1139{
1140 YYUSE (yyvaluep);
1141 YYUSE (list_all);
1142 YYUSE (list_event);
1143 YYUSE (idx);
1144
1145 if (!yymsg)
1146 yymsg = "Deleting";
1147 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1148
1149 switch (yytype)
1150 {
1151
1152 default:
1153 break;
1154 }
1155}
1156
1157
1158/* Prevent warnings from -Wmissing-prototypes. */
1159#ifdef YYPARSE_PARAM
1160#if defined __STDC__ || defined __cplusplus
1161int yyparse (void *YYPARSE_PARAM);
1162#else
1163int yyparse ();
1164#endif
1165#else /* ! YYPARSE_PARAM */
1166#if defined __STDC__ || defined __cplusplus
1167int yyparse (struct list_head *list_all, struct list_head *list_event, int *idx);
1168#else
1169int yyparse ();
1170#endif
1171#endif /* ! YYPARSE_PARAM */
1172
1173
1174/* The lookahead symbol. */
1175int yychar;
1176
1177/* The semantic value of the lookahead symbol. */
1178YYSTYPE yylval;
1179
1180/* Number of syntax errors so far. */
1181int yynerrs;
1182
1183
1184/*----------.
1185| yyparse. |
1186`----------*/
1187
1188#ifdef YYPARSE_PARAM
1189#if (defined __STDC__ || defined __C99__FUNC__ \
1190 || defined __cplusplus || defined _MSC_VER)
1191int
1192yyparse (void *YYPARSE_PARAM)
1193#else
1194int
1195yyparse (YYPARSE_PARAM)
1196 void *YYPARSE_PARAM;
1197#endif
1198#else /* ! YYPARSE_PARAM */
1199#if (defined __STDC__ || defined __C99__FUNC__ \
1200 || defined __cplusplus || defined _MSC_VER)
1201int
1202yyparse (struct list_head *list_all, struct list_head *list_event, int *idx)
1203#else
1204int
1205yyparse (list_all, list_event, idx)
1206 struct list_head *list_all;
1207 struct list_head *list_event;
1208 int *idx;
1209#endif
1210#endif
1211{
1212 int yystate;
1213 /* Number of tokens to shift before error messages enabled. */
1214 int yyerrstatus;
1215
1216 /* The stacks and their tools:
1217 `yyss': related to states.
1218 `yyvs': related to semantic values.
1219
1220 Refer to the stacks thru separate pointers, to allow yyoverflow
1221 to reallocate them elsewhere. */
1222
1223 /* The state stack. */
1224 yytype_int16 yyssa[YYINITDEPTH];
1225 yytype_int16 *yyss;
1226 yytype_int16 *yyssp;
1227
1228 /* The semantic value stack. */
1229 YYSTYPE yyvsa[YYINITDEPTH];
1230 YYSTYPE *yyvs;
1231 YYSTYPE *yyvsp;
1232
1233 YYSIZE_T yystacksize;
1234
1235 int yyn;
1236 int yyresult;
1237 /* Lookahead token as an internal (translated) token number. */
1238 int yytoken;
1239 /* The variables used to return semantic value and location from the
1240 action routines. */
1241 YYSTYPE yyval;
1242
1243#if YYERROR_VERBOSE
1244 /* Buffer for error messages, and its allocated size. */
1245 char yymsgbuf[128];
1246 char *yymsg = yymsgbuf;
1247 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1248#endif
1249
1250#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1251
1252 /* The number of symbols on the RHS of the reduced rule.
1253 Keep to zero when no symbol should be popped. */
1254 int yylen = 0;
1255
1256 yytoken = 0;
1257 yyss = yyssa;
1258 yyvs = yyvsa;
1259 yystacksize = YYINITDEPTH;
1260
1261 YYDPRINTF ((stderr, "Starting parse\n"));
1262
1263 yystate = 0;
1264 yyerrstatus = 0;
1265 yynerrs = 0;
1266 yychar = YYEMPTY; /* Cause a token to be read. */
1267
1268 /* Initialize stack pointers.
1269 Waste one element of value and location stack
1270 so that they stay on the same level as the state stack.
1271 The wasted elements are never initialized. */
1272 yyssp = yyss;
1273 yyvsp = yyvs;
1274
1275 goto yysetstate;
1276
1277/*------------------------------------------------------------.
1278| yynewstate -- Push a new state, which is found in yystate. |
1279`------------------------------------------------------------*/
1280 yynewstate:
1281 /* In all cases, when you get here, the value and location stacks
1282 have just been pushed. So pushing a state here evens the stacks. */
1283 yyssp++;
1284
1285 yysetstate:
1286 *yyssp = yystate;
1287
1288 if (yyss + yystacksize - 1 <= yyssp)
1289 {
1290 /* Get the current used size of the three stacks, in elements. */
1291 YYSIZE_T yysize = yyssp - yyss + 1;
1292
1293#ifdef yyoverflow
1294 {
1295 /* Give user a chance to reallocate the stack. Use copies of
1296 these so that the &'s don't force the real ones into
1297 memory. */
1298 YYSTYPE *yyvs1 = yyvs;
1299 yytype_int16 *yyss1 = yyss;
1300
1301 /* Each stack pointer address is followed by the size of the
1302 data in use in that stack, in bytes. This used to be a
1303 conditional around just the two extra args, but that might
1304 be undefined if yyoverflow is a macro. */
1305 yyoverflow (YY_("memory exhausted"),
1306 &yyss1, yysize * sizeof (*yyssp),
1307 &yyvs1, yysize * sizeof (*yyvsp),
1308 &yystacksize);
1309
1310 yyss = yyss1;
1311 yyvs = yyvs1;
1312 }
1313#else /* no yyoverflow */
1314# ifndef YYSTACK_RELOCATE
1315 goto yyexhaustedlab;
1316# else
1317 /* Extend the stack our own way. */
1318 if (YYMAXDEPTH <= yystacksize)
1319 goto yyexhaustedlab;
1320 yystacksize *= 2;
1321 if (YYMAXDEPTH < yystacksize)
1322 yystacksize = YYMAXDEPTH;
1323
1324 {
1325 yytype_int16 *yyss1 = yyss;
1326 union yyalloc *yyptr =
1327 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1328 if (! yyptr)
1329 goto yyexhaustedlab;
1330 YYSTACK_RELOCATE (yyss_alloc, yyss);
1331 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1332# undef YYSTACK_RELOCATE
1333 if (yyss1 != yyssa)
1334 YYSTACK_FREE (yyss1);
1335 }
1336# endif
1337#endif /* no yyoverflow */
1338
1339 yyssp = yyss + yysize - 1;
1340 yyvsp = yyvs + yysize - 1;
1341
1342 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1343 (unsigned long int) yystacksize));
1344
1345 if (yyss + yystacksize - 1 <= yyssp)
1346 YYABORT;
1347 }
1348
1349 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1350
1351 if (yystate == YYFINAL)
1352 YYACCEPT;
1353
1354 goto yybackup;
1355
1356/*-----------.
1357| yybackup. |
1358`-----------*/
1359yybackup:
1360
1361 /* Do appropriate processing given the current state. Read a
1362 lookahead token if we need one and don't already have one. */
1363
1364 /* First try to decide what to do without reference to lookahead token. */
1365 yyn = yypact[yystate];
1366 if (yypact_value_is_default (yyn))
1367 goto yydefault;
1368
1369 /* Not known => get a lookahead token if don't already have one. */
1370
1371 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1372 if (yychar == YYEMPTY)
1373 {
1374 YYDPRINTF ((stderr, "Reading a token: "));
1375 yychar = YYLEX;
1376 }
1377
1378 if (yychar <= YYEOF)
1379 {
1380 yychar = yytoken = YYEOF;
1381 YYDPRINTF ((stderr, "Now at end of input.\n"));
1382 }
1383 else
1384 {
1385 yytoken = YYTRANSLATE (yychar);
1386 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1387 }
1388
1389 /* If the proper action on seeing token YYTOKEN is to reduce or to
1390 detect an error, take that action. */
1391 yyn += yytoken;
1392 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1393 goto yydefault;
1394 yyn = yytable[yyn];
1395 if (yyn <= 0)
1396 {
1397 if (yytable_value_is_error (yyn))
1398 goto yyerrlab;
1399 yyn = -yyn;
1400 goto yyreduce;
1401 }
1402
1403 /* Count tokens shifted since error; after three, turn off error
1404 status. */
1405 if (yyerrstatus)
1406 yyerrstatus--;
1407
1408 /* Shift the lookahead token. */
1409 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1410
1411 /* Discard the shifted token. */
1412 yychar = YYEMPTY;
1413
1414 yystate = yyn;
1415 *++yyvsp = yylval;
1416
1417 goto yynewstate;
1418
1419
1420/*-----------------------------------------------------------.
1421| yydefault -- do the default action for the current state. |
1422`-----------------------------------------------------------*/
1423yydefault:
1424 yyn = yydefact[yystate];
1425 if (yyn == 0)
1426 goto yyerrlab;
1427 goto yyreduce;
1428
1429
1430/*-----------------------------.
1431| yyreduce -- Do a reduction. |
1432`-----------------------------*/
1433yyreduce:
1434 /* yyn is the number of a rule to reduce with. */
1435 yylen = yyr2[yyn];
1436
1437 /* If YYLEN is nonzero, implement the default value of the action:
1438 `$$ = $1'.
1439
1440 Otherwise, the following line sets YYVAL to garbage.
1441 This behavior is undocumented and Bison
1442 users should not rely upon it. Assigning to YYVAL
1443 unconditionally makes the parser a bit smaller, and it avoids a
1444 GCC warning that YYVAL may be used uninitialized. */
1445 yyval = yyvsp[1-yylen];
1446
1447
1448 YY_REDUCE_PRINT (yyn);
1449 switch (yyn)
1450 {
1451 case 4:
1452
1453/* Line 1806 of yacc.c */
1454#line 59 "util/parse-events.y"
1455 {
1456 /*
1457 * Apply modifier on all events added by single event definition
1458 * (there could be more events added for multiple tracepoint
1459 * definitions via '*?'.
1460 */
1461 ABORT_ON(parse_events_modifier(list_event, (yyvsp[(2) - (2)].str)));
1462 parse_events_update_lists(list_event, list_all);
1463}
1464 break;
1465
1466 case 5:
1467
1468/* Line 1806 of yacc.c */
1469#line 70 "util/parse-events.y"
1470 {
1471 parse_events_update_lists(list_event, list_all);
1472}
1473 break;
1474
1475 case 13:
1476
1477/* Line 1806 of yacc.c */
1478#line 84 "util/parse-events.y"
1479 {
1480 ABORT_ON(parse_events_add_pmu(list_event, idx, (yyvsp[(1) - (4)].str), (yyvsp[(3) - (4)].head)));
1481 parse_events__free_terms((yyvsp[(3) - (4)].head));
1482}
1483 break;
1484
1485 case 14:
1486
1487/* Line 1806 of yacc.c */
1488#line 91 "util/parse-events.y"
1489 {
1490 int type = (yyvsp[(1) - (4)].num) >> 16;
1491 int config = (yyvsp[(1) - (4)].num) & 255;
1492
1493 ABORT_ON(parse_events_add_numeric(list_event, idx, type, config, (yyvsp[(3) - (4)].head)));
1494 parse_events__free_terms((yyvsp[(3) - (4)].head));
1495}
1496 break;
1497
1498 case 15:
1499
1500/* Line 1806 of yacc.c */
1501#line 100 "util/parse-events.y"
1502 {
1503 int type = (yyvsp[(1) - (2)].num) >> 16;
1504 int config = (yyvsp[(1) - (2)].num) & 255;
1505
1506 ABORT_ON(parse_events_add_numeric(list_event, idx, type, config, NULL));
1507}
1508 break;
1509
1510 case 16:
1511
1512/* Line 1806 of yacc.c */
1513#line 109 "util/parse-events.y"
1514 {
1515 ABORT_ON(parse_events_add_cache(list_event, idx, (yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (yyvsp[(5) - (5)].str)));
1516}
1517 break;
1518
1519 case 17:
1520
1521/* Line 1806 of yacc.c */
1522#line 114 "util/parse-events.y"
1523 {
1524 ABORT_ON(parse_events_add_cache(list_event, idx, (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str), NULL));
1525}
1526 break;
1527
1528 case 18:
1529
1530/* Line 1806 of yacc.c */
1531#line 119 "util/parse-events.y"
1532 {
1533 ABORT_ON(parse_events_add_cache(list_event, idx, (yyvsp[(1) - (1)].str), NULL, NULL));
1534}
1535 break;
1536
1537 case 19:
1538
1539/* Line 1806 of yacc.c */
1540#line 125 "util/parse-events.y"
1541 {
1542 ABORT_ON(parse_events_add_breakpoint(list_event, idx, (void *) (yyvsp[(2) - (5)].num), (yyvsp[(4) - (5)].str)));
1543}
1544 break;
1545
1546 case 20:
1547
1548/* Line 1806 of yacc.c */
1549#line 130 "util/parse-events.y"
1550 {
1551 ABORT_ON(parse_events_add_breakpoint(list_event, idx, (void *) (yyvsp[(2) - (3)].num), NULL));
1552}
1553 break;
1554
1555 case 21:
1556
1557/* Line 1806 of yacc.c */
1558#line 136 "util/parse-events.y"
1559 {
1560 ABORT_ON(parse_events_add_tracepoint(list_event, idx, (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)));
1561}
1562 break;
1563
1564 case 22:
1565
1566/* Line 1806 of yacc.c */
1567#line 142 "util/parse-events.y"
1568 {
1569 ABORT_ON(parse_events_add_numeric(list_event, idx, (yyvsp[(1) - (3)].num), (yyvsp[(3) - (3)].num), NULL));
1570}
1571 break;
1572
1573 case 23:
1574
1575/* Line 1806 of yacc.c */
1576#line 148 "util/parse-events.y"
1577 {
1578 ABORT_ON(parse_events_add_numeric(list_event, idx, PERF_TYPE_RAW, (yyvsp[(1) - (1)].num), NULL));
1579}
1580 break;
1581
1582 case 24:
1583
1584/* Line 1806 of yacc.c */
1585#line 154 "util/parse-events.y"
1586 {
1587 struct list_head *head = (yyvsp[(1) - (3)].head);
1588 struct parse_events__term *term = (yyvsp[(3) - (3)].term);
1589
1590 ABORT_ON(!head);
1591 list_add_tail(&term->list, head);
1592 (yyval.head) = (yyvsp[(1) - (3)].head);
1593}
1594 break;
1595
1596 case 25:
1597
1598/* Line 1806 of yacc.c */
1599#line 164 "util/parse-events.y"
1600 {
1601 struct list_head *head = malloc(sizeof(*head));
1602 struct parse_events__term *term = (yyvsp[(1) - (1)].term);
1603
1604 ABORT_ON(!head);
1605 INIT_LIST_HEAD(head);
1606 list_add_tail(&term->list, head);
1607 (yyval.head) = head;
1608}
1609 break;
1610
1611 case 26:
1612
1613/* Line 1806 of yacc.c */
1614#line 176 "util/parse-events.y"
1615 {
1616 struct parse_events__term *term;
1617
1618 ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_STR,
1619 (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str), 0));
1620 (yyval.term) = term;
1621}
1622 break;
1623
1624 case 27:
1625
1626/* Line 1806 of yacc.c */
1627#line 185 "util/parse-events.y"
1628 {
1629 struct parse_events__term *term;
1630
1631 ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
1632 (yyvsp[(1) - (3)].str), NULL, (yyvsp[(3) - (3)].num)));
1633 (yyval.term) = term;
1634}
1635 break;
1636
1637 case 28:
1638
1639/* Line 1806 of yacc.c */
1640#line 194 "util/parse-events.y"
1641 {
1642 struct parse_events__term *term;
1643
1644 ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
1645 (yyvsp[(1) - (1)].str), NULL, 1));
1646 (yyval.term) = term;
1647}
1648 break;
1649
1650 case 29:
1651
1652/* Line 1806 of yacc.c */
1653#line 203 "util/parse-events.y"
1654 {
1655 struct parse_events__term *term;
1656
1657 ABORT_ON(parse_events__new_term(&term, (yyvsp[(1) - (3)].num), NULL, NULL, (yyvsp[(3) - (3)].num)));
1658 (yyval.term) = term;
1659}
1660 break;
1661
1662 case 30:
1663
1664/* Line 1806 of yacc.c */
1665#line 211 "util/parse-events.y"
1666 {
1667 struct parse_events__term *term;
1668
1669 ABORT_ON(parse_events__new_term(&term, (yyvsp[(1) - (1)].num), NULL, NULL, 1));
1670 (yyval.term) = term;
1671}
1672 break;
1673
1674
1675
1676/* Line 1806 of yacc.c */
1677#line 1678 "util/parse-events-bison.c"
1678 default: break;
1679 }
1680 /* User semantic actions sometimes alter yychar, and that requires
1681 that yytoken be updated with the new translation. We take the
1682 approach of translating immediately before every use of yytoken.
1683 One alternative is translating here after every semantic action,
1684 but that translation would be missed if the semantic action invokes
1685 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1686 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1687 incorrect destructor might then be invoked immediately. In the
1688 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1689 to an incorrect destructor call or verbose syntax error message
1690 before the lookahead is translated. */
1691 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1692
1693 YYPOPSTACK (yylen);
1694 yylen = 0;
1695 YY_STACK_PRINT (yyss, yyssp);
1696
1697 *++yyvsp = yyval;
1698
1699 /* Now `shift' the result of the reduction. Determine what state
1700 that goes to, based on the state we popped back to and the rule
1701 number reduced by. */
1702
1703 yyn = yyr1[yyn];
1704
1705 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1706 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1707 yystate = yytable[yystate];
1708 else
1709 yystate = yydefgoto[yyn - YYNTOKENS];
1710
1711 goto yynewstate;
1712
1713
1714/*------------------------------------.
1715| yyerrlab -- here on detecting error |
1716`------------------------------------*/
1717yyerrlab:
1718 /* Make sure we have latest lookahead translation. See comments at
1719 user semantic actions for why this is necessary. */
1720 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1721
1722 /* If not already recovering from an error, report this error. */
1723 if (!yyerrstatus)
1724 {
1725 ++yynerrs;
1726#if ! YYERROR_VERBOSE
1727 yyerror (list_all, list_event, idx, YY_("syntax error"));
1728#else
1729# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1730 yyssp, yytoken)
1731 {
1732 char const *yymsgp = YY_("syntax error");
1733 int yysyntax_error_status;
1734 yysyntax_error_status = YYSYNTAX_ERROR;
1735 if (yysyntax_error_status == 0)
1736 yymsgp = yymsg;
1737 else if (yysyntax_error_status == 1)
1738 {
1739 if (yymsg != yymsgbuf)
1740 YYSTACK_FREE (yymsg);
1741 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1742 if (!yymsg)
1743 {
1744 yymsg = yymsgbuf;
1745 yymsg_alloc = sizeof yymsgbuf;
1746 yysyntax_error_status = 2;
1747 }
1748 else
1749 {
1750 yysyntax_error_status = YYSYNTAX_ERROR;
1751 yymsgp = yymsg;
1752 }
1753 }
1754 yyerror (list_all, list_event, idx, yymsgp);
1755 if (yysyntax_error_status == 2)
1756 goto yyexhaustedlab;
1757 }
1758# undef YYSYNTAX_ERROR
1759#endif
1760 }
1761
1762
1763
1764 if (yyerrstatus == 3)
1765 {
1766 /* If just tried and failed to reuse lookahead token after an
1767 error, discard it. */
1768
1769 if (yychar <= YYEOF)
1770 {
1771 /* Return failure if at end of input. */
1772 if (yychar == YYEOF)
1773 YYABORT;
1774 }
1775 else
1776 {
1777 yydestruct ("Error: discarding",
1778 yytoken, &yylval, list_all, list_event, idx);
1779 yychar = YYEMPTY;
1780 }
1781 }
1782
1783 /* Else will try to reuse lookahead token after shifting the error
1784 token. */
1785 goto yyerrlab1;
1786
1787
1788/*---------------------------------------------------.
1789| yyerrorlab -- error raised explicitly by YYERROR. |
1790`---------------------------------------------------*/
1791yyerrorlab:
1792
1793 /* Pacify compilers like GCC when the user code never invokes
1794 YYERROR and the label yyerrorlab therefore never appears in user
1795 code. */
1796 if (/*CONSTCOND*/ 0)
1797 goto yyerrorlab;
1798
1799 /* Do not reclaim the symbols of the rule which action triggered
1800 this YYERROR. */
1801 YYPOPSTACK (yylen);
1802 yylen = 0;
1803 YY_STACK_PRINT (yyss, yyssp);
1804 yystate = *yyssp;
1805 goto yyerrlab1;
1806
1807
1808/*-------------------------------------------------------------.
1809| yyerrlab1 -- common code for both syntax error and YYERROR. |
1810`-------------------------------------------------------------*/
1811yyerrlab1:
1812 yyerrstatus = 3; /* Each real token shifted decrements this. */
1813
1814 for (;;)
1815 {
1816 yyn = yypact[yystate];
1817 if (!yypact_value_is_default (yyn))
1818 {
1819 yyn += YYTERROR;
1820 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1821 {
1822 yyn = yytable[yyn];
1823 if (0 < yyn)
1824 break;
1825 }
1826 }
1827
1828 /* Pop the current state because it cannot handle the error token. */
1829 if (yyssp == yyss)
1830 YYABORT;
1831
1832
1833 yydestruct ("Error: popping",
1834 yystos[yystate], yyvsp, list_all, list_event, idx);
1835 YYPOPSTACK (1);
1836 yystate = *yyssp;
1837 YY_STACK_PRINT (yyss, yyssp);
1838 }
1839
1840 *++yyvsp = yylval;
1841
1842
1843 /* Shift the error token. */
1844 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1845
1846 yystate = yyn;
1847 goto yynewstate;
1848
1849
1850/*-------------------------------------.
1851| yyacceptlab -- YYACCEPT comes here. |
1852`-------------------------------------*/
1853yyacceptlab:
1854 yyresult = 0;
1855 goto yyreturn;
1856
1857/*-----------------------------------.
1858| yyabortlab -- YYABORT comes here. |
1859`-----------------------------------*/
1860yyabortlab:
1861 yyresult = 1;
1862 goto yyreturn;
1863
1864#if !defined(yyoverflow) || YYERROR_VERBOSE
1865/*-------------------------------------------------.
1866| yyexhaustedlab -- memory exhaustion comes here. |
1867`-------------------------------------------------*/
1868yyexhaustedlab:
1869 yyerror (list_all, list_event, idx, YY_("memory exhausted"));
1870 yyresult = 2;
1871 /* Fall through. */
1872#endif
1873
1874yyreturn:
1875 if (yychar != YYEMPTY)
1876 {
1877 /* Make sure we have latest lookahead translation. See comments at
1878 user semantic actions for why this is necessary. */
1879 yytoken = YYTRANSLATE (yychar);
1880 yydestruct ("Cleanup: discarding lookahead",
1881 yytoken, &yylval, list_all, list_event, idx);
1882 }
1883 /* Do not reclaim the symbols of the rule which action triggered
1884 this YYABORT or YYACCEPT. */
1885 YYPOPSTACK (yylen);
1886 YY_STACK_PRINT (yyss, yyssp);
1887 while (yyssp != yyss)
1888 {
1889 yydestruct ("Cleanup: popping",
1890 yystos[*yyssp], yyvsp, list_all, list_event, idx);
1891 YYPOPSTACK (1);
1892 }
1893#ifndef yyoverflow
1894 if (yyss != yyssa)
1895 YYSTACK_FREE (yyss);
1896#endif
1897#if YYERROR_VERBOSE
1898 if (yymsg != yymsgbuf)
1899 YYSTACK_FREE (yymsg);
1900#endif
1901 /* Make sure YYID is used. */
1902 return YYID (yyresult);
1903}
1904
1905
1906
1907/* Line 2067 of yacc.c */
1908#line 222 "util/parse-events.y"
1909
1910
1911void parse_events_error(struct list_head *list_all __used,
1912 struct list_head *list_event __used,
1913 int *idx __used,
1914 char const *msg __used)
1915{
1916}
1917
diff --git a/tools/perf/util/parse-events-bison.h b/tools/perf/util/parse-events-bison.h
deleted file mode 100644
index 0be3e5ae2fed..000000000000
--- a/tools/perf/util/parse-events-bison.h
+++ /dev/null
@@ -1,81 +0,0 @@
1/* A Bison parser, made by GNU Bison 2.5. */
2
3/* Bison interface for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20/* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33
34/* Tokens. */
35#ifndef YYTOKENTYPE
36# define YYTOKENTYPE
37 /* Put the tokens into the symbol table, so that GDB and other debuggers
38 know about them. */
39 enum yytokentype {
40 PE_VALUE = 258,
41 PE_VALUE_SYM = 259,
42 PE_RAW = 260,
43 PE_TERM = 261,
44 PE_NAME = 262,
45 PE_MODIFIER_EVENT = 263,
46 PE_MODIFIER_BP = 264,
47 PE_NAME_CACHE_TYPE = 265,
48 PE_NAME_CACHE_OP_RESULT = 266,
49 PE_PREFIX_MEM = 267,
50 PE_PREFIX_RAW = 268,
51 PE_ERROR = 269
52 };
53#endif
54
55
56
57#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
58typedef union YYSTYPE
59{
60
61/* Line 2068 of yacc.c */
62#line 46 "util/parse-events.y"
63
64 char *str;
65 unsigned long num;
66 struct list_head *head;
67 struct parse_events__term *term;
68
69
70
71/* Line 2068 of yacc.c */
72#line 73 "util/parse-events-bison.h"
73} YYSTYPE;
74# define YYSTYPE_IS_TRIVIAL 1
75# define yystype YYSTYPE /* obsolescent; will be withdrawn */
76# define YYSTYPE_IS_DECLARED 1
77#endif
78
79extern YYSTYPE parse_events_lval;
80
81
diff --git a/tools/perf/util/parse-events-flex.c b/tools/perf/util/parse-events-flex.c
deleted file mode 100644
index 34cfc85c4f79..000000000000
--- a/tools/perf/util/parse-events-flex.c
+++ /dev/null
@@ -1,2272 +0,0 @@
1
2#line 3 "<stdout>"
3
4#define YY_INT_ALIGNED short int
5
6/* A lexical scanner generated by flex */
7
8#define yy_create_buffer parse_events__create_buffer
9#define yy_delete_buffer parse_events__delete_buffer
10#define yy_flex_debug parse_events__flex_debug
11#define yy_init_buffer parse_events__init_buffer
12#define yy_flush_buffer parse_events__flush_buffer
13#define yy_load_buffer_state parse_events__load_buffer_state
14#define yy_switch_to_buffer parse_events__switch_to_buffer
15#define yyin parse_events_in
16#define yyleng parse_events_leng
17#define yylex parse_events_lex
18#define yylineno parse_events_lineno
19#define yyout parse_events_out
20#define yyrestart parse_events_restart
21#define yytext parse_events_text
22#define yywrap parse_events_wrap
23#define yyalloc parse_events_alloc
24#define yyrealloc parse_events_realloc
25#define yyfree parse_events_free
26
27#define FLEX_SCANNER
28#define YY_FLEX_MAJOR_VERSION 2
29#define YY_FLEX_MINOR_VERSION 5
30#define YY_FLEX_SUBMINOR_VERSION 35
31#if YY_FLEX_SUBMINOR_VERSION > 0
32#define FLEX_BETA
33#endif
34
35/* First, we deal with platform-specific or compiler-specific issues. */
36
37/* begin standard C headers. */
38#include <stdio.h>
39#include <string.h>
40#include <errno.h>
41#include <stdlib.h>
42
43/* end standard C headers. */
44
45/* flex integer type definitions */
46
47#ifndef FLEXINT_H
48#define FLEXINT_H
49
50/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
51
52#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
53
54/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
55 * if you want the limit (max/min) macros for int types.
56 */
57#ifndef __STDC_LIMIT_MACROS
58#define __STDC_LIMIT_MACROS 1
59#endif
60
61#include <inttypes.h>
62typedef int8_t flex_int8_t;
63typedef uint8_t flex_uint8_t;
64typedef int16_t flex_int16_t;
65typedef uint16_t flex_uint16_t;
66typedef int32_t flex_int32_t;
67typedef uint32_t flex_uint32_t;
68#else
69typedef signed char flex_int8_t;
70typedef short int flex_int16_t;
71typedef int flex_int32_t;
72typedef unsigned char flex_uint8_t;
73typedef unsigned short int flex_uint16_t;
74typedef unsigned int flex_uint32_t;
75#endif /* ! C99 */
76
77/* Limits of integral types. */
78#ifndef INT8_MIN
79#define INT8_MIN (-128)
80#endif
81#ifndef INT16_MIN
82#define INT16_MIN (-32767-1)
83#endif
84#ifndef INT32_MIN
85#define INT32_MIN (-2147483647-1)
86#endif
87#ifndef INT8_MAX
88#define INT8_MAX (127)
89#endif
90#ifndef INT16_MAX
91#define INT16_MAX (32767)
92#endif
93#ifndef INT32_MAX
94#define INT32_MAX (2147483647)
95#endif
96#ifndef UINT8_MAX
97#define UINT8_MAX (255U)
98#endif
99#ifndef UINT16_MAX
100#define UINT16_MAX (65535U)
101#endif
102#ifndef UINT32_MAX
103#define UINT32_MAX (4294967295U)
104#endif
105
106#endif /* ! FLEXINT_H */
107
108#ifdef __cplusplus
109
110/* The "const" storage-class-modifier is valid. */
111#define YY_USE_CONST
112
113#else /* ! __cplusplus */
114
115/* C99 requires __STDC__ to be defined as 1. */
116#if defined (__STDC__)
117
118#define YY_USE_CONST
119
120#endif /* defined (__STDC__) */
121#endif /* ! __cplusplus */
122
123#ifdef YY_USE_CONST
124#define yyconst const
125#else
126#define yyconst
127#endif
128
129/* Returned upon end-of-file. */
130#define YY_NULL 0
131
132/* Promotes a possibly negative, possibly signed char to an unsigned
133 * integer for use as an array index. If the signed char is negative,
134 * we want to instead treat it as an 8-bit unsigned char, hence the
135 * double cast.
136 */
137#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
138
139/* Enter a start condition. This macro really ought to take a parameter,
140 * but we do it the disgusting crufty way forced on us by the ()-less
141 * definition of BEGIN.
142 */
143#define BEGIN (yy_start) = 1 + 2 *
144
145/* Translate the current start state into a value that can be later handed
146 * to BEGIN to return to the state. The YYSTATE alias is for lex
147 * compatibility.
148 */
149#define YY_START (((yy_start) - 1) / 2)
150#define YYSTATE YY_START
151
152/* Action number for EOF rule of a given start state. */
153#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
154
155/* Special action meaning "start processing a new file". */
156#define YY_NEW_FILE parse_events_restart(parse_events_in )
157
158#define YY_END_OF_BUFFER_CHAR 0
159
160/* Size of default input buffer. */
161#ifndef YY_BUF_SIZE
162#define YY_BUF_SIZE 16384
163#endif
164
165/* The state buf must be large enough to hold one state per character in the main buffer.
166 */
167#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
168
169#ifndef YY_TYPEDEF_YY_BUFFER_STATE
170#define YY_TYPEDEF_YY_BUFFER_STATE
171typedef struct yy_buffer_state *YY_BUFFER_STATE;
172#endif
173
174extern int parse_events_leng;
175
176extern FILE *parse_events_in, *parse_events_out;
177
178#define EOB_ACT_CONTINUE_SCAN 0
179#define EOB_ACT_END_OF_FILE 1
180#define EOB_ACT_LAST_MATCH 2
181
182 #define YY_LESS_LINENO(n)
183
184/* Return all but the first "n" matched characters back to the input stream. */
185#define yyless(n) \
186 do \
187 { \
188 /* Undo effects of setting up parse_events_text. */ \
189 int yyless_macro_arg = (n); \
190 YY_LESS_LINENO(yyless_macro_arg);\
191 *yy_cp = (yy_hold_char); \
192 YY_RESTORE_YY_MORE_OFFSET \
193 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
194 YY_DO_BEFORE_ACTION; /* set up parse_events_text again */ \
195 } \
196 while ( 0 )
197
198#define unput(c) yyunput( c, (yytext_ptr) )
199
200#ifndef YY_TYPEDEF_YY_SIZE_T
201#define YY_TYPEDEF_YY_SIZE_T
202typedef size_t yy_size_t;
203#endif
204
205#ifndef YY_STRUCT_YY_BUFFER_STATE
206#define YY_STRUCT_YY_BUFFER_STATE
207struct yy_buffer_state
208 {
209 FILE *yy_input_file;
210
211 char *yy_ch_buf; /* input buffer */
212 char *yy_buf_pos; /* current position in input buffer */
213
214 /* Size of input buffer in bytes, not including room for EOB
215 * characters.
216 */
217 yy_size_t yy_buf_size;
218
219 /* Number of characters read into yy_ch_buf, not including EOB
220 * characters.
221 */
222 int yy_n_chars;
223
224 /* Whether we "own" the buffer - i.e., we know we created it,
225 * and can realloc() it to grow it, and should free() it to
226 * delete it.
227 */
228 int yy_is_our_buffer;
229
230 /* Whether this is an "interactive" input source; if so, and
231 * if we're using stdio for input, then we want to use getc()
232 * instead of fread(), to make sure we stop fetching input after
233 * each newline.
234 */
235 int yy_is_interactive;
236
237 /* Whether we're considered to be at the beginning of a line.
238 * If so, '^' rules will be active on the next match, otherwise
239 * not.
240 */
241 int yy_at_bol;
242
243 int yy_bs_lineno; /**< The line count. */
244 int yy_bs_column; /**< The column count. */
245
246 /* Whether to try to fill the input buffer when we reach the
247 * end of it.
248 */
249 int yy_fill_buffer;
250
251 int yy_buffer_status;
252
253#define YY_BUFFER_NEW 0
254#define YY_BUFFER_NORMAL 1
255 /* When an EOF's been seen but there's still some text to process
256 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
257 * shouldn't try reading from the input source any more. We might
258 * still have a bunch of tokens to match, though, because of
259 * possible backing-up.
260 *
261 * When we actually see the EOF, we change the status to "new"
262 * (via parse_events_restart()), so that the user can continue scanning by
263 * just pointing parse_events_in at a new input file.
264 */
265#define YY_BUFFER_EOF_PENDING 2
266
267 };
268#endif /* !YY_STRUCT_YY_BUFFER_STATE */
269
270/* Stack of input buffers. */
271static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
272static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
273static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
274
275/* We provide macros for accessing buffer states in case in the
276 * future we want to put the buffer states in a more general
277 * "scanner state".
278 *
279 * Returns the top of the stack, or NULL.
280 */
281#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
282 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
283 : NULL)
284
285/* Same as previous macro, but useful when we know that the buffer stack is not
286 * NULL or when we need an lvalue. For internal use only.
287 */
288#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
289
290/* yy_hold_char holds the character lost when parse_events_text is formed. */
291static char yy_hold_char;
292static int yy_n_chars; /* number of characters read into yy_ch_buf */
293int parse_events_leng;
294
295/* Points to current character in buffer. */
296static char *yy_c_buf_p = (char *) 0;
297static int yy_init = 0; /* whether we need to initialize */
298static int yy_start = 0; /* start state number */
299
300/* Flag which is used to allow parse_events_wrap()'s to do buffer switches
301 * instead of setting up a fresh parse_events_in. A bit of a hack ...
302 */
303static int yy_did_buffer_switch_on_eof;
304
305void parse_events_restart (FILE *input_file );
306void parse_events__switch_to_buffer (YY_BUFFER_STATE new_buffer );
307YY_BUFFER_STATE parse_events__create_buffer (FILE *file,int size );
308void parse_events__delete_buffer (YY_BUFFER_STATE b );
309void parse_events__flush_buffer (YY_BUFFER_STATE b );
310void parse_events_push_buffer_state (YY_BUFFER_STATE new_buffer );
311void parse_events_pop_buffer_state (void );
312
313static void parse_events_ensure_buffer_stack (void );
314static void parse_events__load_buffer_state (void );
315static void parse_events__init_buffer (YY_BUFFER_STATE b,FILE *file );
316
317#define YY_FLUSH_BUFFER parse_events__flush_buffer(YY_CURRENT_BUFFER )
318
319YY_BUFFER_STATE parse_events__scan_buffer (char *base,yy_size_t size );
320YY_BUFFER_STATE parse_events__scan_string (yyconst char *yy_str );
321YY_BUFFER_STATE parse_events__scan_bytes (yyconst char *bytes,int len );
322
323void *parse_events_alloc (yy_size_t );
324void *parse_events_realloc (void *,yy_size_t );
325void parse_events_free (void * );
326
327#define yy_new_buffer parse_events__create_buffer
328
329#define yy_set_interactive(is_interactive) \
330 { \
331 if ( ! YY_CURRENT_BUFFER ){ \
332 parse_events_ensure_buffer_stack (); \
333 YY_CURRENT_BUFFER_LVALUE = \
334 parse_events__create_buffer(parse_events_in,YY_BUF_SIZE ); \
335 } \
336 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
337 }
338
339#define yy_set_bol(at_bol) \
340 { \
341 if ( ! YY_CURRENT_BUFFER ){\
342 parse_events_ensure_buffer_stack (); \
343 YY_CURRENT_BUFFER_LVALUE = \
344 parse_events__create_buffer(parse_events_in,YY_BUF_SIZE ); \
345 } \
346 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
347 }
348
349#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
350
351/* Begin user sect3 */
352
353typedef unsigned char YY_CHAR;
354
355FILE *parse_events_in = (FILE *) 0, *parse_events_out = (FILE *) 0;
356
357typedef int yy_state_type;
358
359extern int parse_events_lineno;
360
361int parse_events_lineno = 1;
362
363extern char *parse_events_text;
364#define yytext_ptr parse_events_text
365
366static yy_state_type yy_get_previous_state (void );
367static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
368static int yy_get_next_buffer (void );
369static void yy_fatal_error (yyconst char msg[] );
370
371/* Done after the current pattern has been matched and before the
372 * corresponding action - sets up parse_events_text.
373 */
374#define YY_DO_BEFORE_ACTION \
375 (yytext_ptr) = yy_bp; \
376 parse_events_leng = (size_t) (yy_cp - yy_bp); \
377 (yy_hold_char) = *yy_cp; \
378 *yy_cp = '\0'; \
379 (yy_c_buf_p) = yy_cp;
380
381#define YY_NUM_RULES 49
382#define YY_END_OF_BUFFER 50
383/* This struct is not used in this scanner,
384 but its presence is necessary. */
385struct yy_trans_info
386 {
387 flex_int32_t yy_verify;
388 flex_int32_t yy_nxt;
389 };
390static yyconst flex_int16_t yy_accept[440] =
391 { 0,
392 0, 0, 50, 49, 43, 46, 45, 44, 39, 39,
393 47, 48, 43, 43, 43, 43, 43, 43, 43, 43,
394 43, 43, 41, 43, 43, 43, 43, 43, 41, 42,
395 43, 43, 42, 42, 43, 39, 0, 43, 43, 43,
396 21, 43, 43, 43, 43, 43, 43, 43, 43, 43,
397 43, 43, 15, 43, 0, 43, 43, 43, 41, 0,
398 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
399 43, 43, 43, 38, 38, 43, 43, 43, 43, 40,
400 43, 43, 0, 43, 43, 43, 24, 43, 43, 43,
401 43, 43, 43, 0, 43, 43, 43, 41, 0, 43,
402
403 43, 43, 0, 19, 20, 43, 43, 43, 43, 43,
404 43, 43, 30, 43, 43, 43, 38, 38, 43, 43,
405 43, 43, 43, 43, 43, 0, 0, 43, 43, 43,
406 43, 0, 43, 43, 43, 0, 43, 0, 22, 43,
407 43, 41, 0, 23, 43, 43, 19, 20, 26, 43,
408 37, 43, 43, 31, 25, 43, 43, 43, 26, 43,
409 43, 43, 43, 43, 0, 43, 0, 0, 0, 0,
410 43, 43, 43, 43, 0, 43, 43, 43, 0, 0,
411 43, 22, 43, 43, 41, 23, 0, 43, 26, 43,
412 43, 43, 43, 0, 43, 43, 43, 43, 27, 0,
413
414 27, 0, 43, 0, 0, 0, 0, 43, 43, 24,
415 0, 0, 32, 43, 0, 0, 0, 1, 43, 12,
416 0, 43, 0, 43, 0, 31, 0, 35, 43, 43,
417 43, 0, 0, 43, 0, 0, 0, 43, 43, 0,
418 43, 43, 0, 0, 0, 33, 34, 43, 0, 0,
419 0, 43, 0, 43, 0, 43, 0, 0, 43, 43,
420 43, 0, 43, 0, 0, 0, 43, 43, 0, 0,
421 43, 7, 0, 0, 0, 0, 0, 0, 0, 43,
422 0, 43, 0, 43, 0, 0, 28, 43, 0, 0,
423 43, 0, 43, 0, 0, 43, 0, 0, 0, 0,
424
425 10, 0, 0, 43, 0, 43, 0, 43, 0, 0,
426 43, 43, 0, 0, 43, 0, 0, 0, 0, 43,
427 9, 0, 0, 0, 1, 0, 0, 0, 43, 0,
428 16, 0, 0, 28, 43, 0, 11, 43, 0, 0,
429 0, 0, 36, 0, 0, 0, 0, 0, 0, 43,
430 0, 0, 12, 43, 0, 0, 0, 0, 0, 0,
431 6, 0, 0, 0, 0, 0, 4, 14, 13, 0,
432 0, 0, 0, 0, 0, 8, 0, 0, 0, 0,
433 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
434 16, 0, 0, 0, 0, 0, 0, 0, 0, 0,
435
436 0, 0, 0, 0, 0, 0, 0, 17, 0, 5,
437 15, 18, 0, 0, 29, 0, 0, 0, 0, 0,
438 0, 0, 0, 0, 0, 0, 0, 7, 3, 0,
439 0, 0, 2, 0, 0, 0, 0, 0, 0
440 } ;
441
442static yyconst flex_int32_t yy_ec[256] =
443 { 0,
444 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
447 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
448 1, 2, 1, 3, 4, 1, 5, 6, 7, 8,
449 9, 9, 9, 9, 9, 9, 9, 10, 1, 1,
450 11, 1, 2, 1, 12, 13, 14, 15, 12, 12,
451 2, 2, 16, 2, 2, 17, 2, 2, 2, 2,
452 2, 18, 2, 19, 2, 2, 2, 2, 2, 2,
453 1, 1, 1, 1, 20, 1, 21, 22, 23, 24,
454
455 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
456 35, 36, 2, 37, 38, 39, 40, 41, 42, 43,
457 44, 2, 1, 1, 1, 1, 1, 1, 1, 1,
458 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
459 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
460 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
461 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
462 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
463 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
464 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
465
466 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
467 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
468 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
469 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
470 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
471 1, 1, 1, 1, 1
472 } ;
473
474static yyconst flex_int32_t yy_meta[45] =
475 { 0,
476 1, 2, 1, 1, 1, 3, 3, 3, 3, 1,
477 1, 3, 3, 3, 3, 2, 2, 2, 2, 2,
478 3, 3, 3, 3, 3, 3, 2, 2, 2, 2,
479 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
480 2, 2, 2, 2
481 } ;
482
483static yyconst flex_int16_t yy_base[442] =
484 { 0,
485 0, 0, 510, 511, 0, 511, 511, 511, 39, 43,
486 511, 511, 488, 474, 46, 482, 32, 20, 37, 57,
487 473, 484, 34, 64, 59, 64, 469, 467, 78, 113,
488 41, 481, 464, 0, 0, 104, 0, 461, 461, 494,
489 0, 483, 470, 472, 465, 44, 472, 470, 453, 467,
490 455, 448, 0, 464, 447, 468, 444, 443, 64, 443,
491 464, 448, 441, 67, 457, 447, 443, 52, 451, 436,
492 446, 435, 446, 445, 76, 444, 95, 430, 438, 0,
493 445, 426, 100, 439, 438, 435, 0, 427, 456, 431,
494 105, 454, 425, 424, 442, 422, 421, 112, 420, 438,
495
496 425, 410, 117, 0, 0, 424, 412, 436, 408, 409,
497 405, 417, 0, 416, 411, 413, 83, 107, 415, 405,
498 399, 404, 395, 429, 395, 126, 119, 394, 392, 395,
499 405, 404, 401, 396, 399, 100, 398, 400, 0, 400,
500 381, 123, 397, 0, 414, 380, 511, 511, 378, 378,
501 511, 393, 376, 387, 0, 407, 375, 384, 383, 367,
502 374, 380, 400, 378, 383, 361, 361, 378, 377, 359,
503 371, 357, 361, 365, 348, 387, 363, 346, 73, 359,
504 349, 511, 347, 347, 0, 511, 361, 343, 0, 378,
505 342, 376, 341, 352, 353, 337, 343, 349, 335, 349,
506
507 0, 354, 347, 348, 345, 344, 327, 331, 339, 146,
508 340, 123, 150, 323, 326, 337, 332, 0, 329, 0,
509 313, 333, 329, 325, 327, 0, 331, 0, 328, 329,
510 325, 316, 334, 307, 317, 316, 306, 319, 307, 132,
511 301, 301, 306, 308, 311, 0, 0, 331, 311, 301,
512 295, 296, 307, 290, 307, 292, 305, 285, 296, 284,
513 318, 286, 291, 294, 293, 277, 291, 276, 280, 284,
514 268, 0, 286, 272, 283, 270, 276, 281, 284, 270,
515 271, 273, 261, 266, 259, 266, 272, 267, 272, 271,
516 258, 269, 287, 252, 251, 252, 249, 248, 260, 242,
517
518 511, 245, 243, 277, 255, 244, 246, 239, 244, 236,
519 236, 232, 228, 240, 236, 230, 242, 228, 228, 240,
520 511, 239, 226, 233, 511, 232, 234, 221, 224, 218,
521 0, 217, 217, 0, 229, 230, 511, 248, 222, 229,
522 212, 223, 0, 209, 221, 206, 209, 222, 238, 203,
523 202, 201, 511, 234, 205, 217, 200, 194, 193, 194,
524 511, 197, 207, 195, 188, 142, 0, 511, 511, 130,
525 202, 209, 191, 192, 200, 511, 199, 193, 182, 187,
526 197, 180, 181, 190, 176, 200, 173, 172, 185, 184,
527 511, 169, 184, 171, 184, 183, 199, 164, 172, 162,
528
529 161, 160, 166, 162, 171, 170, 147, 511, 158, 511,
530 511, 511, 167, 152, 511, 169, 152, 154, 153, 161,
531 162, 149, 145, 158, 147, 149, 145, 511, 511, 154,
532 152, 137, 511, 138, 145, 131, 53, 54, 511, 172,
533 66
534 } ;
535
536static yyconst flex_int16_t yy_def[442] =
537 { 0,
538 439, 1, 439, 439, 440, 439, 439, 439, 439, 439,
539 439, 439, 440, 440, 440, 440, 440, 440, 440, 440,
540 440, 440, 440, 440, 440, 440, 440, 440, 440, 440,
541 440, 440, 440, 440, 440, 439, 441, 440, 440, 440,
542 440, 440, 440, 440, 440, 440, 440, 440, 440, 440,
543 440, 440, 440, 440, 439, 440, 440, 440, 440, 439,
544 440, 440, 440, 440, 440, 440, 440, 440, 440, 440,
545 440, 440, 440, 30, 30, 440, 440, 440, 440, 441,
546 440, 440, 439, 440, 440, 440, 440, 440, 440, 440,
547 440, 440, 440, 439, 440, 440, 440, 440, 439, 440,
548
549 440, 440, 439, 440, 440, 440, 440, 440, 440, 440,
550 440, 440, 440, 440, 440, 440, 30, 30, 440, 440,
551 440, 440, 440, 440, 440, 439, 439, 440, 440, 440,
552 440, 439, 440, 440, 440, 439, 440, 439, 440, 440,
553 440, 440, 439, 440, 440, 440, 439, 439, 440, 440,
554 439, 440, 440, 440, 440, 440, 440, 440, 30, 440,
555 440, 440, 440, 440, 439, 440, 439, 439, 439, 439,
556 440, 440, 440, 440, 439, 440, 440, 440, 439, 439,
557 440, 439, 440, 440, 440, 439, 439, 440, 440, 440,
558 440, 440, 440, 439, 440, 440, 440, 440, 440, 439,
559
560 440, 439, 440, 439, 439, 439, 439, 440, 440, 440,
561 439, 439, 440, 440, 439, 439, 439, 440, 440, 440,
562 439, 440, 439, 440, 439, 440, 439, 440, 440, 440,
563 440, 439, 439, 440, 439, 439, 439, 440, 440, 439,
564 440, 440, 439, 439, 439, 440, 440, 440, 439, 439,
565 439, 440, 439, 440, 439, 440, 439, 439, 440, 440,
566 440, 439, 440, 439, 439, 439, 440, 440, 439, 439,
567 440, 440, 439, 439, 439, 439, 439, 439, 439, 440,
568 439, 440, 439, 440, 439, 439, 440, 440, 439, 439,
569 440, 439, 440, 439, 439, 440, 439, 439, 439, 439,
570
571 439, 439, 439, 440, 439, 440, 439, 440, 439, 439,
572 440, 440, 439, 439, 440, 439, 439, 439, 439, 440,
573 439, 439, 439, 439, 439, 439, 439, 439, 440, 439,
574 440, 439, 439, 440, 440, 439, 439, 440, 439, 439,
575 439, 439, 440, 439, 439, 439, 439, 439, 439, 440,
576 439, 439, 439, 440, 439, 439, 439, 439, 439, 439,
577 439, 439, 439, 439, 439, 439, 440, 439, 439, 439,
578 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
579 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
580 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
581
582 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
583 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
584 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
585 439, 439, 439, 439, 439, 439, 439, 439, 0, 439,
586 439
587 } ;
588
589static yyconst flex_int16_t yy_nxt[556] =
590 { 0,
591 4, 5, 6, 7, 8, 9, 10, 10, 10, 11,
592 12, 5, 5, 5, 13, 14, 15, 16, 5, 5,
593 17, 18, 19, 20, 21, 22, 5, 23, 24, 5,
594 23, 25, 26, 27, 28, 29, 30, 31, 32, 23,
595 5, 33, 34, 5, 36, 36, 36, 36, 36, 36,
596 36, 36, 40, 41, 44, 46, 47, 50, 48, 49,
597 55, 59, 42, 45, 59, 64, 87, 60, 80, 59,
598 103, 51, 52, 59, 53, 56, 76, 433, 109, 77,
599 54, 37, 61, 87, 66, 110, 438, 62, 67, 111,
600 104, 98, 68, 65, 98, 105, 117, 63, 71, 98,
601
602 74, 118, 72, 98, 215, 59, 159, 74, 59, 36,
603 36, 36, 36, 59, 73, 120, 216, 59, 74, 74,
604 74, 74, 179, 126, 74, 74, 74, 74, 127, 121,
605 134, 74, 180, 74, 74, 74, 74, 75, 74, 142,
606 147, 169, 142, 135, 113, 148, 167, 142, 168, 240,
607 185, 142, 170, 185, 429, 244, 246, 247, 185, 245,
608 269, 383, 185, 381, 270, 241, 384, 382, 416, 437,
609 242, 436, 417, 35, 35, 435, 434, 433, 432, 431,
610 430, 429, 428, 427, 426, 425, 424, 423, 422, 421,
611 420, 419, 418, 415, 415, 414, 413, 412, 411, 410,
612
613 409, 408, 407, 406, 405, 404, 403, 402, 401, 400,
614 399, 398, 186, 397, 396, 395, 394, 393, 392, 391,
615 390, 389, 388, 387, 148, 386, 385, 380, 379, 378,
616 377, 376, 375, 374, 373, 372, 371, 370, 369, 368,
617 367, 366, 365, 364, 363, 362, 361, 360, 359, 358,
618 357, 356, 355, 354, 353, 352, 351, 350, 349, 348,
619 347, 346, 345, 344, 343, 342, 341, 340, 339, 338,
620 337, 336, 335, 334, 333, 332, 331, 330, 329, 328,
621 327, 326, 325, 324, 323, 322, 321, 320, 319, 318,
622 317, 316, 315, 314, 313, 312, 311, 310, 309, 308,
623
624 307, 306, 305, 304, 303, 302, 301, 300, 299, 298,
625 297, 296, 295, 294, 293, 113, 292, 148, 147, 291,
626 290, 289, 288, 287, 286, 285, 284, 283, 282, 281,
627 280, 279, 278, 277, 276, 275, 274, 273, 272, 271,
628 268, 267, 266, 265, 264, 263, 182, 262, 261, 260,
629 259, 258, 257, 256, 255, 254, 253, 252, 251, 250,
630 249, 248, 243, 239, 238, 237, 236, 235, 147, 234,
631 233, 232, 201, 231, 230, 229, 228, 227, 226, 225,
632 224, 223, 222, 221, 220, 219, 218, 217, 214, 213,
633 212, 211, 210, 209, 113, 208, 207, 206, 205, 204,
634
635 203, 202, 201, 200, 199, 198, 197, 74, 196, 195,
636 194, 193, 192, 191, 190, 189, 188, 187, 186, 184,
637 183, 182, 181, 178, 177, 176, 175, 174, 173, 172,
638 171, 166, 165, 164, 163, 162, 161, 160, 158, 157,
639 156, 155, 154, 153, 152, 151, 150, 149, 146, 145,
640 144, 143, 141, 140, 139, 138, 137, 136, 133, 132,
641 131, 130, 129, 128, 125, 124, 123, 122, 119, 74,
642 116, 115, 114, 113, 112, 108, 107, 106, 102, 101,
643 100, 99, 97, 96, 95, 94, 93, 92, 91, 90,
644 89, 87, 88, 86, 85, 84, 41, 83, 82, 81,
645
646 79, 78, 70, 69, 58, 57, 43, 39, 38, 439,
647 3, 439, 439, 439, 439, 439, 439, 439, 439, 439,
648 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
649 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
650 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
651 439, 439, 439, 439, 439
652 } ;
653
654static yyconst flex_int16_t yy_chk[556] =
655 { 0,
656 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
657 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
658 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
659 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
660 1, 1, 1, 1, 9, 9, 9, 9, 10, 10,
661 10, 10, 15, 15, 17, 18, 18, 19, 18, 18,
662 20, 23, 15, 17, 23, 25, 46, 24, 441, 23,
663 64, 19, 19, 23, 19, 20, 31, 438, 68, 31,
664 19, 9, 24, 46, 26, 68, 437, 24, 26, 68,
665 64, 59, 26, 25, 59, 64, 75, 24, 29, 59,
666
667 75, 75, 29, 59, 179, 29, 117, 117, 29, 36,
668 36, 36, 36, 29, 29, 77, 179, 29, 30, 30,
669 30, 30, 136, 83, 30, 30, 30, 30, 83, 77,
670 91, 118, 136, 30, 30, 30, 30, 30, 30, 98,
671 103, 127, 98, 91, 118, 103, 126, 98, 126, 210,
672 142, 98, 127, 142, 436, 212, 213, 213, 142, 212,
673 240, 370, 142, 366, 240, 210, 370, 366, 407, 435,
674 210, 434, 407, 440, 440, 432, 431, 430, 427, 426,
675 425, 424, 423, 422, 421, 420, 419, 418, 417, 416,
676 414, 413, 409, 406, 405, 404, 403, 402, 401, 400,
677
678 399, 398, 397, 396, 395, 394, 393, 392, 390, 389,
679 388, 387, 386, 385, 384, 383, 382, 381, 380, 379,
680 378, 377, 375, 374, 373, 372, 371, 365, 364, 363,
681 362, 360, 359, 358, 357, 356, 355, 354, 352, 351,
682 350, 349, 348, 347, 346, 345, 344, 342, 341, 340,
683 339, 338, 336, 335, 333, 332, 330, 329, 328, 327,
684 326, 324, 323, 322, 320, 319, 318, 317, 316, 315,
685 314, 313, 312, 311, 310, 309, 308, 307, 306, 305,
686 304, 303, 302, 300, 299, 298, 297, 296, 295, 294,
687 293, 292, 291, 290, 289, 288, 287, 286, 285, 284,
688
689 283, 282, 281, 280, 279, 278, 277, 276, 275, 274,
690 273, 271, 270, 269, 268, 267, 266, 265, 264, 263,
691 262, 261, 260, 259, 258, 257, 256, 255, 254, 253,
692 252, 251, 250, 249, 248, 245, 244, 243, 242, 241,
693 239, 238, 237, 236, 235, 234, 233, 232, 231, 230,
694 229, 227, 225, 224, 223, 222, 221, 219, 217, 216,
695 215, 214, 211, 209, 208, 207, 206, 205, 204, 203,
696 202, 200, 199, 198, 197, 196, 195, 194, 193, 192,
697 191, 190, 188, 187, 184, 183, 181, 180, 178, 177,
698 176, 175, 174, 173, 172, 171, 170, 169, 168, 167,
699
700 166, 165, 164, 163, 162, 161, 160, 159, 158, 157,
701 156, 154, 153, 152, 150, 149, 146, 145, 143, 141,
702 140, 138, 137, 135, 134, 133, 132, 131, 130, 129,
703 128, 125, 124, 123, 122, 121, 120, 119, 116, 115,
704 114, 112, 111, 110, 109, 108, 107, 106, 102, 101,
705 100, 99, 97, 96, 95, 94, 93, 92, 90, 89,
706 88, 86, 85, 84, 82, 81, 79, 78, 76, 74,
707 73, 72, 71, 70, 69, 67, 66, 65, 63, 62,
708 61, 60, 58, 57, 56, 55, 54, 52, 51, 50,
709 49, 48, 47, 45, 44, 43, 42, 40, 39, 38,
710
711 33, 32, 28, 27, 22, 21, 16, 14, 13, 3,
712 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
713 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
714 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
715 439, 439, 439, 439, 439, 439, 439, 439, 439, 439,
716 439, 439, 439, 439, 439
717 } ;
718
719static yy_state_type yy_last_accepting_state;
720static char *yy_last_accepting_cpos;
721
722extern int parse_events__flex_debug;
723int parse_events__flex_debug = 0;
724
725/* The intent behind this definition is that it'll catch
726 * any uses of REJECT which flex missed.
727 */
728#define REJECT reject_used_but_not_detected
729#define yymore() yymore_used_but_not_detected
730#define YY_MORE_ADJ 0
731#define YY_RESTORE_YY_MORE_OFFSET
732char *parse_events_text;
733#line 1 "util/parse-events.l"
734#line 5 "util/parse-events.l"
735#include <errno.h>
736#include "../perf.h"
737#include "parse-events-bison.h"
738#include "parse-events.h"
739
740static int __value(char *str, int base, int token)
741{
742 long num;
743
744 errno = 0;
745 num = strtoul(str, NULL, base);
746 if (errno)
747 return PE_ERROR;
748
749 parse_events_lval.num = num;
750 return token;
751}
752
753static int value(int base)
754{
755 return __value(parse_events_text, base, PE_VALUE);
756}
757
758static int raw(void)
759{
760 return __value(parse_events_text + 1, 16, PE_RAW);
761}
762
763static int str(int token)
764{
765 parse_events_lval.str = strdup(parse_events_text);
766 return token;
767}
768
769static int sym(int type, int config)
770{
771 parse_events_lval.num = (type << 16) + config;
772 return PE_VALUE_SYM;
773}
774
775static int term(int type)
776{
777 parse_events_lval.num = type;
778 return PE_TERM;
779}
780
781#line 782 "<stdout>"
782
783#define INITIAL 0
784
785#ifndef YY_NO_UNISTD_H
786/* Special case for "unistd.h", since it is non-ANSI. We include it way
787 * down here because we want the user's section 1 to have been scanned first.
788 * The user has a chance to override it with an option.
789 */
790#include <unistd.h>
791#endif
792
793#ifndef YY_EXTRA_TYPE
794#define YY_EXTRA_TYPE void *
795#endif
796
797static int yy_init_globals (void );
798
799/* Accessor methods to globals.
800 These are made visible to non-reentrant scanners for convenience. */
801
802int parse_events_lex_destroy (void );
803
804int parse_events_get_debug (void );
805
806void parse_events_set_debug (int debug_flag );
807
808YY_EXTRA_TYPE parse_events_get_extra (void );
809
810void parse_events_set_extra (YY_EXTRA_TYPE user_defined );
811
812FILE *parse_events_get_in (void );
813
814void parse_events_set_in (FILE * in_str );
815
816FILE *parse_events_get_out (void );
817
818void parse_events_set_out (FILE * out_str );
819
820int parse_events_get_leng (void );
821
822char *parse_events_get_text (void );
823
824int parse_events_get_lineno (void );
825
826void parse_events_set_lineno (int line_number );
827
828/* Macros after this point can all be overridden by user definitions in
829 * section 1.
830 */
831
832#ifndef YY_SKIP_YYWRAP
833#ifdef __cplusplus
834extern "C" int parse_events_wrap (void );
835#else
836extern int parse_events_wrap (void );
837#endif
838#endif
839
840 static void yyunput (int c,char *buf_ptr );
841
842#ifndef yytext_ptr
843static void yy_flex_strncpy (char *,yyconst char *,int );
844#endif
845
846#ifdef YY_NEED_STRLEN
847static int yy_flex_strlen (yyconst char * );
848#endif
849
850#ifndef YY_NO_INPUT
851
852#ifdef __cplusplus
853static int yyinput (void );
854#else
855static int input (void );
856#endif
857
858#endif
859
860/* Amount of stuff to slurp up with each read. */
861#ifndef YY_READ_BUF_SIZE
862#define YY_READ_BUF_SIZE 8192
863#endif
864
865/* Copy whatever the last rule matched to the standard output. */
866#ifndef ECHO
867/* This used to be an fputs(), but since the string might contain NUL's,
868 * we now use fwrite().
869 */
870#define ECHO do { if (fwrite( parse_events_text, parse_events_leng, 1, parse_events_out )) {} } while (0)
871#endif
872
873/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
874 * is returned in "result".
875 */
876#ifndef YY_INPUT
877#define YY_INPUT(buf,result,max_size) \
878 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
879 { \
880 int c = '*'; \
881 unsigned n; \
882 for ( n = 0; n < max_size && \
883 (c = getc( parse_events_in )) != EOF && c != '\n'; ++n ) \
884 buf[n] = (char) c; \
885 if ( c == '\n' ) \
886 buf[n++] = (char) c; \
887 if ( c == EOF && ferror( parse_events_in ) ) \
888 YY_FATAL_ERROR( "input in flex scanner failed" ); \
889 result = n; \
890 } \
891 else \
892 { \
893 errno=0; \
894 while ( (result = fread(buf, 1, max_size, parse_events_in))==0 && ferror(parse_events_in)) \
895 { \
896 if( errno != EINTR) \
897 { \
898 YY_FATAL_ERROR( "input in flex scanner failed" ); \
899 break; \
900 } \
901 errno=0; \
902 clearerr(parse_events_in); \
903 } \
904 }\
905\
906
907#endif
908
909/* No semi-colon after return; correct usage is to write "yyterminate();" -
910 * we don't want an extra ';' after the "return" because that will cause
911 * some compilers to complain about unreachable statements.
912 */
913#ifndef yyterminate
914#define yyterminate() return YY_NULL
915#endif
916
917/* Number of entries by which start-condition stack grows. */
918#ifndef YY_START_STACK_INCR
919#define YY_START_STACK_INCR 25
920#endif
921
922/* Report a fatal error. */
923#ifndef YY_FATAL_ERROR
924#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
925#endif
926
927/* end tables serialization structures and prototypes */
928
929/* Default declaration of generated scanner - a define so the user can
930 * easily add parameters.
931 */
932#ifndef YY_DECL
933#define YY_DECL_IS_OURS 1
934
935extern int parse_events_lex (void);
936
937#define YY_DECL int parse_events_lex (void)
938#endif /* !YY_DECL */
939
940/* Code executed at the beginning of each rule, after parse_events_text and parse_events_leng
941 * have been set up.
942 */
943#ifndef YY_USER_ACTION
944#define YY_USER_ACTION
945#endif
946
947/* Code executed at the end of each rule. */
948#ifndef YY_BREAK
949#define YY_BREAK break;
950#endif
951
952#define YY_RULE_SETUP \
953 YY_USER_ACTION
954
955/** The main scanner function which does all the work.
956 */
957YY_DECL
958{
959 register yy_state_type yy_current_state;
960 register char *yy_cp, *yy_bp;
961 register int yy_act;
962
963#line 60 "util/parse-events.l"
964
965#line 966 "<stdout>"
966
967 if ( !(yy_init) )
968 {
969 (yy_init) = 1;
970
971#ifdef YY_USER_INIT
972 YY_USER_INIT;
973#endif
974
975 if ( ! (yy_start) )
976 (yy_start) = 1; /* first start state */
977
978 if ( ! parse_events_in )
979 parse_events_in = stdin;
980
981 if ( ! parse_events_out )
982 parse_events_out = stdout;
983
984 if ( ! YY_CURRENT_BUFFER ) {
985 parse_events_ensure_buffer_stack ();
986 YY_CURRENT_BUFFER_LVALUE =
987 parse_events__create_buffer(parse_events_in,YY_BUF_SIZE );
988 }
989
990 parse_events__load_buffer_state( );
991 }
992
993 while ( 1 ) /* loops until end-of-file is reached */
994 {
995 yy_cp = (yy_c_buf_p);
996
997 /* Support of parse_events_text. */
998 *yy_cp = (yy_hold_char);
999
1000 /* yy_bp points to the position in yy_ch_buf of the start of
1001 * the current run.
1002 */
1003 yy_bp = yy_cp;
1004
1005 yy_current_state = (yy_start);
1006yy_match:
1007 do
1008 {
1009 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1010 if ( yy_accept[yy_current_state] )
1011 {
1012 (yy_last_accepting_state) = yy_current_state;
1013 (yy_last_accepting_cpos) = yy_cp;
1014 }
1015 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1016 {
1017 yy_current_state = (int) yy_def[yy_current_state];
1018 if ( yy_current_state >= 440 )
1019 yy_c = yy_meta[(unsigned int) yy_c];
1020 }
1021 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1022 ++yy_cp;
1023 }
1024 while ( yy_base[yy_current_state] != 511 );
1025
1026yy_find_action:
1027 yy_act = yy_accept[yy_current_state];
1028 if ( yy_act == 0 )
1029 { /* have to back up */
1030 yy_cp = (yy_last_accepting_cpos);
1031 yy_current_state = (yy_last_accepting_state);
1032 yy_act = yy_accept[yy_current_state];
1033 }
1034
1035 YY_DO_BEFORE_ACTION;
1036
1037do_action: /* This label is used only to access EOF actions. */
1038
1039 switch ( yy_act )
1040 { /* beginning of action switch */
1041 case 0: /* must back up */
1042 /* undo the effects of YY_DO_BEFORE_ACTION */
1043 *yy_cp = (yy_hold_char);
1044 yy_cp = (yy_last_accepting_cpos);
1045 yy_current_state = (yy_last_accepting_state);
1046 goto yy_find_action;
1047
1048case 1:
1049YY_RULE_SETUP
1050#line 61 "util/parse-events.l"
1051{ return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); }
1052 YY_BREAK
1053case 2:
1054YY_RULE_SETUP
1055#line 62 "util/parse-events.l"
1056{ return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
1057 YY_BREAK
1058case 3:
1059YY_RULE_SETUP
1060#line 63 "util/parse-events.l"
1061{ return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
1062 YY_BREAK
1063case 4:
1064YY_RULE_SETUP
1065#line 64 "util/parse-events.l"
1066{ return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); }
1067 YY_BREAK
1068case 5:
1069YY_RULE_SETUP
1070#line 65 "util/parse-events.l"
1071{ return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); }
1072 YY_BREAK
1073case 6:
1074YY_RULE_SETUP
1075#line 66 "util/parse-events.l"
1076{ return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); }
1077 YY_BREAK
1078case 7:
1079YY_RULE_SETUP
1080#line 67 "util/parse-events.l"
1081{ return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); }
1082 YY_BREAK
1083case 8:
1084YY_RULE_SETUP
1085#line 68 "util/parse-events.l"
1086{ return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); }
1087 YY_BREAK
1088case 9:
1089YY_RULE_SETUP
1090#line 69 "util/parse-events.l"
1091{ return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); }
1092 YY_BREAK
1093case 10:
1094YY_RULE_SETUP
1095#line 70 "util/parse-events.l"
1096{ return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); }
1097 YY_BREAK
1098case 11:
1099YY_RULE_SETUP
1100#line 71 "util/parse-events.l"
1101{ return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); }
1102 YY_BREAK
1103case 12:
1104YY_RULE_SETUP
1105#line 72 "util/parse-events.l"
1106{ return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); }
1107 YY_BREAK
1108case 13:
1109YY_RULE_SETUP
1110#line 73 "util/parse-events.l"
1111{ return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); }
1112 YY_BREAK
1113case 14:
1114YY_RULE_SETUP
1115#line 74 "util/parse-events.l"
1116{ return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); }
1117 YY_BREAK
1118case 15:
1119YY_RULE_SETUP
1120#line 75 "util/parse-events.l"
1121{ return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); }
1122 YY_BREAK
1123case 16:
1124YY_RULE_SETUP
1125#line 76 "util/parse-events.l"
1126{ return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); }
1127 YY_BREAK
1128case 17:
1129YY_RULE_SETUP
1130#line 77 "util/parse-events.l"
1131{ return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); }
1132 YY_BREAK
1133case 18:
1134YY_RULE_SETUP
1135#line 78 "util/parse-events.l"
1136{ return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); }
1137 YY_BREAK
1138case 19:
1139#line 81 "util/parse-events.l"
1140case 20:
1141#line 82 "util/parse-events.l"
1142case 21:
1143#line 83 "util/parse-events.l"
1144case 22:
1145#line 84 "util/parse-events.l"
1146case 23:
1147#line 85 "util/parse-events.l"
1148case 24:
1149#line 86 "util/parse-events.l"
1150case 25:
1151YY_RULE_SETUP
1152#line 86 "util/parse-events.l"
1153{ return str(PE_NAME_CACHE_TYPE); }
1154 YY_BREAK
1155case 26:
1156#line 89 "util/parse-events.l"
1157case 27:
1158#line 90 "util/parse-events.l"
1159case 28:
1160#line 91 "util/parse-events.l"
1161case 29:
1162#line 92 "util/parse-events.l"
1163case 30:
1164#line 93 "util/parse-events.l"
1165case 31:
1166YY_RULE_SETUP
1167#line 93 "util/parse-events.l"
1168{ return str(PE_NAME_CACHE_OP_RESULT); }
1169 YY_BREAK
1170/*
1171 * These are event config hardcoded term names to be specified
1172 * within xxx/.../ syntax. So far we dont clash with other names,
1173 * so we can put them here directly. In case the we have a conflict
1174 * in future, this needs to go into '//' condition block.
1175 */
1176case 32:
1177YY_RULE_SETUP
1178#line 101 "util/parse-events.l"
1179{ return term(PARSE_EVENTS__TERM_TYPE_CONFIG); }
1180 YY_BREAK
1181case 33:
1182YY_RULE_SETUP
1183#line 102 "util/parse-events.l"
1184{ return term(PARSE_EVENTS__TERM_TYPE_CONFIG1); }
1185 YY_BREAK
1186case 34:
1187YY_RULE_SETUP
1188#line 103 "util/parse-events.l"
1189{ return term(PARSE_EVENTS__TERM_TYPE_CONFIG2); }
1190 YY_BREAK
1191case 35:
1192YY_RULE_SETUP
1193#line 104 "util/parse-events.l"
1194{ return term(PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); }
1195 YY_BREAK
1196case 36:
1197YY_RULE_SETUP
1198#line 105 "util/parse-events.l"
1199{ return term(PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); }
1200 YY_BREAK
1201case 37:
1202YY_RULE_SETUP
1203#line 107 "util/parse-events.l"
1204{ return PE_PREFIX_MEM; }
1205 YY_BREAK
1206case 38:
1207YY_RULE_SETUP
1208#line 108 "util/parse-events.l"
1209{ return raw(); }
1210 YY_BREAK
1211case 39:
1212YY_RULE_SETUP
1213#line 109 "util/parse-events.l"
1214{ return value(10); }
1215 YY_BREAK
1216case 40:
1217YY_RULE_SETUP
1218#line 110 "util/parse-events.l"
1219{ return value(16); }
1220 YY_BREAK
1221case 41:
1222YY_RULE_SETUP
1223#line 112 "util/parse-events.l"
1224{ return str(PE_MODIFIER_EVENT); }
1225 YY_BREAK
1226case 42:
1227YY_RULE_SETUP
1228#line 113 "util/parse-events.l"
1229{ return str(PE_MODIFIER_BP); }
1230 YY_BREAK
1231case 43:
1232YY_RULE_SETUP
1233#line 114 "util/parse-events.l"
1234{ return str(PE_NAME); }
1235 YY_BREAK
1236case 44:
1237YY_RULE_SETUP
1238#line 115 "util/parse-events.l"
1239{ return '/'; }
1240 YY_BREAK
1241case 45:
1242YY_RULE_SETUP
1243#line 116 "util/parse-events.l"
1244{ return '-'; }
1245 YY_BREAK
1246case 46:
1247YY_RULE_SETUP
1248#line 117 "util/parse-events.l"
1249{ return ','; }
1250 YY_BREAK
1251case 47:
1252YY_RULE_SETUP
1253#line 118 "util/parse-events.l"
1254{ return ':'; }
1255 YY_BREAK
1256case 48:
1257YY_RULE_SETUP
1258#line 119 "util/parse-events.l"
1259{ return '='; }
1260 YY_BREAK
1261case 49:
1262YY_RULE_SETUP
1263#line 121 "util/parse-events.l"
1264ECHO;
1265 YY_BREAK
1266#line 1267 "<stdout>"
1267case YY_STATE_EOF(INITIAL):
1268 yyterminate();
1269
1270 case YY_END_OF_BUFFER:
1271 {
1272 /* Amount of text matched not including the EOB char. */
1273 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1274
1275 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1276 *yy_cp = (yy_hold_char);
1277 YY_RESTORE_YY_MORE_OFFSET
1278
1279 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1280 {
1281 /* We're scanning a new file or input source. It's
1282 * possible that this happened because the user
1283 * just pointed parse_events_in at a new source and called
1284 * parse_events_lex(). If so, then we have to assure
1285 * consistency between YY_CURRENT_BUFFER and our
1286 * globals. Here is the right place to do so, because
1287 * this is the first action (other than possibly a
1288 * back-up) that will match for the new input source.
1289 */
1290 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1291 YY_CURRENT_BUFFER_LVALUE->yy_input_file = parse_events_in;
1292 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1293 }
1294
1295 /* Note that here we test for yy_c_buf_p "<=" to the position
1296 * of the first EOB in the buffer, since yy_c_buf_p will
1297 * already have been incremented past the NUL character
1298 * (since all states make transitions on EOB to the
1299 * end-of-buffer state). Contrast this with the test
1300 * in input().
1301 */
1302 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1303 { /* This was really a NUL. */
1304 yy_state_type yy_next_state;
1305
1306 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1307
1308 yy_current_state = yy_get_previous_state( );
1309
1310 /* Okay, we're now positioned to make the NUL
1311 * transition. We couldn't have
1312 * yy_get_previous_state() go ahead and do it
1313 * for us because it doesn't know how to deal
1314 * with the possibility of jamming (and we don't
1315 * want to build jamming into it because then it
1316 * will run more slowly).
1317 */
1318
1319 yy_next_state = yy_try_NUL_trans( yy_current_state );
1320
1321 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1322
1323 if ( yy_next_state )
1324 {
1325 /* Consume the NUL. */
1326 yy_cp = ++(yy_c_buf_p);
1327 yy_current_state = yy_next_state;
1328 goto yy_match;
1329 }
1330
1331 else
1332 {
1333 yy_cp = (yy_c_buf_p);
1334 goto yy_find_action;
1335 }
1336 }
1337
1338 else switch ( yy_get_next_buffer( ) )
1339 {
1340 case EOB_ACT_END_OF_FILE:
1341 {
1342 (yy_did_buffer_switch_on_eof) = 0;
1343
1344 if ( parse_events_wrap( ) )
1345 {
1346 /* Note: because we've taken care in
1347 * yy_get_next_buffer() to have set up
1348 * parse_events_text, we can now set up
1349 * yy_c_buf_p so that if some total
1350 * hoser (like flex itself) wants to
1351 * call the scanner after we return the
1352 * YY_NULL, it'll still work - another
1353 * YY_NULL will get returned.
1354 */
1355 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1356
1357 yy_act = YY_STATE_EOF(YY_START);
1358 goto do_action;
1359 }
1360
1361 else
1362 {
1363 if ( ! (yy_did_buffer_switch_on_eof) )
1364 YY_NEW_FILE;
1365 }
1366 break;
1367 }
1368
1369 case EOB_ACT_CONTINUE_SCAN:
1370 (yy_c_buf_p) =
1371 (yytext_ptr) + yy_amount_of_matched_text;
1372
1373 yy_current_state = yy_get_previous_state( );
1374
1375 yy_cp = (yy_c_buf_p);
1376 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1377 goto yy_match;
1378
1379 case EOB_ACT_LAST_MATCH:
1380 (yy_c_buf_p) =
1381 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1382
1383 yy_current_state = yy_get_previous_state( );
1384
1385 yy_cp = (yy_c_buf_p);
1386 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1387 goto yy_find_action;
1388 }
1389 break;
1390 }
1391
1392 default:
1393 YY_FATAL_ERROR(
1394 "fatal flex scanner internal error--no action found" );
1395 } /* end of action switch */
1396 } /* end of scanning one token */
1397} /* end of parse_events_lex */
1398
1399/* yy_get_next_buffer - try to read in a new buffer
1400 *
1401 * Returns a code representing an action:
1402 * EOB_ACT_LAST_MATCH -
1403 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1404 * EOB_ACT_END_OF_FILE - end of file
1405 */
1406static int yy_get_next_buffer (void)
1407{
1408 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1409 register char *source = (yytext_ptr);
1410 register int number_to_move, i;
1411 int ret_val;
1412
1413 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1414 YY_FATAL_ERROR(
1415 "fatal flex scanner internal error--end of buffer missed" );
1416
1417 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1418 { /* Don't try to fill the buffer, so this is an EOF. */
1419 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1420 {
1421 /* We matched a single character, the EOB, so
1422 * treat this as a final EOF.
1423 */
1424 return EOB_ACT_END_OF_FILE;
1425 }
1426
1427 else
1428 {
1429 /* We matched some text prior to the EOB, first
1430 * process it.
1431 */
1432 return EOB_ACT_LAST_MATCH;
1433 }
1434 }
1435
1436 /* Try to read more data. */
1437
1438 /* First move last chars to start of buffer. */
1439 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1440
1441 for ( i = 0; i < number_to_move; ++i )
1442 *(dest++) = *(source++);
1443
1444 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1445 /* don't do the read, it's not guaranteed to return an EOF,
1446 * just force an EOF
1447 */
1448 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1449
1450 else
1451 {
1452 int num_to_read =
1453 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1454
1455 while ( num_to_read <= 0 )
1456 { /* Not enough room in the buffer - grow it. */
1457
1458 /* just a shorter name for the current buffer */
1459 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1460
1461 int yy_c_buf_p_offset =
1462 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1463
1464 if ( b->yy_is_our_buffer )
1465 {
1466 int new_size = b->yy_buf_size * 2;
1467
1468 if ( new_size <= 0 )
1469 b->yy_buf_size += b->yy_buf_size / 8;
1470 else
1471 b->yy_buf_size *= 2;
1472
1473 b->yy_ch_buf = (char *)
1474 /* Include room in for 2 EOB chars. */
1475 parse_events_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1476 }
1477 else
1478 /* Can't grow it, we don't own it. */
1479 b->yy_ch_buf = 0;
1480
1481 if ( ! b->yy_ch_buf )
1482 YY_FATAL_ERROR(
1483 "fatal error - scanner input buffer overflow" );
1484
1485 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1486
1487 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1488 number_to_move - 1;
1489
1490 }
1491
1492 if ( num_to_read > YY_READ_BUF_SIZE )
1493 num_to_read = YY_READ_BUF_SIZE;
1494
1495 /* Read in more data. */
1496 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1497 (yy_n_chars), (size_t) num_to_read );
1498
1499 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1500 }
1501
1502 if ( (yy_n_chars) == 0 )
1503 {
1504 if ( number_to_move == YY_MORE_ADJ )
1505 {
1506 ret_val = EOB_ACT_END_OF_FILE;
1507 parse_events_restart(parse_events_in );
1508 }
1509
1510 else
1511 {
1512 ret_val = EOB_ACT_LAST_MATCH;
1513 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1514 YY_BUFFER_EOF_PENDING;
1515 }
1516 }
1517
1518 else
1519 ret_val = EOB_ACT_CONTINUE_SCAN;
1520
1521 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1522 /* Extend the array by 50%, plus the number we really need. */
1523 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1524 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) parse_events_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1525 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1526 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1527 }
1528
1529 (yy_n_chars) += number_to_move;
1530 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1531 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1532
1533 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1534
1535 return ret_val;
1536}
1537
1538/* yy_get_previous_state - get the state just before the EOB char was reached */
1539
1540 static yy_state_type yy_get_previous_state (void)
1541{
1542 register yy_state_type yy_current_state;
1543 register char *yy_cp;
1544
1545 yy_current_state = (yy_start);
1546
1547 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1548 {
1549 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1550 if ( yy_accept[yy_current_state] )
1551 {
1552 (yy_last_accepting_state) = yy_current_state;
1553 (yy_last_accepting_cpos) = yy_cp;
1554 }
1555 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1556 {
1557 yy_current_state = (int) yy_def[yy_current_state];
1558 if ( yy_current_state >= 440 )
1559 yy_c = yy_meta[(unsigned int) yy_c];
1560 }
1561 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1562 }
1563
1564 return yy_current_state;
1565}
1566
1567/* yy_try_NUL_trans - try to make a transition on the NUL character
1568 *
1569 * synopsis
1570 * next_state = yy_try_NUL_trans( current_state );
1571 */
1572 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1573{
1574 register int yy_is_jam;
1575 register char *yy_cp = (yy_c_buf_p);
1576
1577 register YY_CHAR yy_c = 1;
1578 if ( yy_accept[yy_current_state] )
1579 {
1580 (yy_last_accepting_state) = yy_current_state;
1581 (yy_last_accepting_cpos) = yy_cp;
1582 }
1583 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1584 {
1585 yy_current_state = (int) yy_def[yy_current_state];
1586 if ( yy_current_state >= 440 )
1587 yy_c = yy_meta[(unsigned int) yy_c];
1588 }
1589 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1590 yy_is_jam = (yy_current_state == 439);
1591
1592 return yy_is_jam ? 0 : yy_current_state;
1593}
1594
1595 static void yyunput (int c, register char * yy_bp )
1596{
1597 register char *yy_cp;
1598
1599 yy_cp = (yy_c_buf_p);
1600
1601 /* undo effects of setting up parse_events_text */
1602 *yy_cp = (yy_hold_char);
1603
1604 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1605 { /* need to shift things up to make room */
1606 /* +2 for EOB chars. */
1607 register int number_to_move = (yy_n_chars) + 2;
1608 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1609 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1610 register char *source =
1611 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1612
1613 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1614 *--dest = *--source;
1615
1616 yy_cp += (int) (dest - source);
1617 yy_bp += (int) (dest - source);
1618 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1619 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1620
1621 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1622 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1623 }
1624
1625 *--yy_cp = (char) c;
1626
1627 (yytext_ptr) = yy_bp;
1628 (yy_hold_char) = *yy_cp;
1629 (yy_c_buf_p) = yy_cp;
1630}
1631
1632#ifndef YY_NO_INPUT
1633#ifdef __cplusplus
1634 static int yyinput (void)
1635#else
1636 static int input (void)
1637#endif
1638
1639{
1640 int c;
1641
1642 *(yy_c_buf_p) = (yy_hold_char);
1643
1644 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1645 {
1646 /* yy_c_buf_p now points to the character we want to return.
1647 * If this occurs *before* the EOB characters, then it's a
1648 * valid NUL; if not, then we've hit the end of the buffer.
1649 */
1650 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1651 /* This was really a NUL. */
1652 *(yy_c_buf_p) = '\0';
1653
1654 else
1655 { /* need more input */
1656 int offset = (yy_c_buf_p) - (yytext_ptr);
1657 ++(yy_c_buf_p);
1658
1659 switch ( yy_get_next_buffer( ) )
1660 {
1661 case EOB_ACT_LAST_MATCH:
1662 /* This happens because yy_g_n_b()
1663 * sees that we've accumulated a
1664 * token and flags that we need to
1665 * try matching the token before
1666 * proceeding. But for input(),
1667 * there's no matching to consider.
1668 * So convert the EOB_ACT_LAST_MATCH
1669 * to EOB_ACT_END_OF_FILE.
1670 */
1671
1672 /* Reset buffer status. */
1673 parse_events_restart(parse_events_in );
1674
1675 /*FALLTHROUGH*/
1676
1677 case EOB_ACT_END_OF_FILE:
1678 {
1679 if ( parse_events_wrap( ) )
1680 return EOF;
1681
1682 if ( ! (yy_did_buffer_switch_on_eof) )
1683 YY_NEW_FILE;
1684#ifdef __cplusplus
1685 return yyinput();
1686#else
1687 return input();
1688#endif
1689 }
1690
1691 case EOB_ACT_CONTINUE_SCAN:
1692 (yy_c_buf_p) = (yytext_ptr) + offset;
1693 break;
1694 }
1695 }
1696 }
1697
1698 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1699 *(yy_c_buf_p) = '\0'; /* preserve parse_events_text */
1700 (yy_hold_char) = *++(yy_c_buf_p);
1701
1702 return c;
1703}
1704#endif /* ifndef YY_NO_INPUT */
1705
1706/** Immediately switch to a different input stream.
1707 * @param input_file A readable stream.
1708 *
1709 * @note This function does not reset the start condition to @c INITIAL .
1710 */
1711 void parse_events_restart (FILE * input_file )
1712{
1713
1714 if ( ! YY_CURRENT_BUFFER ){
1715 parse_events_ensure_buffer_stack ();
1716 YY_CURRENT_BUFFER_LVALUE =
1717 parse_events__create_buffer(parse_events_in,YY_BUF_SIZE );
1718 }
1719
1720 parse_events__init_buffer(YY_CURRENT_BUFFER,input_file );
1721 parse_events__load_buffer_state( );
1722}
1723
1724/** Switch to a different input buffer.
1725 * @param new_buffer The new input buffer.
1726 *
1727 */
1728 void parse_events__switch_to_buffer (YY_BUFFER_STATE new_buffer )
1729{
1730
1731 /* TODO. We should be able to replace this entire function body
1732 * with
1733 * parse_events_pop_buffer_state();
1734 * parse_events_push_buffer_state(new_buffer);
1735 */
1736 parse_events_ensure_buffer_stack ();
1737 if ( YY_CURRENT_BUFFER == new_buffer )
1738 return;
1739
1740 if ( YY_CURRENT_BUFFER )
1741 {
1742 /* Flush out information for old buffer. */
1743 *(yy_c_buf_p) = (yy_hold_char);
1744 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1745 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1746 }
1747
1748 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1749 parse_events__load_buffer_state( );
1750
1751 /* We don't actually know whether we did this switch during
1752 * EOF (parse_events_wrap()) processing, but the only time this flag
1753 * is looked at is after parse_events_wrap() is called, so it's safe
1754 * to go ahead and always set it.
1755 */
1756 (yy_did_buffer_switch_on_eof) = 1;
1757}
1758
1759static void parse_events__load_buffer_state (void)
1760{
1761 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1762 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1763 parse_events_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1764 (yy_hold_char) = *(yy_c_buf_p);
1765}
1766
1767/** Allocate and initialize an input buffer state.
1768 * @param file A readable stream.
1769 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1770 *
1771 * @return the allocated buffer state.
1772 */
1773 YY_BUFFER_STATE parse_events__create_buffer (FILE * file, int size )
1774{
1775 YY_BUFFER_STATE b;
1776
1777 b = (YY_BUFFER_STATE) parse_events_alloc(sizeof( struct yy_buffer_state ) );
1778 if ( ! b )
1779 YY_FATAL_ERROR( "out of dynamic memory in parse_events__create_buffer()" );
1780
1781 b->yy_buf_size = size;
1782
1783 /* yy_ch_buf has to be 2 characters longer than the size given because
1784 * we need to put in 2 end-of-buffer characters.
1785 */
1786 b->yy_ch_buf = (char *) parse_events_alloc(b->yy_buf_size + 2 );
1787 if ( ! b->yy_ch_buf )
1788 YY_FATAL_ERROR( "out of dynamic memory in parse_events__create_buffer()" );
1789
1790 b->yy_is_our_buffer = 1;
1791
1792 parse_events__init_buffer(b,file );
1793
1794 return b;
1795}
1796
1797/** Destroy the buffer.
1798 * @param b a buffer created with parse_events__create_buffer()
1799 *
1800 */
1801 void parse_events__delete_buffer (YY_BUFFER_STATE b )
1802{
1803
1804 if ( ! b )
1805 return;
1806
1807 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1808 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1809
1810 if ( b->yy_is_our_buffer )
1811 parse_events_free((void *) b->yy_ch_buf );
1812
1813 parse_events_free((void *) b );
1814}
1815
1816#ifndef __cplusplus
1817extern int isatty (int );
1818#endif /* __cplusplus */
1819
1820/* Initializes or reinitializes a buffer.
1821 * This function is sometimes called more than once on the same buffer,
1822 * such as during a parse_events_restart() or at EOF.
1823 */
1824 static void parse_events__init_buffer (YY_BUFFER_STATE b, FILE * file )
1825
1826{
1827 int oerrno = errno;
1828
1829 parse_events__flush_buffer(b );
1830
1831 b->yy_input_file = file;
1832 b->yy_fill_buffer = 1;
1833
1834 /* If b is the current buffer, then parse_events__init_buffer was _probably_
1835 * called from parse_events_restart() or through yy_get_next_buffer.
1836 * In that case, we don't want to reset the lineno or column.
1837 */
1838 if (b != YY_CURRENT_BUFFER){
1839 b->yy_bs_lineno = 1;
1840 b->yy_bs_column = 0;
1841 }
1842
1843 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1844
1845 errno = oerrno;
1846}
1847
1848/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1849 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1850 *
1851 */
1852 void parse_events__flush_buffer (YY_BUFFER_STATE b )
1853{
1854 if ( ! b )
1855 return;
1856
1857 b->yy_n_chars = 0;
1858
1859 /* We always need two end-of-buffer characters. The first causes
1860 * a transition to the end-of-buffer state. The second causes
1861 * a jam in that state.
1862 */
1863 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1864 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1865
1866 b->yy_buf_pos = &b->yy_ch_buf[0];
1867
1868 b->yy_at_bol = 1;
1869 b->yy_buffer_status = YY_BUFFER_NEW;
1870
1871 if ( b == YY_CURRENT_BUFFER )
1872 parse_events__load_buffer_state( );
1873}
1874
1875/** Pushes the new state onto the stack. The new state becomes
1876 * the current state. This function will allocate the stack
1877 * if necessary.
1878 * @param new_buffer The new state.
1879 *
1880 */
1881void parse_events_push_buffer_state (YY_BUFFER_STATE new_buffer )
1882{
1883 if (new_buffer == NULL)
1884 return;
1885
1886 parse_events_ensure_buffer_stack();
1887
1888 /* This block is copied from parse_events__switch_to_buffer. */
1889 if ( YY_CURRENT_BUFFER )
1890 {
1891 /* Flush out information for old buffer. */
1892 *(yy_c_buf_p) = (yy_hold_char);
1893 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1894 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1895 }
1896
1897 /* Only push if top exists. Otherwise, replace top. */
1898 if (YY_CURRENT_BUFFER)
1899 (yy_buffer_stack_top)++;
1900 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1901
1902 /* copied from parse_events__switch_to_buffer. */
1903 parse_events__load_buffer_state( );
1904 (yy_did_buffer_switch_on_eof) = 1;
1905}
1906
1907/** Removes and deletes the top of the stack, if present.
1908 * The next element becomes the new top.
1909 *
1910 */
1911void parse_events_pop_buffer_state (void)
1912{
1913 if (!YY_CURRENT_BUFFER)
1914 return;
1915
1916 parse_events__delete_buffer(YY_CURRENT_BUFFER );
1917 YY_CURRENT_BUFFER_LVALUE = NULL;
1918 if ((yy_buffer_stack_top) > 0)
1919 --(yy_buffer_stack_top);
1920
1921 if (YY_CURRENT_BUFFER) {
1922 parse_events__load_buffer_state( );
1923 (yy_did_buffer_switch_on_eof) = 1;
1924 }
1925}
1926
1927/* Allocates the stack if it does not exist.
1928 * Guarantees space for at least one push.
1929 */
1930static void parse_events_ensure_buffer_stack (void)
1931{
1932 int num_to_alloc;
1933
1934 if (!(yy_buffer_stack)) {
1935
1936 /* First allocation is just for 2 elements, since we don't know if this
1937 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1938 * immediate realloc on the next call.
1939 */
1940 num_to_alloc = 1;
1941 (yy_buffer_stack) = (struct yy_buffer_state**)parse_events_alloc
1942 (num_to_alloc * sizeof(struct yy_buffer_state*)
1943 );
1944 if ( ! (yy_buffer_stack) )
1945 YY_FATAL_ERROR( "out of dynamic memory in parse_events_ensure_buffer_stack()" );
1946
1947 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1948
1949 (yy_buffer_stack_max) = num_to_alloc;
1950 (yy_buffer_stack_top) = 0;
1951 return;
1952 }
1953
1954 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1955
1956 /* Increase the buffer to prepare for a possible push. */
1957 int grow_size = 8 /* arbitrary grow size */;
1958
1959 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1960 (yy_buffer_stack) = (struct yy_buffer_state**)parse_events_realloc
1961 ((yy_buffer_stack),
1962 num_to_alloc * sizeof(struct yy_buffer_state*)
1963 );
1964 if ( ! (yy_buffer_stack) )
1965 YY_FATAL_ERROR( "out of dynamic memory in parse_events_ensure_buffer_stack()" );
1966
1967 /* zero only the new slots.*/
1968 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1969 (yy_buffer_stack_max) = num_to_alloc;
1970 }
1971}
1972
1973/** Setup the input buffer state to scan directly from a user-specified character buffer.
1974 * @param base the character buffer
1975 * @param size the size in bytes of the character buffer
1976 *
1977 * @return the newly allocated buffer state object.
1978 */
1979YY_BUFFER_STATE parse_events__scan_buffer (char * base, yy_size_t size )
1980{
1981 YY_BUFFER_STATE b;
1982
1983 if ( size < 2 ||
1984 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1985 base[size-1] != YY_END_OF_BUFFER_CHAR )
1986 /* They forgot to leave room for the EOB's. */
1987 return 0;
1988
1989 b = (YY_BUFFER_STATE) parse_events_alloc(sizeof( struct yy_buffer_state ) );
1990 if ( ! b )
1991 YY_FATAL_ERROR( "out of dynamic memory in parse_events__scan_buffer()" );
1992
1993 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1994 b->yy_buf_pos = b->yy_ch_buf = base;
1995 b->yy_is_our_buffer = 0;
1996 b->yy_input_file = 0;
1997 b->yy_n_chars = b->yy_buf_size;
1998 b->yy_is_interactive = 0;
1999 b->yy_at_bol = 1;
2000 b->yy_fill_buffer = 0;
2001 b->yy_buffer_status = YY_BUFFER_NEW;
2002
2003 parse_events__switch_to_buffer(b );
2004
2005 return b;
2006}
2007
2008/** Setup the input buffer state to scan a string. The next call to parse_events_lex() will
2009 * scan from a @e copy of @a str.
2010 * @param yystr a NUL-terminated string to scan
2011 *
2012 * @return the newly allocated buffer state object.
2013 * @note If you want to scan bytes that may contain NUL values, then use
2014 * parse_events__scan_bytes() instead.
2015 */
2016YY_BUFFER_STATE parse_events__scan_string (yyconst char * yystr )
2017{
2018
2019 return parse_events__scan_bytes(yystr,strlen(yystr) );
2020}
2021
2022/** Setup the input buffer state to scan the given bytes. The next call to parse_events_lex() will
2023 * scan from a @e copy of @a bytes.
2024 * @param bytes the byte buffer to scan
2025 * @param len the number of bytes in the buffer pointed to by @a bytes.
2026 *
2027 * @return the newly allocated buffer state object.
2028 */
2029YY_BUFFER_STATE parse_events__scan_bytes (yyconst char * yybytes, int _yybytes_len )
2030{
2031 YY_BUFFER_STATE b;
2032 char *buf;
2033 yy_size_t n;
2034 int i;
2035
2036 /* Get memory for full buffer, including space for trailing EOB's. */
2037 n = _yybytes_len + 2;
2038 buf = (char *) parse_events_alloc(n );
2039 if ( ! buf )
2040 YY_FATAL_ERROR( "out of dynamic memory in parse_events__scan_bytes()" );
2041
2042 for ( i = 0; i < _yybytes_len; ++i )
2043 buf[i] = yybytes[i];
2044
2045 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2046
2047 b = parse_events__scan_buffer(buf,n );
2048 if ( ! b )
2049 YY_FATAL_ERROR( "bad buffer in parse_events__scan_bytes()" );
2050
2051 /* It's okay to grow etc. this buffer, and we should throw it
2052 * away when we're done.
2053 */
2054 b->yy_is_our_buffer = 1;
2055
2056 return b;
2057}
2058
2059#ifndef YY_EXIT_FAILURE
2060#define YY_EXIT_FAILURE 2
2061#endif
2062
2063static void yy_fatal_error (yyconst char* msg )
2064{
2065 (void) fprintf( stderr, "%s\n", msg );
2066 exit( YY_EXIT_FAILURE );
2067}
2068
2069/* Redefine yyless() so it works in section 3 code. */
2070
2071#undef yyless
2072#define yyless(n) \
2073 do \
2074 { \
2075 /* Undo effects of setting up parse_events_text. */ \
2076 int yyless_macro_arg = (n); \
2077 YY_LESS_LINENO(yyless_macro_arg);\
2078 parse_events_text[parse_events_leng] = (yy_hold_char); \
2079 (yy_c_buf_p) = parse_events_text + yyless_macro_arg; \
2080 (yy_hold_char) = *(yy_c_buf_p); \
2081 *(yy_c_buf_p) = '\0'; \
2082 parse_events_leng = yyless_macro_arg; \
2083 } \
2084 while ( 0 )
2085
2086/* Accessor methods (get/set functions) to struct members. */
2087
2088/** Get the current line number.
2089 *
2090 */
2091int parse_events_get_lineno (void)
2092{
2093
2094 return parse_events_lineno;
2095}
2096
2097/** Get the input stream.
2098 *
2099 */
2100FILE *parse_events_get_in (void)
2101{
2102 return parse_events_in;
2103}
2104
2105/** Get the output stream.
2106 *
2107 */
2108FILE *parse_events_get_out (void)
2109{
2110 return parse_events_out;
2111}
2112
2113/** Get the length of the current token.
2114 *
2115 */
2116int parse_events_get_leng (void)
2117{
2118 return parse_events_leng;
2119}
2120
2121/** Get the current token.
2122 *
2123 */
2124
2125char *parse_events_get_text (void)
2126{
2127 return parse_events_text;
2128}
2129
2130/** Set the current line number.
2131 * @param line_number
2132 *
2133 */
2134void parse_events_set_lineno (int line_number )
2135{
2136
2137 parse_events_lineno = line_number;
2138}
2139
2140/** Set the input stream. This does not discard the current
2141 * input buffer.
2142 * @param in_str A readable stream.
2143 *
2144 * @see parse_events__switch_to_buffer
2145 */
2146void parse_events_set_in (FILE * in_str )
2147{
2148 parse_events_in = in_str ;
2149}
2150
2151void parse_events_set_out (FILE * out_str )
2152{
2153 parse_events_out = out_str ;
2154}
2155
2156int parse_events_get_debug (void)
2157{
2158 return parse_events__flex_debug;
2159}
2160
2161void parse_events_set_debug (int bdebug )
2162{
2163 parse_events__flex_debug = bdebug ;
2164}
2165
2166static int yy_init_globals (void)
2167{
2168 /* Initialization is the same as for the non-reentrant scanner.
2169 * This function is called from parse_events_lex_destroy(), so don't allocate here.
2170 */
2171
2172 (yy_buffer_stack) = 0;
2173 (yy_buffer_stack_top) = 0;
2174 (yy_buffer_stack_max) = 0;
2175 (yy_c_buf_p) = (char *) 0;
2176 (yy_init) = 0;
2177 (yy_start) = 0;
2178
2179/* Defined in main.c */
2180#ifdef YY_STDINIT
2181 parse_events_in = stdin;
2182 parse_events_out = stdout;
2183#else
2184 parse_events_in = (FILE *) 0;
2185 parse_events_out = (FILE *) 0;
2186#endif
2187
2188 /* For future reference: Set errno on error, since we are called by
2189 * parse_events_lex_init()
2190 */
2191 return 0;
2192}
2193
2194/* parse_events_lex_destroy is for both reentrant and non-reentrant scanners. */
2195int parse_events_lex_destroy (void)
2196{
2197
2198 /* Pop the buffer stack, destroying each element. */
2199 while(YY_CURRENT_BUFFER){
2200 parse_events__delete_buffer(YY_CURRENT_BUFFER );
2201 YY_CURRENT_BUFFER_LVALUE = NULL;
2202 parse_events_pop_buffer_state();
2203 }
2204
2205 /* Destroy the stack itself. */
2206 parse_events_free((yy_buffer_stack) );
2207 (yy_buffer_stack) = NULL;
2208
2209 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2210 * parse_events_lex() is called, initialization will occur. */
2211 yy_init_globals( );
2212
2213 return 0;
2214}
2215
2216/*
2217 * Internal utility routines.
2218 */
2219
2220#ifndef yytext_ptr
2221static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2222{
2223 register int i;
2224 for ( i = 0; i < n; ++i )
2225 s1[i] = s2[i];
2226}
2227#endif
2228
2229#ifdef YY_NEED_STRLEN
2230static int yy_flex_strlen (yyconst char * s )
2231{
2232 register int n;
2233 for ( n = 0; s[n]; ++n )
2234 ;
2235
2236 return n;
2237}
2238#endif
2239
2240void *parse_events_alloc (yy_size_t size )
2241{
2242 return (void *) malloc( size );
2243}
2244
2245void *parse_events_realloc (void * ptr, yy_size_t size )
2246{
2247 /* The cast to (char *) in the following accommodates both
2248 * implementations that use char* generic pointers, and those
2249 * that use void* generic pointers. It works with the latter
2250 * because both ANSI C and C++ allow castless assignment from
2251 * any pointer type to void*, and deal with argument conversions
2252 * as though doing an assignment.
2253 */
2254 return (void *) realloc( (char *) ptr, size );
2255}
2256
2257void parse_events_free (void * ptr )
2258{
2259 free( (char *) ptr ); /* see parse_events_realloc() for (char *) cast */
2260}
2261
2262#define YYTABLES_NAME "yytables"
2263
2264#line 121 "util/parse-events.l"
2265
2266
2267
2268int parse_events_wrap(void)
2269{
2270 return 1;
2271}
2272
diff --git a/tools/perf/util/parse-events-flex.h b/tools/perf/util/parse-events-flex.h
deleted file mode 100644
index ceb9b20d732c..000000000000
--- a/tools/perf/util/parse-events-flex.h
+++ /dev/null
@@ -1,316 +0,0 @@
1#ifndef parse_events_HEADER_H
2#define parse_events_HEADER_H 1
3#define parse_events_IN_HEADER 1
4
5#line 6 "util/parse-events-flex.h"
6
7#define YY_INT_ALIGNED short int
8
9/* A lexical scanner generated by flex */
10
11#define FLEX_SCANNER
12#define YY_FLEX_MAJOR_VERSION 2
13#define YY_FLEX_MINOR_VERSION 5
14#define YY_FLEX_SUBMINOR_VERSION 35
15#if YY_FLEX_SUBMINOR_VERSION > 0
16#define FLEX_BETA
17#endif
18
19/* First, we deal with platform-specific or compiler-specific issues. */
20
21/* begin standard C headers. */
22#include <stdio.h>
23#include <string.h>
24#include <errno.h>
25#include <stdlib.h>
26
27/* end standard C headers. */
28
29/* flex integer type definitions */
30
31#ifndef FLEXINT_H
32#define FLEXINT_H
33
34/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
35
36#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
37
38/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
39 * if you want the limit (max/min) macros for int types.
40 */
41#ifndef __STDC_LIMIT_MACROS
42#define __STDC_LIMIT_MACROS 1
43#endif
44
45#include <inttypes.h>
46typedef int8_t flex_int8_t;
47typedef uint8_t flex_uint8_t;
48typedef int16_t flex_int16_t;
49typedef uint16_t flex_uint16_t;
50typedef int32_t flex_int32_t;
51typedef uint32_t flex_uint32_t;
52#else
53typedef signed char flex_int8_t;
54typedef short int flex_int16_t;
55typedef int flex_int32_t;
56typedef unsigned char flex_uint8_t;
57typedef unsigned short int flex_uint16_t;
58typedef unsigned int flex_uint32_t;
59#endif /* ! C99 */
60
61/* Limits of integral types. */
62#ifndef INT8_MIN
63#define INT8_MIN (-128)
64#endif
65#ifndef INT16_MIN
66#define INT16_MIN (-32767-1)
67#endif
68#ifndef INT32_MIN
69#define INT32_MIN (-2147483647-1)
70#endif
71#ifndef INT8_MAX
72#define INT8_MAX (127)
73#endif
74#ifndef INT16_MAX
75#define INT16_MAX (32767)
76#endif
77#ifndef INT32_MAX
78#define INT32_MAX (2147483647)
79#endif
80#ifndef UINT8_MAX
81#define UINT8_MAX (255U)
82#endif
83#ifndef UINT16_MAX
84#define UINT16_MAX (65535U)
85#endif
86#ifndef UINT32_MAX
87#define UINT32_MAX (4294967295U)
88#endif
89
90#endif /* ! FLEXINT_H */
91
92#ifdef __cplusplus
93
94/* The "const" storage-class-modifier is valid. */
95#define YY_USE_CONST
96
97#else /* ! __cplusplus */
98
99/* C99 requires __STDC__ to be defined as 1. */
100#if defined (__STDC__)
101
102#define YY_USE_CONST
103
104#endif /* defined (__STDC__) */
105#endif /* ! __cplusplus */
106
107#ifdef YY_USE_CONST
108#define yyconst const
109#else
110#define yyconst
111#endif
112
113/* Size of default input buffer. */
114#ifndef YY_BUF_SIZE
115#define YY_BUF_SIZE 16384
116#endif
117
118#ifndef YY_TYPEDEF_YY_BUFFER_STATE
119#define YY_TYPEDEF_YY_BUFFER_STATE
120typedef struct yy_buffer_state *YY_BUFFER_STATE;
121#endif
122
123extern int parse_events_leng;
124
125extern FILE *parse_events_in, *parse_events_out;
126
127#ifndef YY_TYPEDEF_YY_SIZE_T
128#define YY_TYPEDEF_YY_SIZE_T
129typedef size_t yy_size_t;
130#endif
131
132#ifndef YY_STRUCT_YY_BUFFER_STATE
133#define YY_STRUCT_YY_BUFFER_STATE
134struct yy_buffer_state
135 {
136 FILE *yy_input_file;
137
138 char *yy_ch_buf; /* input buffer */
139 char *yy_buf_pos; /* current position in input buffer */
140
141 /* Size of input buffer in bytes, not including room for EOB
142 * characters.
143 */
144 yy_size_t yy_buf_size;
145
146 /* Number of characters read into yy_ch_buf, not including EOB
147 * characters.
148 */
149 int yy_n_chars;
150
151 /* Whether we "own" the buffer - i.e., we know we created it,
152 * and can realloc() it to grow it, and should free() it to
153 * delete it.
154 */
155 int yy_is_our_buffer;
156
157 /* Whether this is an "interactive" input source; if so, and
158 * if we're using stdio for input, then we want to use getc()
159 * instead of fread(), to make sure we stop fetching input after
160 * each newline.
161 */
162 int yy_is_interactive;
163
164 /* Whether we're considered to be at the beginning of a line.
165 * If so, '^' rules will be active on the next match, otherwise
166 * not.
167 */
168 int yy_at_bol;
169
170 int yy_bs_lineno; /**< The line count. */
171 int yy_bs_column; /**< The column count. */
172
173 /* Whether to try to fill the input buffer when we reach the
174 * end of it.
175 */
176 int yy_fill_buffer;
177
178 int yy_buffer_status;
179
180 };
181#endif /* !YY_STRUCT_YY_BUFFER_STATE */
182
183void parse_events_restart (FILE *input_file );
184void parse_events__switch_to_buffer (YY_BUFFER_STATE new_buffer );
185YY_BUFFER_STATE parse_events__create_buffer (FILE *file,int size );
186void parse_events__delete_buffer (YY_BUFFER_STATE b );
187void parse_events__flush_buffer (YY_BUFFER_STATE b );
188void parse_events_push_buffer_state (YY_BUFFER_STATE new_buffer );
189void parse_events_pop_buffer_state (void );
190
191YY_BUFFER_STATE parse_events__scan_buffer (char *base,yy_size_t size );
192YY_BUFFER_STATE parse_events__scan_string (yyconst char *yy_str );
193YY_BUFFER_STATE parse_events__scan_bytes (yyconst char *bytes,int len );
194
195void *parse_events_alloc (yy_size_t );
196void *parse_events_realloc (void *,yy_size_t );
197void parse_events_free (void * );
198
199/* Begin user sect3 */
200
201extern int parse_events_lineno;
202
203extern char *parse_events_text;
204#define yytext_ptr parse_events_text
205
206#ifdef YY_HEADER_EXPORT_START_CONDITIONS
207#define INITIAL 0
208
209#endif
210
211#ifndef YY_NO_UNISTD_H
212/* Special case for "unistd.h", since it is non-ANSI. We include it way
213 * down here because we want the user's section 1 to have been scanned first.
214 * The user has a chance to override it with an option.
215 */
216#include <unistd.h>
217#endif
218
219#ifndef YY_EXTRA_TYPE
220#define YY_EXTRA_TYPE void *
221#endif
222
223/* Accessor methods to globals.
224 These are made visible to non-reentrant scanners for convenience. */
225
226int parse_events_lex_destroy (void );
227
228int parse_events_get_debug (void );
229
230void parse_events_set_debug (int debug_flag );
231
232YY_EXTRA_TYPE parse_events_get_extra (void );
233
234void parse_events_set_extra (YY_EXTRA_TYPE user_defined );
235
236FILE *parse_events_get_in (void );
237
238void parse_events_set_in (FILE * in_str );
239
240FILE *parse_events_get_out (void );
241
242void parse_events_set_out (FILE * out_str );
243
244int parse_events_get_leng (void );
245
246char *parse_events_get_text (void );
247
248int parse_events_get_lineno (void );
249
250void parse_events_set_lineno (int line_number );
251
252/* Macros after this point can all be overridden by user definitions in
253 * section 1.
254 */
255
256#ifndef YY_SKIP_YYWRAP
257#ifdef __cplusplus
258extern "C" int parse_events_wrap (void );
259#else
260extern int parse_events_wrap (void );
261#endif
262#endif
263
264#ifndef yytext_ptr
265static void yy_flex_strncpy (char *,yyconst char *,int );
266#endif
267
268#ifdef YY_NEED_STRLEN
269static int yy_flex_strlen (yyconst char * );
270#endif
271
272#ifndef YY_NO_INPUT
273
274#endif
275
276/* Amount of stuff to slurp up with each read. */
277#ifndef YY_READ_BUF_SIZE
278#define YY_READ_BUF_SIZE 8192
279#endif
280
281/* Number of entries by which start-condition stack grows. */
282#ifndef YY_START_STACK_INCR
283#define YY_START_STACK_INCR 25
284#endif
285
286/* Default declaration of generated scanner - a define so the user can
287 * easily add parameters.
288 */
289#ifndef YY_DECL
290#define YY_DECL_IS_OURS 1
291
292extern int parse_events_lex (void);
293
294#define YY_DECL int parse_events_lex (void)
295#endif /* !YY_DECL */
296
297/* yy_get_previous_state - get the state just before the EOB char was reached */
298
299#undef YY_NEW_FILE
300#undef YY_FLUSH_BUFFER
301#undef yy_set_bol
302#undef yy_new_buffer
303#undef yy_set_interactive
304#undef YY_DO_BEFORE_ACTION
305
306#ifdef YY_DECL_IS_OURS
307#undef YY_DECL_IS_OURS
308#undef YY_DECL
309#endif
310
311#line 121 "util/parse-events.l"
312
313
314#line 315 "util/parse-events-flex.h"
315#undef parse_events_IN_HEADER
316#endif /* parse_events_HEADER_H */
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index ab9eca120feb..05d766e3ecb5 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -67,6 +67,7 @@ cache-misses { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); }
67branch-instructions|branches { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); } 67branch-instructions|branches { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); }
68branch-misses { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); } 68branch-misses { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); }
69bus-cycles { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); } 69bus-cycles { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); }
70ref-cycles { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_REF_CPU_CYCLES); }
70cpu-clock { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); } 71cpu-clock { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); }
71task-clock { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); } 72task-clock { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); }
72page-faults|faults { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); } 73page-faults|faults { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); }
diff --git a/tools/perf/util/pmu-bison.c b/tools/perf/util/pmu-bison.c
deleted file mode 100644
index 343521ec589f..000000000000
--- a/tools/perf/util/pmu-bison.c
+++ /dev/null
@@ -1,1663 +0,0 @@
1/* A Bison parser, made by GNU Bison 2.4.3. */
2
3/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2009, 2010 Free Software Foundation, Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21/* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34/* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37/* All symbols defined below should begin with yy or YY, to avoid
38 infringing on user name space. This should be done even for local
39 variables, as they might otherwise be expanded by user macros.
40 There are some unavoidable exceptions within include files to
41 define necessary library symbols; they are noted "INFRINGES ON
42 USER NAME SPACE" below. */
43
44/* Identify Bison output. */
45#define YYBISON 1
46
47/* Bison version. */
48#define YYBISON_VERSION "2.4.3"
49
50/* Skeleton name. */
51#define YYSKELETON_NAME "yacc.c"
52
53/* Pure parsers. */
54#define YYPURE 0
55
56/* Push parsers. */
57#define YYPUSH 0
58
59/* Pull parsers. */
60#define YYPULL 1
61
62/* Using locations. */
63#define YYLSP_NEEDED 0
64
65/* Substitute the variable and function names. */
66#define yyparse perf_pmu_parse
67#define yylex perf_pmu_lex
68#define yyerror perf_pmu_error
69#define yylval perf_pmu_lval
70#define yychar perf_pmu_char
71#define yydebug perf_pmu_debug
72#define yynerrs perf_pmu_nerrs
73
74
75/* Copy the first part of user declarations. */
76
77/* Line 189 of yacc.c */
78#line 6 "util/pmu.y"
79
80
81#include <linux/compiler.h>
82#include <linux/list.h>
83#include <linux/bitmap.h>
84#include <string.h>
85#include "pmu.h"
86
87extern int perf_pmu_lex (void);
88
89#define ABORT_ON(val) \
90do { \
91 if (val) \
92 YYABORT; \
93} while (0)
94
95
96
97/* Line 189 of yacc.c */
98#line 99 "util/pmu-bison.c"
99
100/* Enabling traces. */
101#ifndef YYDEBUG
102# define YYDEBUG 0
103#endif
104
105/* Enabling verbose error messages. */
106#ifdef YYERROR_VERBOSE
107# undef YYERROR_VERBOSE
108# define YYERROR_VERBOSE 1
109#else
110# define YYERROR_VERBOSE 0
111#endif
112
113/* Enabling the token table. */
114#ifndef YYTOKEN_TABLE
115# define YYTOKEN_TABLE 0
116#endif
117
118
119/* Tokens. */
120#ifndef YYTOKENTYPE
121# define YYTOKENTYPE
122 /* Put the tokens into the symbol table, so that GDB and other debuggers
123 know about them. */
124 enum yytokentype {
125 PP_CONFIG = 258,
126 PP_CONFIG1 = 259,
127 PP_CONFIG2 = 260,
128 PP_VALUE = 261,
129 PP_ERROR = 262
130 };
131#endif
132
133
134
135#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
136typedef union YYSTYPE
137{
138
139/* Line 214 of yacc.c */
140#line 31 "util/pmu.y"
141
142 unsigned long num;
143 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
144
145
146
147/* Line 214 of yacc.c */
148#line 149 "util/pmu-bison.c"
149} YYSTYPE;
150# define YYSTYPE_IS_TRIVIAL 1
151# define yystype YYSTYPE /* obsolescent; will be withdrawn */
152# define YYSTYPE_IS_DECLARED 1
153#endif
154
155
156/* Copy the second part of user declarations. */
157
158
159/* Line 264 of yacc.c */
160#line 161 "util/pmu-bison.c"
161
162#ifdef short
163# undef short
164#endif
165
166#ifdef YYTYPE_UINT8
167typedef YYTYPE_UINT8 yytype_uint8;
168#else
169typedef unsigned char yytype_uint8;
170#endif
171
172#ifdef YYTYPE_INT8
173typedef YYTYPE_INT8 yytype_int8;
174#elif (defined __STDC__ || defined __C99__FUNC__ \
175 || defined __cplusplus || defined _MSC_VER)
176typedef signed char yytype_int8;
177#else
178typedef short int yytype_int8;
179#endif
180
181#ifdef YYTYPE_UINT16
182typedef YYTYPE_UINT16 yytype_uint16;
183#else
184typedef unsigned short int yytype_uint16;
185#endif
186
187#ifdef YYTYPE_INT16
188typedef YYTYPE_INT16 yytype_int16;
189#else
190typedef short int yytype_int16;
191#endif
192
193#ifndef YYSIZE_T
194# ifdef __SIZE_TYPE__
195# define YYSIZE_T __SIZE_TYPE__
196# elif defined size_t
197# define YYSIZE_T size_t
198# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
199 || defined __cplusplus || defined _MSC_VER)
200# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
201# define YYSIZE_T size_t
202# else
203# define YYSIZE_T unsigned int
204# endif
205#endif
206
207#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
208
209#ifndef YY_
210# if defined YYENABLE_NLS && YYENABLE_NLS
211# if ENABLE_NLS
212# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
213# define YY_(msgid) dgettext ("bison-runtime", msgid)
214# endif
215# endif
216# ifndef YY_
217# define YY_(msgid) msgid
218# endif
219#endif
220
221/* Suppress unused-variable warnings by "using" E. */
222#if ! defined lint || defined __GNUC__
223# define YYUSE(e) ((void) (e))
224#else
225# define YYUSE(e) /* empty */
226#endif
227
228/* Identity function, used to suppress warnings about constant conditions. */
229#ifndef lint
230# define YYID(n) (n)
231#else
232#if (defined __STDC__ || defined __C99__FUNC__ \
233 || defined __cplusplus || defined _MSC_VER)
234static int
235YYID (int yyi)
236#else
237static int
238YYID (yyi)
239 int yyi;
240#endif
241{
242 return yyi;
243}
244#endif
245
246#if ! defined yyoverflow || YYERROR_VERBOSE
247
248/* The parser invokes alloca or malloc; define the necessary symbols. */
249
250# ifdef YYSTACK_USE_ALLOCA
251# if YYSTACK_USE_ALLOCA
252# ifdef __GNUC__
253# define YYSTACK_ALLOC __builtin_alloca
254# elif defined __BUILTIN_VA_ARG_INCR
255# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
256# elif defined _AIX
257# define YYSTACK_ALLOC __alloca
258# elif defined _MSC_VER
259# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
260# define alloca _alloca
261# else
262# define YYSTACK_ALLOC alloca
263# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
264 || defined __cplusplus || defined _MSC_VER)
265# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
266# ifndef _STDLIB_H
267# define _STDLIB_H 1
268# endif
269# endif
270# endif
271# endif
272# endif
273
274# ifdef YYSTACK_ALLOC
275 /* Pacify GCC's `empty if-body' warning. */
276# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
277# ifndef YYSTACK_ALLOC_MAXIMUM
278 /* The OS might guarantee only one guard page at the bottom of the stack,
279 and a page size can be as small as 4096 bytes. So we cannot safely
280 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
281 to allow for a few compiler-allocated temporary stack slots. */
282# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
283# endif
284# else
285# define YYSTACK_ALLOC YYMALLOC
286# define YYSTACK_FREE YYFREE
287# ifndef YYSTACK_ALLOC_MAXIMUM
288# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
289# endif
290# if (defined __cplusplus && ! defined _STDLIB_H \
291 && ! ((defined YYMALLOC || defined malloc) \
292 && (defined YYFREE || defined free)))
293# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
294# ifndef _STDLIB_H
295# define _STDLIB_H 1
296# endif
297# endif
298# ifndef YYMALLOC
299# define YYMALLOC malloc
300# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
301 || defined __cplusplus || defined _MSC_VER)
302void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
303# endif
304# endif
305# ifndef YYFREE
306# define YYFREE free
307# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
308 || defined __cplusplus || defined _MSC_VER)
309void free (void *); /* INFRINGES ON USER NAME SPACE */
310# endif
311# endif
312# endif
313#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
314
315
316#if (! defined yyoverflow \
317 && (! defined __cplusplus \
318 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
319
320/* A type that is properly aligned for any stack member. */
321union yyalloc
322{
323 yytype_int16 yyss_alloc;
324 YYSTYPE yyvs_alloc;
325};
326
327/* The size of the maximum gap between one aligned stack and the next. */
328# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
329
330/* The size of an array large to enough to hold all stacks, each with
331 N elements. */
332# define YYSTACK_BYTES(N) \
333 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
334 + YYSTACK_GAP_MAXIMUM)
335
336/* Copy COUNT objects from FROM to TO. The source and destination do
337 not overlap. */
338# ifndef YYCOPY
339# if defined __GNUC__ && 1 < __GNUC__
340# define YYCOPY(To, From, Count) \
341 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
342# else
343# define YYCOPY(To, From, Count) \
344 do \
345 { \
346 YYSIZE_T yyi; \
347 for (yyi = 0; yyi < (Count); yyi++) \
348 (To)[yyi] = (From)[yyi]; \
349 } \
350 while (YYID (0))
351# endif
352# endif
353
354/* Relocate STACK from its old location to the new one. The
355 local variables YYSIZE and YYSTACKSIZE give the old and new number of
356 elements in the stack, and YYPTR gives the new location of the
357 stack. Advance YYPTR to a properly aligned location for the next
358 stack. */
359# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
360 do \
361 { \
362 YYSIZE_T yynewbytes; \
363 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
364 Stack = &yyptr->Stack_alloc; \
365 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
366 yyptr += yynewbytes / sizeof (*yyptr); \
367 } \
368 while (YYID (0))
369
370#endif
371
372/* YYFINAL -- State number of the termination state. */
373#define YYFINAL 9
374/* YYLAST -- Last index in YYTABLE. */
375#define YYLAST 17
376
377/* YYNTOKENS -- Number of terminals. */
378#define YYNTOKENS 11
379/* YYNNTS -- Number of nonterminals. */
380#define YYNNTS 5
381/* YYNRULES -- Number of rules. */
382#define YYNRULES 10
383/* YYNRULES -- Number of states. */
384#define YYNSTATES 20
385
386/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
387#define YYUNDEFTOK 2
388#define YYMAXUTOK 262
389
390#define YYTRANSLATE(YYX) \
391 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
392
393/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
394static const yytype_uint8 yytranslate[] =
395{
396 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
397 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
398 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
399 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
400 2, 2, 2, 2, 9, 10, 2, 2, 2, 2,
401 2, 2, 2, 2, 2, 2, 2, 2, 8, 2,
402 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
403 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
404 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
405 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
406 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
407 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
408 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
409 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
410 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
411 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
412 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
413 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
414 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
415 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
416 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
417 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
418 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
419 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
420 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
421 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
422 5, 6, 7
423};
424
425#if YYDEBUG
426/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
427 YYRHS. */
428static const yytype_uint8 yyprhs[] =
429{
430 0, 0, 3, 6, 8, 12, 16, 20, 24, 26,
431 30
432};
433
434/* YYRHS -- A `-1'-separated list of the rules' RHS. */
435static const yytype_int8 yyrhs[] =
436{
437 12, 0, -1, 12, 13, -1, 13, -1, 3, 8,
438 14, -1, 4, 8, 14, -1, 5, 8, 14, -1,
439 14, 9, 15, -1, 15, -1, 6, 10, 6, -1,
440 6, -1
441};
442
443/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
444static const yytype_uint8 yyrline[] =
445{
446 0, 39, 39, 41, 44, 51, 58, 66, 71, 77,
447 82
448};
449#endif
450
451#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
452/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
453 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
454static const char *const yytname[] =
455{
456 "$end", "error", "$undefined", "PP_CONFIG", "PP_CONFIG1", "PP_CONFIG2",
457 "PP_VALUE", "PP_ERROR", "':'", "','", "'-'", "$accept", "format",
458 "format_term", "bits", "bit_term", 0
459};
460#endif
461
462# ifdef YYPRINT
463/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
464 token YYLEX-NUM. */
465static const yytype_uint16 yytoknum[] =
466{
467 0, 256, 257, 258, 259, 260, 261, 262, 58, 44,
468 45
469};
470# endif
471
472/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
473static const yytype_uint8 yyr1[] =
474{
475 0, 11, 12, 12, 13, 13, 13, 14, 14, 15,
476 15
477};
478
479/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
480static const yytype_uint8 yyr2[] =
481{
482 0, 2, 2, 1, 3, 3, 3, 3, 1, 3,
483 1
484};
485
486/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
487 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
488 means the default is an error. */
489static const yytype_uint8 yydefact[] =
490{
491 0, 0, 0, 0, 0, 3, 0, 0, 0, 1,
492 2, 10, 4, 8, 5, 6, 0, 0, 9, 7
493};
494
495/* YYDEFGOTO[NTERM-NUM]. */
496static const yytype_int8 yydefgoto[] =
497{
498 -1, 4, 5, 12, 13
499};
500
501/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
502 STATE-NUM. */
503#define YYPACT_NINF -7
504static const yytype_int8 yypact[] =
505{
506 3, 1, 2, 4, 0, -7, 5, 5, 5, -7,
507 -7, 6, 8, -7, 8, 8, 7, 5, -7, -7
508};
509
510/* YYPGOTO[NTERM-NUM]. */
511static const yytype_int8 yypgoto[] =
512{
513 -7, -7, 10, -6, -2
514};
515
516/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
517 positive, shift that token. If negative, reduce the rule which
518 number is the opposite. If zero, do what YYDEFACT says.
519 If YYTABLE_NINF, syntax error. */
520#define YYTABLE_NINF -1
521static const yytype_uint8 yytable[] =
522{
523 9, 14, 15, 1, 2, 3, 1, 2, 3, 6,
524 7, 11, 8, 18, 10, 19, 16, 17
525};
526
527static const yytype_uint8 yycheck[] =
528{
529 0, 7, 8, 3, 4, 5, 3, 4, 5, 8,
530 8, 6, 8, 6, 4, 17, 10, 9
531};
532
533/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
534 symbol of state STATE-NUM. */
535static const yytype_uint8 yystos[] =
536{
537 0, 3, 4, 5, 12, 13, 8, 8, 8, 0,
538 13, 6, 14, 15, 14, 14, 10, 9, 6, 15
539};
540
541#define yyerrok (yyerrstatus = 0)
542#define yyclearin (yychar = YYEMPTY)
543#define YYEMPTY (-2)
544#define YYEOF 0
545
546#define YYACCEPT goto yyacceptlab
547#define YYABORT goto yyabortlab
548#define YYERROR goto yyerrorlab
549
550
551/* Like YYERROR except do call yyerror. This remains here temporarily
552 to ease the transition to the new meaning of YYERROR, for GCC.
553 Once GCC version 2 has supplanted version 1, this can go. However,
554 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
555 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
556 discussed. */
557
558#define YYFAIL goto yyerrlab
559#if defined YYFAIL
560 /* This is here to suppress warnings from the GCC cpp's
561 -Wunused-macros. Normally we don't worry about that warning, but
562 some users do, and we want to make it easy for users to remove
563 YYFAIL uses, which will produce warnings from Bison 2.5. */
564#endif
565
566#define YYRECOVERING() (!!yyerrstatus)
567
568#define YYBACKUP(Token, Value) \
569do \
570 if (yychar == YYEMPTY && yylen == 1) \
571 { \
572 yychar = (Token); \
573 yylval = (Value); \
574 yytoken = YYTRANSLATE (yychar); \
575 YYPOPSTACK (1); \
576 goto yybackup; \
577 } \
578 else \
579 { \
580 yyerror (format, name, YY_("syntax error: cannot back up")); \
581 YYERROR; \
582 } \
583while (YYID (0))
584
585
586#define YYTERROR 1
587#define YYERRCODE 256
588
589
590/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
591 If N is 0, then set CURRENT to the empty location which ends
592 the previous symbol: RHS[0] (always defined). */
593
594#define YYRHSLOC(Rhs, K) ((Rhs)[K])
595#ifndef YYLLOC_DEFAULT
596# define YYLLOC_DEFAULT(Current, Rhs, N) \
597 do \
598 if (YYID (N)) \
599 { \
600 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
601 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
602 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
603 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
604 } \
605 else \
606 { \
607 (Current).first_line = (Current).last_line = \
608 YYRHSLOC (Rhs, 0).last_line; \
609 (Current).first_column = (Current).last_column = \
610 YYRHSLOC (Rhs, 0).last_column; \
611 } \
612 while (YYID (0))
613#endif
614
615
616/* YY_LOCATION_PRINT -- Print the location on the stream.
617 This macro was not mandated originally: define only if we know
618 we won't break user code: when these are the locations we know. */
619
620#ifndef YY_LOCATION_PRINT
621# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
622# define YY_LOCATION_PRINT(File, Loc) \
623 fprintf (File, "%d.%d-%d.%d", \
624 (Loc).first_line, (Loc).first_column, \
625 (Loc).last_line, (Loc).last_column)
626# else
627# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
628# endif
629#endif
630
631
632/* YYLEX -- calling `yylex' with the right arguments. */
633
634#ifdef YYLEX_PARAM
635# define YYLEX yylex (YYLEX_PARAM)
636#else
637# define YYLEX yylex ()
638#endif
639
640/* Enable debugging if requested. */
641#if YYDEBUG
642
643# ifndef YYFPRINTF
644# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
645# define YYFPRINTF fprintf
646# endif
647
648# define YYDPRINTF(Args) \
649do { \
650 if (yydebug) \
651 YYFPRINTF Args; \
652} while (YYID (0))
653
654# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
655do { \
656 if (yydebug) \
657 { \
658 YYFPRINTF (stderr, "%s ", Title); \
659 yy_symbol_print (stderr, \
660 Type, Value, format, name); \
661 YYFPRINTF (stderr, "\n"); \
662 } \
663} while (YYID (0))
664
665
666/*--------------------------------.
667| Print this symbol on YYOUTPUT. |
668`--------------------------------*/
669
670/*ARGSUSED*/
671#if (defined __STDC__ || defined __C99__FUNC__ \
672 || defined __cplusplus || defined _MSC_VER)
673static void
674yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *format, char *name)
675#else
676static void
677yy_symbol_value_print (yyoutput, yytype, yyvaluep, format, name)
678 FILE *yyoutput;
679 int yytype;
680 YYSTYPE const * const yyvaluep;
681 struct list_head *format;
682 char *name;
683#endif
684{
685 if (!yyvaluep)
686 return;
687 YYUSE (format);
688 YYUSE (name);
689# ifdef YYPRINT
690 if (yytype < YYNTOKENS)
691 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
692# else
693 YYUSE (yyoutput);
694# endif
695 switch (yytype)
696 {
697 default:
698 break;
699 }
700}
701
702
703/*--------------------------------.
704| Print this symbol on YYOUTPUT. |
705`--------------------------------*/
706
707#if (defined __STDC__ || defined __C99__FUNC__ \
708 || defined __cplusplus || defined _MSC_VER)
709static void
710yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *format, char *name)
711#else
712static void
713yy_symbol_print (yyoutput, yytype, yyvaluep, format, name)
714 FILE *yyoutput;
715 int yytype;
716 YYSTYPE const * const yyvaluep;
717 struct list_head *format;
718 char *name;
719#endif
720{
721 if (yytype < YYNTOKENS)
722 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
723 else
724 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
725
726 yy_symbol_value_print (yyoutput, yytype, yyvaluep, format, name);
727 YYFPRINTF (yyoutput, ")");
728}
729
730/*------------------------------------------------------------------.
731| yy_stack_print -- Print the state stack from its BOTTOM up to its |
732| TOP (included). |
733`------------------------------------------------------------------*/
734
735#if (defined __STDC__ || defined __C99__FUNC__ \
736 || defined __cplusplus || defined _MSC_VER)
737static void
738yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
739#else
740static void
741yy_stack_print (yybottom, yytop)
742 yytype_int16 *yybottom;
743 yytype_int16 *yytop;
744#endif
745{
746 YYFPRINTF (stderr, "Stack now");
747 for (; yybottom <= yytop; yybottom++)
748 {
749 int yybot = *yybottom;
750 YYFPRINTF (stderr, " %d", yybot);
751 }
752 YYFPRINTF (stderr, "\n");
753}
754
755# define YY_STACK_PRINT(Bottom, Top) \
756do { \
757 if (yydebug) \
758 yy_stack_print ((Bottom), (Top)); \
759} while (YYID (0))
760
761
762/*------------------------------------------------.
763| Report that the YYRULE is going to be reduced. |
764`------------------------------------------------*/
765
766#if (defined __STDC__ || defined __C99__FUNC__ \
767 || defined __cplusplus || defined _MSC_VER)
768static void
769yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct list_head *format, char *name)
770#else
771static void
772yy_reduce_print (yyvsp, yyrule, format, name)
773 YYSTYPE *yyvsp;
774 int yyrule;
775 struct list_head *format;
776 char *name;
777#endif
778{
779 int yynrhs = yyr2[yyrule];
780 int yyi;
781 unsigned long int yylno = yyrline[yyrule];
782 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
783 yyrule - 1, yylno);
784 /* The symbols being reduced. */
785 for (yyi = 0; yyi < yynrhs; yyi++)
786 {
787 YYFPRINTF (stderr, " $%d = ", yyi + 1);
788 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
789 &(yyvsp[(yyi + 1) - (yynrhs)])
790 , format, name);
791 YYFPRINTF (stderr, "\n");
792 }
793}
794
795# define YY_REDUCE_PRINT(Rule) \
796do { \
797 if (yydebug) \
798 yy_reduce_print (yyvsp, Rule, format, name); \
799} while (YYID (0))
800
801/* Nonzero means print parse trace. It is left uninitialized so that
802 multiple parsers can coexist. */
803int yydebug;
804#else /* !YYDEBUG */
805# define YYDPRINTF(Args)
806# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
807# define YY_STACK_PRINT(Bottom, Top)
808# define YY_REDUCE_PRINT(Rule)
809#endif /* !YYDEBUG */
810
811
812/* YYINITDEPTH -- initial size of the parser's stacks. */
813#ifndef YYINITDEPTH
814# define YYINITDEPTH 200
815#endif
816
817/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
818 if the built-in stack extension method is used).
819
820 Do not make this value too large; the results are undefined if
821 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
822 evaluated with infinite-precision integer arithmetic. */
823
824#ifndef YYMAXDEPTH
825# define YYMAXDEPTH 10000
826#endif
827
828
829
830#if YYERROR_VERBOSE
831
832# ifndef yystrlen
833# if defined __GLIBC__ && defined _STRING_H
834# define yystrlen strlen
835# else
836/* Return the length of YYSTR. */
837#if (defined __STDC__ || defined __C99__FUNC__ \
838 || defined __cplusplus || defined _MSC_VER)
839static YYSIZE_T
840yystrlen (const char *yystr)
841#else
842static YYSIZE_T
843yystrlen (yystr)
844 const char *yystr;
845#endif
846{
847 YYSIZE_T yylen;
848 for (yylen = 0; yystr[yylen]; yylen++)
849 continue;
850 return yylen;
851}
852# endif
853# endif
854
855# ifndef yystpcpy
856# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
857# define yystpcpy stpcpy
858# else
859/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
860 YYDEST. */
861#if (defined __STDC__ || defined __C99__FUNC__ \
862 || defined __cplusplus || defined _MSC_VER)
863static char *
864yystpcpy (char *yydest, const char *yysrc)
865#else
866static char *
867yystpcpy (yydest, yysrc)
868 char *yydest;
869 const char *yysrc;
870#endif
871{
872 char *yyd = yydest;
873 const char *yys = yysrc;
874
875 while ((*yyd++ = *yys++) != '\0')
876 continue;
877
878 return yyd - 1;
879}
880# endif
881# endif
882
883# ifndef yytnamerr
884/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
885 quotes and backslashes, so that it's suitable for yyerror. The
886 heuristic is that double-quoting is unnecessary unless the string
887 contains an apostrophe, a comma, or backslash (other than
888 backslash-backslash). YYSTR is taken from yytname. If YYRES is
889 null, do not copy; instead, return the length of what the result
890 would have been. */
891static YYSIZE_T
892yytnamerr (char *yyres, const char *yystr)
893{
894 if (*yystr == '"')
895 {
896 YYSIZE_T yyn = 0;
897 char const *yyp = yystr;
898
899 for (;;)
900 switch (*++yyp)
901 {
902 case '\'':
903 case ',':
904 goto do_not_strip_quotes;
905
906 case '\\':
907 if (*++yyp != '\\')
908 goto do_not_strip_quotes;
909 /* Fall through. */
910 default:
911 if (yyres)
912 yyres[yyn] = *yyp;
913 yyn++;
914 break;
915
916 case '"':
917 if (yyres)
918 yyres[yyn] = '\0';
919 return yyn;
920 }
921 do_not_strip_quotes: ;
922 }
923
924 if (! yyres)
925 return yystrlen (yystr);
926
927 return yystpcpy (yyres, yystr) - yyres;
928}
929# endif
930
931/* Copy into YYRESULT an error message about the unexpected token
932 YYCHAR while in state YYSTATE. Return the number of bytes copied,
933 including the terminating null byte. If YYRESULT is null, do not
934 copy anything; just return the number of bytes that would be
935 copied. As a special case, return 0 if an ordinary "syntax error"
936 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
937 size calculation. */
938static YYSIZE_T
939yysyntax_error (char *yyresult, int yystate, int yychar)
940{
941 int yyn = yypact[yystate];
942
943 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
944 return 0;
945 else
946 {
947 int yytype = YYTRANSLATE (yychar);
948 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
949 YYSIZE_T yysize = yysize0;
950 YYSIZE_T yysize1;
951 int yysize_overflow = 0;
952 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
953 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
954 int yyx;
955
956# if 0
957 /* This is so xgettext sees the translatable formats that are
958 constructed on the fly. */
959 YY_("syntax error, unexpected %s");
960 YY_("syntax error, unexpected %s, expecting %s");
961 YY_("syntax error, unexpected %s, expecting %s or %s");
962 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
963 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
964# endif
965 char *yyfmt;
966 char const *yyf;
967 static char const yyunexpected[] = "syntax error, unexpected %s";
968 static char const yyexpecting[] = ", expecting %s";
969 static char const yyor[] = " or %s";
970 char yyformat[sizeof yyunexpected
971 + sizeof yyexpecting - 1
972 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
973 * (sizeof yyor - 1))];
974 char const *yyprefix = yyexpecting;
975
976 /* Start YYX at -YYN if negative to avoid negative indexes in
977 YYCHECK. */
978 int yyxbegin = yyn < 0 ? -yyn : 0;
979
980 /* Stay within bounds of both yycheck and yytname. */
981 int yychecklim = YYLAST - yyn + 1;
982 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
983 int yycount = 1;
984
985 yyarg[0] = yytname[yytype];
986 yyfmt = yystpcpy (yyformat, yyunexpected);
987
988 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
989 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
990 {
991 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
992 {
993 yycount = 1;
994 yysize = yysize0;
995 yyformat[sizeof yyunexpected - 1] = '\0';
996 break;
997 }
998 yyarg[yycount++] = yytname[yyx];
999 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1000 yysize_overflow |= (yysize1 < yysize);
1001 yysize = yysize1;
1002 yyfmt = yystpcpy (yyfmt, yyprefix);
1003 yyprefix = yyor;
1004 }
1005
1006 yyf = YY_(yyformat);
1007 yysize1 = yysize + yystrlen (yyf);
1008 yysize_overflow |= (yysize1 < yysize);
1009 yysize = yysize1;
1010
1011 if (yysize_overflow)
1012 return YYSIZE_MAXIMUM;
1013
1014 if (yyresult)
1015 {
1016 /* Avoid sprintf, as that infringes on the user's name space.
1017 Don't have undefined behavior even if the translation
1018 produced a string with the wrong number of "%s"s. */
1019 char *yyp = yyresult;
1020 int yyi = 0;
1021 while ((*yyp = *yyf) != '\0')
1022 {
1023 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1024 {
1025 yyp += yytnamerr (yyp, yyarg[yyi++]);
1026 yyf += 2;
1027 }
1028 else
1029 {
1030 yyp++;
1031 yyf++;
1032 }
1033 }
1034 }
1035 return yysize;
1036 }
1037}
1038#endif /* YYERROR_VERBOSE */
1039
1040
1041/*-----------------------------------------------.
1042| Release the memory associated to this symbol. |
1043`-----------------------------------------------*/
1044
1045/*ARGSUSED*/
1046#if (defined __STDC__ || defined __C99__FUNC__ \
1047 || defined __cplusplus || defined _MSC_VER)
1048static void
1049yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct list_head *format, char *name)
1050#else
1051static void
1052yydestruct (yymsg, yytype, yyvaluep, format, name)
1053 const char *yymsg;
1054 int yytype;
1055 YYSTYPE *yyvaluep;
1056 struct list_head *format;
1057 char *name;
1058#endif
1059{
1060 YYUSE (yyvaluep);
1061 YYUSE (format);
1062 YYUSE (name);
1063
1064 if (!yymsg)
1065 yymsg = "Deleting";
1066 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1067
1068 switch (yytype)
1069 {
1070
1071 default:
1072 break;
1073 }
1074}
1075
1076/* Prevent warnings from -Wmissing-prototypes. */
1077#ifdef YYPARSE_PARAM
1078#if defined __STDC__ || defined __cplusplus
1079int yyparse (void *YYPARSE_PARAM);
1080#else
1081int yyparse ();
1082#endif
1083#else /* ! YYPARSE_PARAM */
1084#if defined __STDC__ || defined __cplusplus
1085int yyparse (struct list_head *format, char *name);
1086#else
1087int yyparse ();
1088#endif
1089#endif /* ! YYPARSE_PARAM */
1090
1091
1092/* The lookahead symbol. */
1093int yychar;
1094
1095/* The semantic value of the lookahead symbol. */
1096YYSTYPE yylval;
1097
1098/* Number of syntax errors so far. */
1099int yynerrs;
1100
1101
1102
1103/*-------------------------.
1104| yyparse or yypush_parse. |
1105`-------------------------*/
1106
1107#ifdef YYPARSE_PARAM
1108#if (defined __STDC__ || defined __C99__FUNC__ \
1109 || defined __cplusplus || defined _MSC_VER)
1110int
1111yyparse (void *YYPARSE_PARAM)
1112#else
1113int
1114yyparse (YYPARSE_PARAM)
1115 void *YYPARSE_PARAM;
1116#endif
1117#else /* ! YYPARSE_PARAM */
1118#if (defined __STDC__ || defined __C99__FUNC__ \
1119 || defined __cplusplus || defined _MSC_VER)
1120int
1121yyparse (struct list_head *format, char *name)
1122#else
1123int
1124yyparse (format, name)
1125 struct list_head *format;
1126 char *name;
1127#endif
1128#endif
1129{
1130
1131
1132 int yystate;
1133 /* Number of tokens to shift before error messages enabled. */
1134 int yyerrstatus;
1135
1136 /* The stacks and their tools:
1137 `yyss': related to states.
1138 `yyvs': related to semantic values.
1139
1140 Refer to the stacks thru separate pointers, to allow yyoverflow
1141 to reallocate them elsewhere. */
1142
1143 /* The state stack. */
1144 yytype_int16 yyssa[YYINITDEPTH];
1145 yytype_int16 *yyss;
1146 yytype_int16 *yyssp;
1147
1148 /* The semantic value stack. */
1149 YYSTYPE yyvsa[YYINITDEPTH];
1150 YYSTYPE *yyvs;
1151 YYSTYPE *yyvsp;
1152
1153 YYSIZE_T yystacksize;
1154
1155 int yyn;
1156 int yyresult;
1157 /* Lookahead token as an internal (translated) token number. */
1158 int yytoken;
1159 /* The variables used to return semantic value and location from the
1160 action routines. */
1161 YYSTYPE yyval;
1162
1163#if YYERROR_VERBOSE
1164 /* Buffer for error messages, and its allocated size. */
1165 char yymsgbuf[128];
1166 char *yymsg = yymsgbuf;
1167 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1168#endif
1169
1170#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1171
1172 /* The number of symbols on the RHS of the reduced rule.
1173 Keep to zero when no symbol should be popped. */
1174 int yylen = 0;
1175
1176 yytoken = 0;
1177 yyss = yyssa;
1178 yyvs = yyvsa;
1179 yystacksize = YYINITDEPTH;
1180
1181 YYDPRINTF ((stderr, "Starting parse\n"));
1182
1183 yystate = 0;
1184 yyerrstatus = 0;
1185 yynerrs = 0;
1186 yychar = YYEMPTY; /* Cause a token to be read. */
1187
1188 /* Initialize stack pointers.
1189 Waste one element of value and location stack
1190 so that they stay on the same level as the state stack.
1191 The wasted elements are never initialized. */
1192 yyssp = yyss;
1193 yyvsp = yyvs;
1194
1195 goto yysetstate;
1196
1197/*------------------------------------------------------------.
1198| yynewstate -- Push a new state, which is found in yystate. |
1199`------------------------------------------------------------*/
1200 yynewstate:
1201 /* In all cases, when you get here, the value and location stacks
1202 have just been pushed. So pushing a state here evens the stacks. */
1203 yyssp++;
1204
1205 yysetstate:
1206 *yyssp = yystate;
1207
1208 if (yyss + yystacksize - 1 <= yyssp)
1209 {
1210 /* Get the current used size of the three stacks, in elements. */
1211 YYSIZE_T yysize = yyssp - yyss + 1;
1212
1213#ifdef yyoverflow
1214 {
1215 /* Give user a chance to reallocate the stack. Use copies of
1216 these so that the &'s don't force the real ones into
1217 memory. */
1218 YYSTYPE *yyvs1 = yyvs;
1219 yytype_int16 *yyss1 = yyss;
1220
1221 /* Each stack pointer address is followed by the size of the
1222 data in use in that stack, in bytes. This used to be a
1223 conditional around just the two extra args, but that might
1224 be undefined if yyoverflow is a macro. */
1225 yyoverflow (YY_("memory exhausted"),
1226 &yyss1, yysize * sizeof (*yyssp),
1227 &yyvs1, yysize * sizeof (*yyvsp),
1228 &yystacksize);
1229
1230 yyss = yyss1;
1231 yyvs = yyvs1;
1232 }
1233#else /* no yyoverflow */
1234# ifndef YYSTACK_RELOCATE
1235 goto yyexhaustedlab;
1236# else
1237 /* Extend the stack our own way. */
1238 if (YYMAXDEPTH <= yystacksize)
1239 goto yyexhaustedlab;
1240 yystacksize *= 2;
1241 if (YYMAXDEPTH < yystacksize)
1242 yystacksize = YYMAXDEPTH;
1243
1244 {
1245 yytype_int16 *yyss1 = yyss;
1246 union yyalloc *yyptr =
1247 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1248 if (! yyptr)
1249 goto yyexhaustedlab;
1250 YYSTACK_RELOCATE (yyss_alloc, yyss);
1251 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1252# undef YYSTACK_RELOCATE
1253 if (yyss1 != yyssa)
1254 YYSTACK_FREE (yyss1);
1255 }
1256# endif
1257#endif /* no yyoverflow */
1258
1259 yyssp = yyss + yysize - 1;
1260 yyvsp = yyvs + yysize - 1;
1261
1262 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1263 (unsigned long int) yystacksize));
1264
1265 if (yyss + yystacksize - 1 <= yyssp)
1266 YYABORT;
1267 }
1268
1269 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1270
1271 if (yystate == YYFINAL)
1272 YYACCEPT;
1273
1274 goto yybackup;
1275
1276/*-----------.
1277| yybackup. |
1278`-----------*/
1279yybackup:
1280
1281 /* Do appropriate processing given the current state. Read a
1282 lookahead token if we need one and don't already have one. */
1283
1284 /* First try to decide what to do without reference to lookahead token. */
1285 yyn = yypact[yystate];
1286 if (yyn == YYPACT_NINF)
1287 goto yydefault;
1288
1289 /* Not known => get a lookahead token if don't already have one. */
1290
1291 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1292 if (yychar == YYEMPTY)
1293 {
1294 YYDPRINTF ((stderr, "Reading a token: "));
1295 yychar = YYLEX;
1296 }
1297
1298 if (yychar <= YYEOF)
1299 {
1300 yychar = yytoken = YYEOF;
1301 YYDPRINTF ((stderr, "Now at end of input.\n"));
1302 }
1303 else
1304 {
1305 yytoken = YYTRANSLATE (yychar);
1306 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1307 }
1308
1309 /* If the proper action on seeing token YYTOKEN is to reduce or to
1310 detect an error, take that action. */
1311 yyn += yytoken;
1312 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1313 goto yydefault;
1314 yyn = yytable[yyn];
1315 if (yyn <= 0)
1316 {
1317 if (yyn == 0 || yyn == YYTABLE_NINF)
1318 goto yyerrlab;
1319 yyn = -yyn;
1320 goto yyreduce;
1321 }
1322
1323 /* Count tokens shifted since error; after three, turn off error
1324 status. */
1325 if (yyerrstatus)
1326 yyerrstatus--;
1327
1328 /* Shift the lookahead token. */
1329 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1330
1331 /* Discard the shifted token. */
1332 yychar = YYEMPTY;
1333
1334 yystate = yyn;
1335 *++yyvsp = yylval;
1336
1337 goto yynewstate;
1338
1339
1340/*-----------------------------------------------------------.
1341| yydefault -- do the default action for the current state. |
1342`-----------------------------------------------------------*/
1343yydefault:
1344 yyn = yydefact[yystate];
1345 if (yyn == 0)
1346 goto yyerrlab;
1347 goto yyreduce;
1348
1349
1350/*-----------------------------.
1351| yyreduce -- Do a reduction. |
1352`-----------------------------*/
1353yyreduce:
1354 /* yyn is the number of a rule to reduce with. */
1355 yylen = yyr2[yyn];
1356
1357 /* If YYLEN is nonzero, implement the default value of the action:
1358 `$$ = $1'.
1359
1360 Otherwise, the following line sets YYVAL to garbage.
1361 This behavior is undocumented and Bison
1362 users should not rely upon it. Assigning to YYVAL
1363 unconditionally makes the parser a bit smaller, and it avoids a
1364 GCC warning that YYVAL may be used uninitialized. */
1365 yyval = yyvsp[1-yylen];
1366
1367
1368 YY_REDUCE_PRINT (yyn);
1369 switch (yyn)
1370 {
1371 case 4:
1372
1373/* Line 1464 of yacc.c */
1374#line 45 "util/pmu.y"
1375 {
1376 ABORT_ON(perf_pmu__new_format(format, name,
1377 PERF_PMU_FORMAT_VALUE_CONFIG,
1378 (yyvsp[(3) - (3)].bits)));
1379;}
1380 break;
1381
1382 case 5:
1383
1384/* Line 1464 of yacc.c */
1385#line 52 "util/pmu.y"
1386 {
1387 ABORT_ON(perf_pmu__new_format(format, name,
1388 PERF_PMU_FORMAT_VALUE_CONFIG1,
1389 (yyvsp[(3) - (3)].bits)));
1390;}
1391 break;
1392
1393 case 6:
1394
1395/* Line 1464 of yacc.c */
1396#line 59 "util/pmu.y"
1397 {
1398 ABORT_ON(perf_pmu__new_format(format, name,
1399 PERF_PMU_FORMAT_VALUE_CONFIG2,
1400 (yyvsp[(3) - (3)].bits)));
1401;}
1402 break;
1403
1404 case 7:
1405
1406/* Line 1464 of yacc.c */
1407#line 67 "util/pmu.y"
1408 {
1409 bitmap_or((yyval.bits), (yyvsp[(1) - (3)].bits), (yyvsp[(3) - (3)].bits), 64);
1410;}
1411 break;
1412
1413 case 8:
1414
1415/* Line 1464 of yacc.c */
1416#line 72 "util/pmu.y"
1417 {
1418 memcpy((yyval.bits), (yyvsp[(1) - (1)].bits), sizeof((yyvsp[(1) - (1)].bits)));
1419;}
1420 break;
1421
1422 case 9:
1423
1424/* Line 1464 of yacc.c */
1425#line 78 "util/pmu.y"
1426 {
1427 perf_pmu__set_format((yyval.bits), (yyvsp[(1) - (3)].num), (yyvsp[(3) - (3)].num));
1428;}
1429 break;
1430
1431 case 10:
1432
1433/* Line 1464 of yacc.c */
1434#line 83 "util/pmu.y"
1435 {
1436 perf_pmu__set_format((yyval.bits), (yyvsp[(1) - (1)].num), 0);
1437;}
1438 break;
1439
1440
1441
1442/* Line 1464 of yacc.c */
1443#line 1444 "util/pmu-bison.c"
1444 default: break;
1445 }
1446 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1447
1448 YYPOPSTACK (yylen);
1449 yylen = 0;
1450 YY_STACK_PRINT (yyss, yyssp);
1451
1452 *++yyvsp = yyval;
1453
1454 /* Now `shift' the result of the reduction. Determine what state
1455 that goes to, based on the state we popped back to and the rule
1456 number reduced by. */
1457
1458 yyn = yyr1[yyn];
1459
1460 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1461 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1462 yystate = yytable[yystate];
1463 else
1464 yystate = yydefgoto[yyn - YYNTOKENS];
1465
1466 goto yynewstate;
1467
1468
1469/*------------------------------------.
1470| yyerrlab -- here on detecting error |
1471`------------------------------------*/
1472yyerrlab:
1473 /* If not already recovering from an error, report this error. */
1474 if (!yyerrstatus)
1475 {
1476 ++yynerrs;
1477#if ! YYERROR_VERBOSE
1478 yyerror (format, name, YY_("syntax error"));
1479#else
1480 {
1481 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1482 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1483 {
1484 YYSIZE_T yyalloc = 2 * yysize;
1485 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1486 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1487 if (yymsg != yymsgbuf)
1488 YYSTACK_FREE (yymsg);
1489 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1490 if (yymsg)
1491 yymsg_alloc = yyalloc;
1492 else
1493 {
1494 yymsg = yymsgbuf;
1495 yymsg_alloc = sizeof yymsgbuf;
1496 }
1497 }
1498
1499 if (0 < yysize && yysize <= yymsg_alloc)
1500 {
1501 (void) yysyntax_error (yymsg, yystate, yychar);
1502 yyerror (format, name, yymsg);
1503 }
1504 else
1505 {
1506 yyerror (format, name, YY_("syntax error"));
1507 if (yysize != 0)
1508 goto yyexhaustedlab;
1509 }
1510 }
1511#endif
1512 }
1513
1514
1515
1516 if (yyerrstatus == 3)
1517 {
1518 /* If just tried and failed to reuse lookahead token after an
1519 error, discard it. */
1520
1521 if (yychar <= YYEOF)
1522 {
1523 /* Return failure if at end of input. */
1524 if (yychar == YYEOF)
1525 YYABORT;
1526 }
1527 else
1528 {
1529 yydestruct ("Error: discarding",
1530 yytoken, &yylval, format, name);
1531 yychar = YYEMPTY;
1532 }
1533 }
1534
1535 /* Else will try to reuse lookahead token after shifting the error
1536 token. */
1537 goto yyerrlab1;
1538
1539
1540/*---------------------------------------------------.
1541| yyerrorlab -- error raised explicitly by YYERROR. |
1542`---------------------------------------------------*/
1543yyerrorlab:
1544
1545 /* Pacify compilers like GCC when the user code never invokes
1546 YYERROR and the label yyerrorlab therefore never appears in user
1547 code. */
1548 if (/*CONSTCOND*/ 0)
1549 goto yyerrorlab;
1550
1551 /* Do not reclaim the symbols of the rule which action triggered
1552 this YYERROR. */
1553 YYPOPSTACK (yylen);
1554 yylen = 0;
1555 YY_STACK_PRINT (yyss, yyssp);
1556 yystate = *yyssp;
1557 goto yyerrlab1;
1558
1559
1560/*-------------------------------------------------------------.
1561| yyerrlab1 -- common code for both syntax error and YYERROR. |
1562`-------------------------------------------------------------*/
1563yyerrlab1:
1564 yyerrstatus = 3; /* Each real token shifted decrements this. */
1565
1566 for (;;)
1567 {
1568 yyn = yypact[yystate];
1569 if (yyn != YYPACT_NINF)
1570 {
1571 yyn += YYTERROR;
1572 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1573 {
1574 yyn = yytable[yyn];
1575 if (0 < yyn)
1576 break;
1577 }
1578 }
1579
1580 /* Pop the current state because it cannot handle the error token. */
1581 if (yyssp == yyss)
1582 YYABORT;
1583
1584
1585 yydestruct ("Error: popping",
1586 yystos[yystate], yyvsp, format, name);
1587 YYPOPSTACK (1);
1588 yystate = *yyssp;
1589 YY_STACK_PRINT (yyss, yyssp);
1590 }
1591
1592 *++yyvsp = yylval;
1593
1594
1595 /* Shift the error token. */
1596 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1597
1598 yystate = yyn;
1599 goto yynewstate;
1600
1601
1602/*-------------------------------------.
1603| yyacceptlab -- YYACCEPT comes here. |
1604`-------------------------------------*/
1605yyacceptlab:
1606 yyresult = 0;
1607 goto yyreturn;
1608
1609/*-----------------------------------.
1610| yyabortlab -- YYABORT comes here. |
1611`-----------------------------------*/
1612yyabortlab:
1613 yyresult = 1;
1614 goto yyreturn;
1615
1616#if !defined(yyoverflow) || YYERROR_VERBOSE
1617/*-------------------------------------------------.
1618| yyexhaustedlab -- memory exhaustion comes here. |
1619`-------------------------------------------------*/
1620yyexhaustedlab:
1621 yyerror (format, name, YY_("memory exhausted"));
1622 yyresult = 2;
1623 /* Fall through. */
1624#endif
1625
1626yyreturn:
1627 if (yychar != YYEMPTY)
1628 yydestruct ("Cleanup: discarding lookahead",
1629 yytoken, &yylval, format, name);
1630 /* Do not reclaim the symbols of the rule which action triggered
1631 this YYABORT or YYACCEPT. */
1632 YYPOPSTACK (yylen);
1633 YY_STACK_PRINT (yyss, yyssp);
1634 while (yyssp != yyss)
1635 {
1636 yydestruct ("Cleanup: popping",
1637 yystos[*yyssp], yyvsp, format, name);
1638 YYPOPSTACK (1);
1639 }
1640#ifndef yyoverflow
1641 if (yyss != yyssa)
1642 YYSTACK_FREE (yyss);
1643#endif
1644#if YYERROR_VERBOSE
1645 if (yymsg != yymsgbuf)
1646 YYSTACK_FREE (yymsg);
1647#endif
1648 /* Make sure YYID is used. */
1649 return YYID (yyresult);
1650}
1651
1652
1653
1654/* Line 1684 of yacc.c */
1655#line 87 "util/pmu.y"
1656
1657
1658void perf_pmu_error(struct list_head *list __used,
1659 char *name __used,
1660 char const *msg __used)
1661{
1662}
1663
diff --git a/tools/perf/util/pmu-bison.h b/tools/perf/util/pmu-bison.h
deleted file mode 100644
index 54f4a0d7829b..000000000000
--- a/tools/perf/util/pmu-bison.h
+++ /dev/null
@@ -1,73 +0,0 @@
1/* A Bison parser, made by GNU Bison 2.4.3. */
2
3/* Skeleton interface for Bison's Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2009, 2010 Free Software Foundation, Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21/* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34
35/* Tokens. */
36#ifndef YYTOKENTYPE
37# define YYTOKENTYPE
38 /* Put the tokens into the symbol table, so that GDB and other debuggers
39 know about them. */
40 enum yytokentype {
41 PP_CONFIG = 258,
42 PP_CONFIG1 = 259,
43 PP_CONFIG2 = 260,
44 PP_VALUE = 261,
45 PP_ERROR = 262
46 };
47#endif
48
49
50
51#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
52typedef union YYSTYPE
53{
54
55/* Line 1685 of yacc.c */
56#line 31 "util/pmu.y"
57
58 unsigned long num;
59 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
60
61
62
63/* Line 1685 of yacc.c */
64#line 65 "util/pmu-bison.h"
65} YYSTYPE;
66# define YYSTYPE_IS_TRIVIAL 1
67# define yystype YYSTYPE /* obsolescent; will be withdrawn */
68# define YYSTYPE_IS_DECLARED 1
69#endif
70
71extern YYSTYPE perf_pmu_lval;
72
73
diff --git a/tools/perf/util/pmu-flex.c b/tools/perf/util/pmu-flex.c
deleted file mode 100644
index 5a8c15966d5c..000000000000
--- a/tools/perf/util/pmu-flex.c
+++ /dev/null
@@ -1,1821 +0,0 @@
1
2#line 3 "<stdout>"
3
4#define YY_INT_ALIGNED short int
5
6/* A lexical scanner generated by flex */
7
8#define yy_create_buffer perf_pmu__create_buffer
9#define yy_delete_buffer perf_pmu__delete_buffer
10#define yy_flex_debug perf_pmu__flex_debug
11#define yy_init_buffer perf_pmu__init_buffer
12#define yy_flush_buffer perf_pmu__flush_buffer
13#define yy_load_buffer_state perf_pmu__load_buffer_state
14#define yy_switch_to_buffer perf_pmu__switch_to_buffer
15#define yyin perf_pmu_in
16#define yyleng perf_pmu_leng
17#define yylex perf_pmu_lex
18#define yylineno perf_pmu_lineno
19#define yyout perf_pmu_out
20#define yyrestart perf_pmu_restart
21#define yytext perf_pmu_text
22#define yywrap perf_pmu_wrap
23#define yyalloc perf_pmu_alloc
24#define yyrealloc perf_pmu_realloc
25#define yyfree perf_pmu_free
26
27#define FLEX_SCANNER
28#define YY_FLEX_MAJOR_VERSION 2
29#define YY_FLEX_MINOR_VERSION 5
30#define YY_FLEX_SUBMINOR_VERSION 35
31#if YY_FLEX_SUBMINOR_VERSION > 0
32#define FLEX_BETA
33#endif
34
35/* First, we deal with platform-specific or compiler-specific issues. */
36
37/* begin standard C headers. */
38#include <stdio.h>
39#include <string.h>
40#include <errno.h>
41#include <stdlib.h>
42
43/* end standard C headers. */
44
45/* flex integer type definitions */
46
47#ifndef FLEXINT_H
48#define FLEXINT_H
49
50/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
51
52#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
53
54/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
55 * if you want the limit (max/min) macros for int types.
56 */
57#ifndef __STDC_LIMIT_MACROS
58#define __STDC_LIMIT_MACROS 1
59#endif
60
61#include <inttypes.h>
62typedef int8_t flex_int8_t;
63typedef uint8_t flex_uint8_t;
64typedef int16_t flex_int16_t;
65typedef uint16_t flex_uint16_t;
66typedef int32_t flex_int32_t;
67typedef uint32_t flex_uint32_t;
68#else
69typedef signed char flex_int8_t;
70typedef short int flex_int16_t;
71typedef int flex_int32_t;
72typedef unsigned char flex_uint8_t;
73typedef unsigned short int flex_uint16_t;
74typedef unsigned int flex_uint32_t;
75#endif /* ! C99 */
76
77/* Limits of integral types. */
78#ifndef INT8_MIN
79#define INT8_MIN (-128)
80#endif
81#ifndef INT16_MIN
82#define INT16_MIN (-32767-1)
83#endif
84#ifndef INT32_MIN
85#define INT32_MIN (-2147483647-1)
86#endif
87#ifndef INT8_MAX
88#define INT8_MAX (127)
89#endif
90#ifndef INT16_MAX
91#define INT16_MAX (32767)
92#endif
93#ifndef INT32_MAX
94#define INT32_MAX (2147483647)
95#endif
96#ifndef UINT8_MAX
97#define UINT8_MAX (255U)
98#endif
99#ifndef UINT16_MAX
100#define UINT16_MAX (65535U)
101#endif
102#ifndef UINT32_MAX
103#define UINT32_MAX (4294967295U)
104#endif
105
106#endif /* ! FLEXINT_H */
107
108#ifdef __cplusplus
109
110/* The "const" storage-class-modifier is valid. */
111#define YY_USE_CONST
112
113#else /* ! __cplusplus */
114
115/* C99 requires __STDC__ to be defined as 1. */
116#if defined (__STDC__)
117
118#define YY_USE_CONST
119
120#endif /* defined (__STDC__) */
121#endif /* ! __cplusplus */
122
123#ifdef YY_USE_CONST
124#define yyconst const
125#else
126#define yyconst
127#endif
128
129/* Returned upon end-of-file. */
130#define YY_NULL 0
131
132/* Promotes a possibly negative, possibly signed char to an unsigned
133 * integer for use as an array index. If the signed char is negative,
134 * we want to instead treat it as an 8-bit unsigned char, hence the
135 * double cast.
136 */
137#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
138
139/* Enter a start condition. This macro really ought to take a parameter,
140 * but we do it the disgusting crufty way forced on us by the ()-less
141 * definition of BEGIN.
142 */
143#define BEGIN (yy_start) = 1 + 2 *
144
145/* Translate the current start state into a value that can be later handed
146 * to BEGIN to return to the state. The YYSTATE alias is for lex
147 * compatibility.
148 */
149#define YY_START (((yy_start) - 1) / 2)
150#define YYSTATE YY_START
151
152/* Action number for EOF rule of a given start state. */
153#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
154
155/* Special action meaning "start processing a new file". */
156#define YY_NEW_FILE perf_pmu_restart(perf_pmu_in )
157
158#define YY_END_OF_BUFFER_CHAR 0
159
160/* Size of default input buffer. */
161#ifndef YY_BUF_SIZE
162#define YY_BUF_SIZE 16384
163#endif
164
165/* The state buf must be large enough to hold one state per character in the main buffer.
166 */
167#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
168
169#ifndef YY_TYPEDEF_YY_BUFFER_STATE
170#define YY_TYPEDEF_YY_BUFFER_STATE
171typedef struct yy_buffer_state *YY_BUFFER_STATE;
172#endif
173
174extern int perf_pmu_leng;
175
176extern FILE *perf_pmu_in, *perf_pmu_out;
177
178#define EOB_ACT_CONTINUE_SCAN 0
179#define EOB_ACT_END_OF_FILE 1
180#define EOB_ACT_LAST_MATCH 2
181
182 #define YY_LESS_LINENO(n)
183
184/* Return all but the first "n" matched characters back to the input stream. */
185#define yyless(n) \
186 do \
187 { \
188 /* Undo effects of setting up perf_pmu_text. */ \
189 int yyless_macro_arg = (n); \
190 YY_LESS_LINENO(yyless_macro_arg);\
191 *yy_cp = (yy_hold_char); \
192 YY_RESTORE_YY_MORE_OFFSET \
193 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
194 YY_DO_BEFORE_ACTION; /* set up perf_pmu_text again */ \
195 } \
196 while ( 0 )
197
198#define unput(c) yyunput( c, (yytext_ptr) )
199
200#ifndef YY_TYPEDEF_YY_SIZE_T
201#define YY_TYPEDEF_YY_SIZE_T
202typedef size_t yy_size_t;
203#endif
204
205#ifndef YY_STRUCT_YY_BUFFER_STATE
206#define YY_STRUCT_YY_BUFFER_STATE
207struct yy_buffer_state
208 {
209 FILE *yy_input_file;
210
211 char *yy_ch_buf; /* input buffer */
212 char *yy_buf_pos; /* current position in input buffer */
213
214 /* Size of input buffer in bytes, not including room for EOB
215 * characters.
216 */
217 yy_size_t yy_buf_size;
218
219 /* Number of characters read into yy_ch_buf, not including EOB
220 * characters.
221 */
222 int yy_n_chars;
223
224 /* Whether we "own" the buffer - i.e., we know we created it,
225 * and can realloc() it to grow it, and should free() it to
226 * delete it.
227 */
228 int yy_is_our_buffer;
229
230 /* Whether this is an "interactive" input source; if so, and
231 * if we're using stdio for input, then we want to use getc()
232 * instead of fread(), to make sure we stop fetching input after
233 * each newline.
234 */
235 int yy_is_interactive;
236
237 /* Whether we're considered to be at the beginning of a line.
238 * If so, '^' rules will be active on the next match, otherwise
239 * not.
240 */
241 int yy_at_bol;
242
243 int yy_bs_lineno; /**< The line count. */
244 int yy_bs_column; /**< The column count. */
245
246 /* Whether to try to fill the input buffer when we reach the
247 * end of it.
248 */
249 int yy_fill_buffer;
250
251 int yy_buffer_status;
252
253#define YY_BUFFER_NEW 0
254#define YY_BUFFER_NORMAL 1
255 /* When an EOF's been seen but there's still some text to process
256 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
257 * shouldn't try reading from the input source any more. We might
258 * still have a bunch of tokens to match, though, because of
259 * possible backing-up.
260 *
261 * When we actually see the EOF, we change the status to "new"
262 * (via perf_pmu_restart()), so that the user can continue scanning by
263 * just pointing perf_pmu_in at a new input file.
264 */
265#define YY_BUFFER_EOF_PENDING 2
266
267 };
268#endif /* !YY_STRUCT_YY_BUFFER_STATE */
269
270/* Stack of input buffers. */
271static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
272static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
273static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
274
275/* We provide macros for accessing buffer states in case in the
276 * future we want to put the buffer states in a more general
277 * "scanner state".
278 *
279 * Returns the top of the stack, or NULL.
280 */
281#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
282 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
283 : NULL)
284
285/* Same as previous macro, but useful when we know that the buffer stack is not
286 * NULL or when we need an lvalue. For internal use only.
287 */
288#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
289
290/* yy_hold_char holds the character lost when perf_pmu_text is formed. */
291static char yy_hold_char;
292static int yy_n_chars; /* number of characters read into yy_ch_buf */
293int perf_pmu_leng;
294
295/* Points to current character in buffer. */
296static char *yy_c_buf_p = (char *) 0;
297static int yy_init = 0; /* whether we need to initialize */
298static int yy_start = 0; /* start state number */
299
300/* Flag which is used to allow perf_pmu_wrap()'s to do buffer switches
301 * instead of setting up a fresh perf_pmu_in. A bit of a hack ...
302 */
303static int yy_did_buffer_switch_on_eof;
304
305void perf_pmu_restart (FILE *input_file );
306void perf_pmu__switch_to_buffer (YY_BUFFER_STATE new_buffer );
307YY_BUFFER_STATE perf_pmu__create_buffer (FILE *file,int size );
308void perf_pmu__delete_buffer (YY_BUFFER_STATE b );
309void perf_pmu__flush_buffer (YY_BUFFER_STATE b );
310void perf_pmu_push_buffer_state (YY_BUFFER_STATE new_buffer );
311void perf_pmu_pop_buffer_state (void );
312
313static void perf_pmu_ensure_buffer_stack (void );
314static void perf_pmu__load_buffer_state (void );
315static void perf_pmu__init_buffer (YY_BUFFER_STATE b,FILE *file );
316
317#define YY_FLUSH_BUFFER perf_pmu__flush_buffer(YY_CURRENT_BUFFER )
318
319YY_BUFFER_STATE perf_pmu__scan_buffer (char *base,yy_size_t size );
320YY_BUFFER_STATE perf_pmu__scan_string (yyconst char *yy_str );
321YY_BUFFER_STATE perf_pmu__scan_bytes (yyconst char *bytes,int len );
322
323void *perf_pmu_alloc (yy_size_t );
324void *perf_pmu_realloc (void *,yy_size_t );
325void perf_pmu_free (void * );
326
327#define yy_new_buffer perf_pmu__create_buffer
328
329#define yy_set_interactive(is_interactive) \
330 { \
331 if ( ! YY_CURRENT_BUFFER ){ \
332 perf_pmu_ensure_buffer_stack (); \
333 YY_CURRENT_BUFFER_LVALUE = \
334 perf_pmu__create_buffer(perf_pmu_in,YY_BUF_SIZE ); \
335 } \
336 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
337 }
338
339#define yy_set_bol(at_bol) \
340 { \
341 if ( ! YY_CURRENT_BUFFER ){\
342 perf_pmu_ensure_buffer_stack (); \
343 YY_CURRENT_BUFFER_LVALUE = \
344 perf_pmu__create_buffer(perf_pmu_in,YY_BUF_SIZE ); \
345 } \
346 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
347 }
348
349#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
350
351/* Begin user sect3 */
352
353typedef unsigned char YY_CHAR;
354
355FILE *perf_pmu_in = (FILE *) 0, *perf_pmu_out = (FILE *) 0;
356
357typedef int yy_state_type;
358
359extern int perf_pmu_lineno;
360
361int perf_pmu_lineno = 1;
362
363extern char *perf_pmu_text;
364#define yytext_ptr perf_pmu_text
365
366static yy_state_type yy_get_previous_state (void );
367static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
368static int yy_get_next_buffer (void );
369static void yy_fatal_error (yyconst char msg[] );
370
371/* Done after the current pattern has been matched and before the
372 * corresponding action - sets up perf_pmu_text.
373 */
374#define YY_DO_BEFORE_ACTION \
375 (yytext_ptr) = yy_bp; \
376 perf_pmu_leng = (size_t) (yy_cp - yy_bp); \
377 (yy_hold_char) = *yy_cp; \
378 *yy_cp = '\0'; \
379 (yy_c_buf_p) = yy_cp;
380
381#define YY_NUM_RULES 10
382#define YY_END_OF_BUFFER 11
383/* This struct is not used in this scanner,
384 but its presence is necessary. */
385struct yy_trans_info
386 {
387 flex_int32_t yy_verify;
388 flex_int32_t yy_nxt;
389 };
390static yyconst flex_int16_t yy_accept[20] =
391 { 0,
392 0, 0, 11, 8, 9, 7, 5, 1, 6, 8,
393 1, 0, 0, 0, 0, 2, 3, 4, 0
394 } ;
395
396static yyconst flex_int32_t yy_ec[256] =
397 { 0,
398 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
399 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
400 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
401 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
402 1, 1, 1, 3, 4, 1, 1, 5, 6, 7,
403 5, 5, 5, 5, 5, 5, 5, 8, 1, 1,
404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
407 1, 1, 1, 1, 1, 1, 1, 1, 9, 1,
408
409 1, 10, 11, 1, 12, 1, 1, 1, 1, 13,
410 14, 1, 1, 1, 1, 1, 1, 1, 1, 1,
411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
415 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
416 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
419
420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
425 1, 1, 1, 1, 1
426 } ;
427
428static yyconst flex_int32_t yy_meta[15] =
429 { 0,
430 1, 1, 1, 1, 2, 2, 2, 1, 1, 1,
431 1, 1, 1, 1
432 } ;
433
434static yyconst flex_int16_t yy_base[21] =
435 { 0,
436 0, 0, 23, 24, 24, 24, 24, 0, 24, 8,
437 0, 8, 10, 7, 7, 9, 24, 24, 24, 15
438 } ;
439
440static yyconst flex_int16_t yy_def[21] =
441 { 0,
442 19, 1, 19, 19, 19, 19, 19, 20, 19, 19,
443 20, 19, 19, 19, 19, 19, 19, 19, 0, 19
444 } ;
445
446static yyconst flex_int16_t yy_nxt[39] =
447 { 0,
448 4, 5, 6, 7, 8, 8, 8, 9, 10, 4,
449 4, 4, 4, 4, 17, 18, 11, 16, 15, 14,
450 13, 12, 19, 3, 19, 19, 19, 19, 19, 19,
451 19, 19, 19, 19, 19, 19, 19, 19
452 } ;
453
454static yyconst flex_int16_t yy_chk[39] =
455 { 0,
456 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
457 1, 1, 1, 1, 16, 16, 20, 15, 14, 13,
458 12, 10, 3, 19, 19, 19, 19, 19, 19, 19,
459 19, 19, 19, 19, 19, 19, 19, 19
460 } ;
461
462static yy_state_type yy_last_accepting_state;
463static char *yy_last_accepting_cpos;
464
465extern int perf_pmu__flex_debug;
466int perf_pmu__flex_debug = 0;
467
468/* The intent behind this definition is that it'll catch
469 * any uses of REJECT which flex missed.
470 */
471#define REJECT reject_used_but_not_detected
472#define yymore() yymore_used_but_not_detected
473#define YY_MORE_ADJ 0
474#define YY_RESTORE_YY_MORE_OFFSET
475char *perf_pmu_text;
476#line 1 "util/pmu.l"
477#line 4 "util/pmu.l"
478#include <stdlib.h>
479#include <linux/bitops.h>
480#include "pmu.h"
481#include "pmu-bison.h"
482
483static int value(int base)
484{
485 long num;
486
487 errno = 0;
488 num = strtoul(perf_pmu_text, NULL, base);
489 if (errno)
490 return PP_ERROR;
491
492 perf_pmu_lval.num = num;
493 return PP_VALUE;
494}
495
496#line 497 "<stdout>"
497
498#define INITIAL 0
499
500#ifndef YY_NO_UNISTD_H
501/* Special case for "unistd.h", since it is non-ANSI. We include it way
502 * down here because we want the user's section 1 to have been scanned first.
503 * The user has a chance to override it with an option.
504 */
505#include <unistd.h>
506#endif
507
508#ifndef YY_EXTRA_TYPE
509#define YY_EXTRA_TYPE void *
510#endif
511
512static int yy_init_globals (void );
513
514/* Accessor methods to globals.
515 These are made visible to non-reentrant scanners for convenience. */
516
517int perf_pmu_lex_destroy (void );
518
519int perf_pmu_get_debug (void );
520
521void perf_pmu_set_debug (int debug_flag );
522
523YY_EXTRA_TYPE perf_pmu_get_extra (void );
524
525void perf_pmu_set_extra (YY_EXTRA_TYPE user_defined );
526
527FILE *perf_pmu_get_in (void );
528
529void perf_pmu_set_in (FILE * in_str );
530
531FILE *perf_pmu_get_out (void );
532
533void perf_pmu_set_out (FILE * out_str );
534
535int perf_pmu_get_leng (void );
536
537char *perf_pmu_get_text (void );
538
539int perf_pmu_get_lineno (void );
540
541void perf_pmu_set_lineno (int line_number );
542
543/* Macros after this point can all be overridden by user definitions in
544 * section 1.
545 */
546
547#ifndef YY_SKIP_YYWRAP
548#ifdef __cplusplus
549extern "C" int perf_pmu_wrap (void );
550#else
551extern int perf_pmu_wrap (void );
552#endif
553#endif
554
555 static void yyunput (int c,char *buf_ptr );
556
557#ifndef yytext_ptr
558static void yy_flex_strncpy (char *,yyconst char *,int );
559#endif
560
561#ifdef YY_NEED_STRLEN
562static int yy_flex_strlen (yyconst char * );
563#endif
564
565#ifndef YY_NO_INPUT
566
567#ifdef __cplusplus
568static int yyinput (void );
569#else
570static int input (void );
571#endif
572
573#endif
574
575/* Amount of stuff to slurp up with each read. */
576#ifndef YY_READ_BUF_SIZE
577#define YY_READ_BUF_SIZE 8192
578#endif
579
580/* Copy whatever the last rule matched to the standard output. */
581#ifndef ECHO
582/* This used to be an fputs(), but since the string might contain NUL's,
583 * we now use fwrite().
584 */
585#define ECHO do { if (fwrite( perf_pmu_text, perf_pmu_leng, 1, perf_pmu_out )) {} } while (0)
586#endif
587
588/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
589 * is returned in "result".
590 */
591#ifndef YY_INPUT
592#define YY_INPUT(buf,result,max_size) \
593 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
594 { \
595 int c = '*'; \
596 unsigned n; \
597 for ( n = 0; n < max_size && \
598 (c = getc( perf_pmu_in )) != EOF && c != '\n'; ++n ) \
599 buf[n] = (char) c; \
600 if ( c == '\n' ) \
601 buf[n++] = (char) c; \
602 if ( c == EOF && ferror( perf_pmu_in ) ) \
603 YY_FATAL_ERROR( "input in flex scanner failed" ); \
604 result = n; \
605 } \
606 else \
607 { \
608 errno=0; \
609 while ( (result = fread(buf, 1, max_size, perf_pmu_in))==0 && ferror(perf_pmu_in)) \
610 { \
611 if( errno != EINTR) \
612 { \
613 YY_FATAL_ERROR( "input in flex scanner failed" ); \
614 break; \
615 } \
616 errno=0; \
617 clearerr(perf_pmu_in); \
618 } \
619 }\
620\
621
622#endif
623
624/* No semi-colon after return; correct usage is to write "yyterminate();" -
625 * we don't want an extra ';' after the "return" because that will cause
626 * some compilers to complain about unreachable statements.
627 */
628#ifndef yyterminate
629#define yyterminate() return YY_NULL
630#endif
631
632/* Number of entries by which start-condition stack grows. */
633#ifndef YY_START_STACK_INCR
634#define YY_START_STACK_INCR 25
635#endif
636
637/* Report a fatal error. */
638#ifndef YY_FATAL_ERROR
639#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
640#endif
641
642/* end tables serialization structures and prototypes */
643
644/* Default declaration of generated scanner - a define so the user can
645 * easily add parameters.
646 */
647#ifndef YY_DECL
648#define YY_DECL_IS_OURS 1
649
650extern int perf_pmu_lex (void);
651
652#define YY_DECL int perf_pmu_lex (void)
653#endif /* !YY_DECL */
654
655/* Code executed at the beginning of each rule, after perf_pmu_text and perf_pmu_leng
656 * have been set up.
657 */
658#ifndef YY_USER_ACTION
659#define YY_USER_ACTION
660#endif
661
662/* Code executed at the end of each rule. */
663#ifndef YY_BREAK
664#define YY_BREAK break;
665#endif
666
667#define YY_RULE_SETUP \
668 YY_USER_ACTION
669
670/** The main scanner function which does all the work.
671 */
672YY_DECL
673{
674 register yy_state_type yy_current_state;
675 register char *yy_cp, *yy_bp;
676 register int yy_act;
677
678#line 26 "util/pmu.l"
679
680
681#line 682 "<stdout>"
682
683 if ( !(yy_init) )
684 {
685 (yy_init) = 1;
686
687#ifdef YY_USER_INIT
688 YY_USER_INIT;
689#endif
690
691 if ( ! (yy_start) )
692 (yy_start) = 1; /* first start state */
693
694 if ( ! perf_pmu_in )
695 perf_pmu_in = stdin;
696
697 if ( ! perf_pmu_out )
698 perf_pmu_out = stdout;
699
700 if ( ! YY_CURRENT_BUFFER ) {
701 perf_pmu_ensure_buffer_stack ();
702 YY_CURRENT_BUFFER_LVALUE =
703 perf_pmu__create_buffer(perf_pmu_in,YY_BUF_SIZE );
704 }
705
706 perf_pmu__load_buffer_state( );
707 }
708
709 while ( 1 ) /* loops until end-of-file is reached */
710 {
711 yy_cp = (yy_c_buf_p);
712
713 /* Support of perf_pmu_text. */
714 *yy_cp = (yy_hold_char);
715
716 /* yy_bp points to the position in yy_ch_buf of the start of
717 * the current run.
718 */
719 yy_bp = yy_cp;
720
721 yy_current_state = (yy_start);
722yy_match:
723 do
724 {
725 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
726 if ( yy_accept[yy_current_state] )
727 {
728 (yy_last_accepting_state) = yy_current_state;
729 (yy_last_accepting_cpos) = yy_cp;
730 }
731 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
732 {
733 yy_current_state = (int) yy_def[yy_current_state];
734 if ( yy_current_state >= 20 )
735 yy_c = yy_meta[(unsigned int) yy_c];
736 }
737 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
738 ++yy_cp;
739 }
740 while ( yy_base[yy_current_state] != 24 );
741
742yy_find_action:
743 yy_act = yy_accept[yy_current_state];
744 if ( yy_act == 0 )
745 { /* have to back up */
746 yy_cp = (yy_last_accepting_cpos);
747 yy_current_state = (yy_last_accepting_state);
748 yy_act = yy_accept[yy_current_state];
749 }
750
751 YY_DO_BEFORE_ACTION;
752
753do_action: /* This label is used only to access EOF actions. */
754
755 switch ( yy_act )
756 { /* beginning of action switch */
757 case 0: /* must back up */
758 /* undo the effects of YY_DO_BEFORE_ACTION */
759 *yy_cp = (yy_hold_char);
760 yy_cp = (yy_last_accepting_cpos);
761 yy_current_state = (yy_last_accepting_state);
762 goto yy_find_action;
763
764case 1:
765YY_RULE_SETUP
766#line 28 "util/pmu.l"
767{ return value(10); }
768 YY_BREAK
769case 2:
770YY_RULE_SETUP
771#line 29 "util/pmu.l"
772{ return PP_CONFIG; }
773 YY_BREAK
774case 3:
775YY_RULE_SETUP
776#line 30 "util/pmu.l"
777{ return PP_CONFIG1; }
778 YY_BREAK
779case 4:
780YY_RULE_SETUP
781#line 31 "util/pmu.l"
782{ return PP_CONFIG2; }
783 YY_BREAK
784case 5:
785YY_RULE_SETUP
786#line 32 "util/pmu.l"
787{ return '-'; }
788 YY_BREAK
789case 6:
790YY_RULE_SETUP
791#line 33 "util/pmu.l"
792{ return ':'; }
793 YY_BREAK
794case 7:
795YY_RULE_SETUP
796#line 34 "util/pmu.l"
797{ return ','; }
798 YY_BREAK
799case 8:
800YY_RULE_SETUP
801#line 35 "util/pmu.l"
802{ ; }
803 YY_BREAK
804case 9:
805/* rule 9 can match eol */
806YY_RULE_SETUP
807#line 36 "util/pmu.l"
808{ ; }
809 YY_BREAK
810case 10:
811YY_RULE_SETUP
812#line 38 "util/pmu.l"
813ECHO;
814 YY_BREAK
815#line 816 "<stdout>"
816case YY_STATE_EOF(INITIAL):
817 yyterminate();
818
819 case YY_END_OF_BUFFER:
820 {
821 /* Amount of text matched not including the EOB char. */
822 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
823
824 /* Undo the effects of YY_DO_BEFORE_ACTION. */
825 *yy_cp = (yy_hold_char);
826 YY_RESTORE_YY_MORE_OFFSET
827
828 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
829 {
830 /* We're scanning a new file or input source. It's
831 * possible that this happened because the user
832 * just pointed perf_pmu_in at a new source and called
833 * perf_pmu_lex(). If so, then we have to assure
834 * consistency between YY_CURRENT_BUFFER and our
835 * globals. Here is the right place to do so, because
836 * this is the first action (other than possibly a
837 * back-up) that will match for the new input source.
838 */
839 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
840 YY_CURRENT_BUFFER_LVALUE->yy_input_file = perf_pmu_in;
841 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
842 }
843
844 /* Note that here we test for yy_c_buf_p "<=" to the position
845 * of the first EOB in the buffer, since yy_c_buf_p will
846 * already have been incremented past the NUL character
847 * (since all states make transitions on EOB to the
848 * end-of-buffer state). Contrast this with the test
849 * in input().
850 */
851 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
852 { /* This was really a NUL. */
853 yy_state_type yy_next_state;
854
855 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
856
857 yy_current_state = yy_get_previous_state( );
858
859 /* Okay, we're now positioned to make the NUL
860 * transition. We couldn't have
861 * yy_get_previous_state() go ahead and do it
862 * for us because it doesn't know how to deal
863 * with the possibility of jamming (and we don't
864 * want to build jamming into it because then it
865 * will run more slowly).
866 */
867
868 yy_next_state = yy_try_NUL_trans( yy_current_state );
869
870 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
871
872 if ( yy_next_state )
873 {
874 /* Consume the NUL. */
875 yy_cp = ++(yy_c_buf_p);
876 yy_current_state = yy_next_state;
877 goto yy_match;
878 }
879
880 else
881 {
882 yy_cp = (yy_c_buf_p);
883 goto yy_find_action;
884 }
885 }
886
887 else switch ( yy_get_next_buffer( ) )
888 {
889 case EOB_ACT_END_OF_FILE:
890 {
891 (yy_did_buffer_switch_on_eof) = 0;
892
893 if ( perf_pmu_wrap( ) )
894 {
895 /* Note: because we've taken care in
896 * yy_get_next_buffer() to have set up
897 * perf_pmu_text, we can now set up
898 * yy_c_buf_p so that if some total
899 * hoser (like flex itself) wants to
900 * call the scanner after we return the
901 * YY_NULL, it'll still work - another
902 * YY_NULL will get returned.
903 */
904 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
905
906 yy_act = YY_STATE_EOF(YY_START);
907 goto do_action;
908 }
909
910 else
911 {
912 if ( ! (yy_did_buffer_switch_on_eof) )
913 YY_NEW_FILE;
914 }
915 break;
916 }
917
918 case EOB_ACT_CONTINUE_SCAN:
919 (yy_c_buf_p) =
920 (yytext_ptr) + yy_amount_of_matched_text;
921
922 yy_current_state = yy_get_previous_state( );
923
924 yy_cp = (yy_c_buf_p);
925 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
926 goto yy_match;
927
928 case EOB_ACT_LAST_MATCH:
929 (yy_c_buf_p) =
930 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
931
932 yy_current_state = yy_get_previous_state( );
933
934 yy_cp = (yy_c_buf_p);
935 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
936 goto yy_find_action;
937 }
938 break;
939 }
940
941 default:
942 YY_FATAL_ERROR(
943 "fatal flex scanner internal error--no action found" );
944 } /* end of action switch */
945 } /* end of scanning one token */
946} /* end of perf_pmu_lex */
947
948/* yy_get_next_buffer - try to read in a new buffer
949 *
950 * Returns a code representing an action:
951 * EOB_ACT_LAST_MATCH -
952 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
953 * EOB_ACT_END_OF_FILE - end of file
954 */
955static int yy_get_next_buffer (void)
956{
957 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
958 register char *source = (yytext_ptr);
959 register int number_to_move, i;
960 int ret_val;
961
962 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
963 YY_FATAL_ERROR(
964 "fatal flex scanner internal error--end of buffer missed" );
965
966 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
967 { /* Don't try to fill the buffer, so this is an EOF. */
968 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
969 {
970 /* We matched a single character, the EOB, so
971 * treat this as a final EOF.
972 */
973 return EOB_ACT_END_OF_FILE;
974 }
975
976 else
977 {
978 /* We matched some text prior to the EOB, first
979 * process it.
980 */
981 return EOB_ACT_LAST_MATCH;
982 }
983 }
984
985 /* Try to read more data. */
986
987 /* First move last chars to start of buffer. */
988 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
989
990 for ( i = 0; i < number_to_move; ++i )
991 *(dest++) = *(source++);
992
993 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
994 /* don't do the read, it's not guaranteed to return an EOF,
995 * just force an EOF
996 */
997 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
998
999 else
1000 {
1001 int num_to_read =
1002 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1003
1004 while ( num_to_read <= 0 )
1005 { /* Not enough room in the buffer - grow it. */
1006
1007 /* just a shorter name for the current buffer */
1008 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1009
1010 int yy_c_buf_p_offset =
1011 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1012
1013 if ( b->yy_is_our_buffer )
1014 {
1015 int new_size = b->yy_buf_size * 2;
1016
1017 if ( new_size <= 0 )
1018 b->yy_buf_size += b->yy_buf_size / 8;
1019 else
1020 b->yy_buf_size *= 2;
1021
1022 b->yy_ch_buf = (char *)
1023 /* Include room in for 2 EOB chars. */
1024 perf_pmu_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1025 }
1026 else
1027 /* Can't grow it, we don't own it. */
1028 b->yy_ch_buf = 0;
1029
1030 if ( ! b->yy_ch_buf )
1031 YY_FATAL_ERROR(
1032 "fatal error - scanner input buffer overflow" );
1033
1034 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1035
1036 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1037 number_to_move - 1;
1038
1039 }
1040
1041 if ( num_to_read > YY_READ_BUF_SIZE )
1042 num_to_read = YY_READ_BUF_SIZE;
1043
1044 /* Read in more data. */
1045 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1046 (yy_n_chars), (size_t) num_to_read );
1047
1048 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1049 }
1050
1051 if ( (yy_n_chars) == 0 )
1052 {
1053 if ( number_to_move == YY_MORE_ADJ )
1054 {
1055 ret_val = EOB_ACT_END_OF_FILE;
1056 perf_pmu_restart(perf_pmu_in );
1057 }
1058
1059 else
1060 {
1061 ret_val = EOB_ACT_LAST_MATCH;
1062 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1063 YY_BUFFER_EOF_PENDING;
1064 }
1065 }
1066
1067 else
1068 ret_val = EOB_ACT_CONTINUE_SCAN;
1069
1070 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1071 /* Extend the array by 50%, plus the number we really need. */
1072 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1073 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) perf_pmu_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1074 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1075 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1076 }
1077
1078 (yy_n_chars) += number_to_move;
1079 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1080 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1081
1082 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1083
1084 return ret_val;
1085}
1086
1087/* yy_get_previous_state - get the state just before the EOB char was reached */
1088
1089 static yy_state_type yy_get_previous_state (void)
1090{
1091 register yy_state_type yy_current_state;
1092 register char *yy_cp;
1093
1094 yy_current_state = (yy_start);
1095
1096 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1097 {
1098 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1099 if ( yy_accept[yy_current_state] )
1100 {
1101 (yy_last_accepting_state) = yy_current_state;
1102 (yy_last_accepting_cpos) = yy_cp;
1103 }
1104 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1105 {
1106 yy_current_state = (int) yy_def[yy_current_state];
1107 if ( yy_current_state >= 20 )
1108 yy_c = yy_meta[(unsigned int) yy_c];
1109 }
1110 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1111 }
1112
1113 return yy_current_state;
1114}
1115
1116/* yy_try_NUL_trans - try to make a transition on the NUL character
1117 *
1118 * synopsis
1119 * next_state = yy_try_NUL_trans( current_state );
1120 */
1121 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1122{
1123 register int yy_is_jam;
1124 register char *yy_cp = (yy_c_buf_p);
1125
1126 register YY_CHAR yy_c = 1;
1127 if ( yy_accept[yy_current_state] )
1128 {
1129 (yy_last_accepting_state) = yy_current_state;
1130 (yy_last_accepting_cpos) = yy_cp;
1131 }
1132 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1133 {
1134 yy_current_state = (int) yy_def[yy_current_state];
1135 if ( yy_current_state >= 20 )
1136 yy_c = yy_meta[(unsigned int) yy_c];
1137 }
1138 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1139 yy_is_jam = (yy_current_state == 19);
1140
1141 return yy_is_jam ? 0 : yy_current_state;
1142}
1143
1144 static void yyunput (int c, register char * yy_bp )
1145{
1146 register char *yy_cp;
1147
1148 yy_cp = (yy_c_buf_p);
1149
1150 /* undo effects of setting up perf_pmu_text */
1151 *yy_cp = (yy_hold_char);
1152
1153 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1154 { /* need to shift things up to make room */
1155 /* +2 for EOB chars. */
1156 register int number_to_move = (yy_n_chars) + 2;
1157 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1158 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1159 register char *source =
1160 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1161
1162 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1163 *--dest = *--source;
1164
1165 yy_cp += (int) (dest - source);
1166 yy_bp += (int) (dest - source);
1167 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1168 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1169
1170 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1171 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1172 }
1173
1174 *--yy_cp = (char) c;
1175
1176 (yytext_ptr) = yy_bp;
1177 (yy_hold_char) = *yy_cp;
1178 (yy_c_buf_p) = yy_cp;
1179}
1180
1181#ifndef YY_NO_INPUT
1182#ifdef __cplusplus
1183 static int yyinput (void)
1184#else
1185 static int input (void)
1186#endif
1187
1188{
1189 int c;
1190
1191 *(yy_c_buf_p) = (yy_hold_char);
1192
1193 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1194 {
1195 /* yy_c_buf_p now points to the character we want to return.
1196 * If this occurs *before* the EOB characters, then it's a
1197 * valid NUL; if not, then we've hit the end of the buffer.
1198 */
1199 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1200 /* This was really a NUL. */
1201 *(yy_c_buf_p) = '\0';
1202
1203 else
1204 { /* need more input */
1205 int offset = (yy_c_buf_p) - (yytext_ptr);
1206 ++(yy_c_buf_p);
1207
1208 switch ( yy_get_next_buffer( ) )
1209 {
1210 case EOB_ACT_LAST_MATCH:
1211 /* This happens because yy_g_n_b()
1212 * sees that we've accumulated a
1213 * token and flags that we need to
1214 * try matching the token before
1215 * proceeding. But for input(),
1216 * there's no matching to consider.
1217 * So convert the EOB_ACT_LAST_MATCH
1218 * to EOB_ACT_END_OF_FILE.
1219 */
1220
1221 /* Reset buffer status. */
1222 perf_pmu_restart(perf_pmu_in );
1223
1224 /*FALLTHROUGH*/
1225
1226 case EOB_ACT_END_OF_FILE:
1227 {
1228 if ( perf_pmu_wrap( ) )
1229 return EOF;
1230
1231 if ( ! (yy_did_buffer_switch_on_eof) )
1232 YY_NEW_FILE;
1233#ifdef __cplusplus
1234 return yyinput();
1235#else
1236 return input();
1237#endif
1238 }
1239
1240 case EOB_ACT_CONTINUE_SCAN:
1241 (yy_c_buf_p) = (yytext_ptr) + offset;
1242 break;
1243 }
1244 }
1245 }
1246
1247 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1248 *(yy_c_buf_p) = '\0'; /* preserve perf_pmu_text */
1249 (yy_hold_char) = *++(yy_c_buf_p);
1250
1251 return c;
1252}
1253#endif /* ifndef YY_NO_INPUT */
1254
1255/** Immediately switch to a different input stream.
1256 * @param input_file A readable stream.
1257 *
1258 * @note This function does not reset the start condition to @c INITIAL .
1259 */
1260 void perf_pmu_restart (FILE * input_file )
1261{
1262
1263 if ( ! YY_CURRENT_BUFFER ){
1264 perf_pmu_ensure_buffer_stack ();
1265 YY_CURRENT_BUFFER_LVALUE =
1266 perf_pmu__create_buffer(perf_pmu_in,YY_BUF_SIZE );
1267 }
1268
1269 perf_pmu__init_buffer(YY_CURRENT_BUFFER,input_file );
1270 perf_pmu__load_buffer_state( );
1271}
1272
1273/** Switch to a different input buffer.
1274 * @param new_buffer The new input buffer.
1275 *
1276 */
1277 void perf_pmu__switch_to_buffer (YY_BUFFER_STATE new_buffer )
1278{
1279
1280 /* TODO. We should be able to replace this entire function body
1281 * with
1282 * perf_pmu_pop_buffer_state();
1283 * perf_pmu_push_buffer_state(new_buffer);
1284 */
1285 perf_pmu_ensure_buffer_stack ();
1286 if ( YY_CURRENT_BUFFER == new_buffer )
1287 return;
1288
1289 if ( YY_CURRENT_BUFFER )
1290 {
1291 /* Flush out information for old buffer. */
1292 *(yy_c_buf_p) = (yy_hold_char);
1293 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1294 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1295 }
1296
1297 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1298 perf_pmu__load_buffer_state( );
1299
1300 /* We don't actually know whether we did this switch during
1301 * EOF (perf_pmu_wrap()) processing, but the only time this flag
1302 * is looked at is after perf_pmu_wrap() is called, so it's safe
1303 * to go ahead and always set it.
1304 */
1305 (yy_did_buffer_switch_on_eof) = 1;
1306}
1307
1308static void perf_pmu__load_buffer_state (void)
1309{
1310 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1311 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1312 perf_pmu_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1313 (yy_hold_char) = *(yy_c_buf_p);
1314}
1315
1316/** Allocate and initialize an input buffer state.
1317 * @param file A readable stream.
1318 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1319 *
1320 * @return the allocated buffer state.
1321 */
1322 YY_BUFFER_STATE perf_pmu__create_buffer (FILE * file, int size )
1323{
1324 YY_BUFFER_STATE b;
1325
1326 b = (YY_BUFFER_STATE) perf_pmu_alloc(sizeof( struct yy_buffer_state ) );
1327 if ( ! b )
1328 YY_FATAL_ERROR( "out of dynamic memory in perf_pmu__create_buffer()" );
1329
1330 b->yy_buf_size = size;
1331
1332 /* yy_ch_buf has to be 2 characters longer than the size given because
1333 * we need to put in 2 end-of-buffer characters.
1334 */
1335 b->yy_ch_buf = (char *) perf_pmu_alloc(b->yy_buf_size + 2 );
1336 if ( ! b->yy_ch_buf )
1337 YY_FATAL_ERROR( "out of dynamic memory in perf_pmu__create_buffer()" );
1338
1339 b->yy_is_our_buffer = 1;
1340
1341 perf_pmu__init_buffer(b,file );
1342
1343 return b;
1344}
1345
1346/** Destroy the buffer.
1347 * @param b a buffer created with perf_pmu__create_buffer()
1348 *
1349 */
1350 void perf_pmu__delete_buffer (YY_BUFFER_STATE b )
1351{
1352
1353 if ( ! b )
1354 return;
1355
1356 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1357 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1358
1359 if ( b->yy_is_our_buffer )
1360 perf_pmu_free((void *) b->yy_ch_buf );
1361
1362 perf_pmu_free((void *) b );
1363}
1364
1365#ifndef __cplusplus
1366extern int isatty (int );
1367#endif /* __cplusplus */
1368
1369/* Initializes or reinitializes a buffer.
1370 * This function is sometimes called more than once on the same buffer,
1371 * such as during a perf_pmu_restart() or at EOF.
1372 */
1373 static void perf_pmu__init_buffer (YY_BUFFER_STATE b, FILE * file )
1374
1375{
1376 int oerrno = errno;
1377
1378 perf_pmu__flush_buffer(b );
1379
1380 b->yy_input_file = file;
1381 b->yy_fill_buffer = 1;
1382
1383 /* If b is the current buffer, then perf_pmu__init_buffer was _probably_
1384 * called from perf_pmu_restart() or through yy_get_next_buffer.
1385 * In that case, we don't want to reset the lineno or column.
1386 */
1387 if (b != YY_CURRENT_BUFFER){
1388 b->yy_bs_lineno = 1;
1389 b->yy_bs_column = 0;
1390 }
1391
1392 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1393
1394 errno = oerrno;
1395}
1396
1397/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1398 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1399 *
1400 */
1401 void perf_pmu__flush_buffer (YY_BUFFER_STATE b )
1402{
1403 if ( ! b )
1404 return;
1405
1406 b->yy_n_chars = 0;
1407
1408 /* We always need two end-of-buffer characters. The first causes
1409 * a transition to the end-of-buffer state. The second causes
1410 * a jam in that state.
1411 */
1412 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1413 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1414
1415 b->yy_buf_pos = &b->yy_ch_buf[0];
1416
1417 b->yy_at_bol = 1;
1418 b->yy_buffer_status = YY_BUFFER_NEW;
1419
1420 if ( b == YY_CURRENT_BUFFER )
1421 perf_pmu__load_buffer_state( );
1422}
1423
1424/** Pushes the new state onto the stack. The new state becomes
1425 * the current state. This function will allocate the stack
1426 * if necessary.
1427 * @param new_buffer The new state.
1428 *
1429 */
1430void perf_pmu_push_buffer_state (YY_BUFFER_STATE new_buffer )
1431{
1432 if (new_buffer == NULL)
1433 return;
1434
1435 perf_pmu_ensure_buffer_stack();
1436
1437 /* This block is copied from perf_pmu__switch_to_buffer. */
1438 if ( YY_CURRENT_BUFFER )
1439 {
1440 /* Flush out information for old buffer. */
1441 *(yy_c_buf_p) = (yy_hold_char);
1442 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1443 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1444 }
1445
1446 /* Only push if top exists. Otherwise, replace top. */
1447 if (YY_CURRENT_BUFFER)
1448 (yy_buffer_stack_top)++;
1449 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1450
1451 /* copied from perf_pmu__switch_to_buffer. */
1452 perf_pmu__load_buffer_state( );
1453 (yy_did_buffer_switch_on_eof) = 1;
1454}
1455
1456/** Removes and deletes the top of the stack, if present.
1457 * The next element becomes the new top.
1458 *
1459 */
1460void perf_pmu_pop_buffer_state (void)
1461{
1462 if (!YY_CURRENT_BUFFER)
1463 return;
1464
1465 perf_pmu__delete_buffer(YY_CURRENT_BUFFER );
1466 YY_CURRENT_BUFFER_LVALUE = NULL;
1467 if ((yy_buffer_stack_top) > 0)
1468 --(yy_buffer_stack_top);
1469
1470 if (YY_CURRENT_BUFFER) {
1471 perf_pmu__load_buffer_state( );
1472 (yy_did_buffer_switch_on_eof) = 1;
1473 }
1474}
1475
1476/* Allocates the stack if it does not exist.
1477 * Guarantees space for at least one push.
1478 */
1479static void perf_pmu_ensure_buffer_stack (void)
1480{
1481 int num_to_alloc;
1482
1483 if (!(yy_buffer_stack)) {
1484
1485 /* First allocation is just for 2 elements, since we don't know if this
1486 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1487 * immediate realloc on the next call.
1488 */
1489 num_to_alloc = 1;
1490 (yy_buffer_stack) = (struct yy_buffer_state**)perf_pmu_alloc
1491 (num_to_alloc * sizeof(struct yy_buffer_state*)
1492 );
1493 if ( ! (yy_buffer_stack) )
1494 YY_FATAL_ERROR( "out of dynamic memory in perf_pmu_ensure_buffer_stack()" );
1495
1496 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1497
1498 (yy_buffer_stack_max) = num_to_alloc;
1499 (yy_buffer_stack_top) = 0;
1500 return;
1501 }
1502
1503 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1504
1505 /* Increase the buffer to prepare for a possible push. */
1506 int grow_size = 8 /* arbitrary grow size */;
1507
1508 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1509 (yy_buffer_stack) = (struct yy_buffer_state**)perf_pmu_realloc
1510 ((yy_buffer_stack),
1511 num_to_alloc * sizeof(struct yy_buffer_state*)
1512 );
1513 if ( ! (yy_buffer_stack) )
1514 YY_FATAL_ERROR( "out of dynamic memory in perf_pmu_ensure_buffer_stack()" );
1515
1516 /* zero only the new slots.*/
1517 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1518 (yy_buffer_stack_max) = num_to_alloc;
1519 }
1520}
1521
1522/** Setup the input buffer state to scan directly from a user-specified character buffer.
1523 * @param base the character buffer
1524 * @param size the size in bytes of the character buffer
1525 *
1526 * @return the newly allocated buffer state object.
1527 */
1528YY_BUFFER_STATE perf_pmu__scan_buffer (char * base, yy_size_t size )
1529{
1530 YY_BUFFER_STATE b;
1531
1532 if ( size < 2 ||
1533 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1534 base[size-1] != YY_END_OF_BUFFER_CHAR )
1535 /* They forgot to leave room for the EOB's. */
1536 return 0;
1537
1538 b = (YY_BUFFER_STATE) perf_pmu_alloc(sizeof( struct yy_buffer_state ) );
1539 if ( ! b )
1540 YY_FATAL_ERROR( "out of dynamic memory in perf_pmu__scan_buffer()" );
1541
1542 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1543 b->yy_buf_pos = b->yy_ch_buf = base;
1544 b->yy_is_our_buffer = 0;
1545 b->yy_input_file = 0;
1546 b->yy_n_chars = b->yy_buf_size;
1547 b->yy_is_interactive = 0;
1548 b->yy_at_bol = 1;
1549 b->yy_fill_buffer = 0;
1550 b->yy_buffer_status = YY_BUFFER_NEW;
1551
1552 perf_pmu__switch_to_buffer(b );
1553
1554 return b;
1555}
1556
1557/** Setup the input buffer state to scan a string. The next call to perf_pmu_lex() will
1558 * scan from a @e copy of @a str.
1559 * @param yystr a NUL-terminated string to scan
1560 *
1561 * @return the newly allocated buffer state object.
1562 * @note If you want to scan bytes that may contain NUL values, then use
1563 * perf_pmu__scan_bytes() instead.
1564 */
1565YY_BUFFER_STATE perf_pmu__scan_string (yyconst char * yystr )
1566{
1567
1568 return perf_pmu__scan_bytes(yystr,strlen(yystr) );
1569}
1570
1571/** Setup the input buffer state to scan the given bytes. The next call to perf_pmu_lex() will
1572 * scan from a @e copy of @a bytes.
1573 * @param bytes the byte buffer to scan
1574 * @param len the number of bytes in the buffer pointed to by @a bytes.
1575 *
1576 * @return the newly allocated buffer state object.
1577 */
1578YY_BUFFER_STATE perf_pmu__scan_bytes (yyconst char * yybytes, int _yybytes_len )
1579{
1580 YY_BUFFER_STATE b;
1581 char *buf;
1582 yy_size_t n;
1583 int i;
1584
1585 /* Get memory for full buffer, including space for trailing EOB's. */
1586 n = _yybytes_len + 2;
1587 buf = (char *) perf_pmu_alloc(n );
1588 if ( ! buf )
1589 YY_FATAL_ERROR( "out of dynamic memory in perf_pmu__scan_bytes()" );
1590
1591 for ( i = 0; i < _yybytes_len; ++i )
1592 buf[i] = yybytes[i];
1593
1594 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1595
1596 b = perf_pmu__scan_buffer(buf,n );
1597 if ( ! b )
1598 YY_FATAL_ERROR( "bad buffer in perf_pmu__scan_bytes()" );
1599
1600 /* It's okay to grow etc. this buffer, and we should throw it
1601 * away when we're done.
1602 */
1603 b->yy_is_our_buffer = 1;
1604
1605 return b;
1606}
1607
1608#ifndef YY_EXIT_FAILURE
1609#define YY_EXIT_FAILURE 2
1610#endif
1611
1612static void yy_fatal_error (yyconst char* msg )
1613{
1614 (void) fprintf( stderr, "%s\n", msg );
1615 exit( YY_EXIT_FAILURE );
1616}
1617
1618/* Redefine yyless() so it works in section 3 code. */
1619
1620#undef yyless
1621#define yyless(n) \
1622 do \
1623 { \
1624 /* Undo effects of setting up perf_pmu_text. */ \
1625 int yyless_macro_arg = (n); \
1626 YY_LESS_LINENO(yyless_macro_arg);\
1627 perf_pmu_text[perf_pmu_leng] = (yy_hold_char); \
1628 (yy_c_buf_p) = perf_pmu_text + yyless_macro_arg; \
1629 (yy_hold_char) = *(yy_c_buf_p); \
1630 *(yy_c_buf_p) = '\0'; \
1631 perf_pmu_leng = yyless_macro_arg; \
1632 } \
1633 while ( 0 )
1634
1635/* Accessor methods (get/set functions) to struct members. */
1636
1637/** Get the current line number.
1638 *
1639 */
1640int perf_pmu_get_lineno (void)
1641{
1642
1643 return perf_pmu_lineno;
1644}
1645
1646/** Get the input stream.
1647 *
1648 */
1649FILE *perf_pmu_get_in (void)
1650{
1651 return perf_pmu_in;
1652}
1653
1654/** Get the output stream.
1655 *
1656 */
1657FILE *perf_pmu_get_out (void)
1658{
1659 return perf_pmu_out;
1660}
1661
1662/** Get the length of the current token.
1663 *
1664 */
1665int perf_pmu_get_leng (void)
1666{
1667 return perf_pmu_leng;
1668}
1669
1670/** Get the current token.
1671 *
1672 */
1673
1674char *perf_pmu_get_text (void)
1675{
1676 return perf_pmu_text;
1677}
1678
1679/** Set the current line number.
1680 * @param line_number
1681 *
1682 */
1683void perf_pmu_set_lineno (int line_number )
1684{
1685
1686 perf_pmu_lineno = line_number;
1687}
1688
1689/** Set the input stream. This does not discard the current
1690 * input buffer.
1691 * @param in_str A readable stream.
1692 *
1693 * @see perf_pmu__switch_to_buffer
1694 */
1695void perf_pmu_set_in (FILE * in_str )
1696{
1697 perf_pmu_in = in_str ;
1698}
1699
1700void perf_pmu_set_out (FILE * out_str )
1701{
1702 perf_pmu_out = out_str ;
1703}
1704
1705int perf_pmu_get_debug (void)
1706{
1707 return perf_pmu__flex_debug;
1708}
1709
1710void perf_pmu_set_debug (int bdebug )
1711{
1712 perf_pmu__flex_debug = bdebug ;
1713}
1714
1715static int yy_init_globals (void)
1716{
1717 /* Initialization is the same as for the non-reentrant scanner.
1718 * This function is called from perf_pmu_lex_destroy(), so don't allocate here.
1719 */
1720
1721 (yy_buffer_stack) = 0;
1722 (yy_buffer_stack_top) = 0;
1723 (yy_buffer_stack_max) = 0;
1724 (yy_c_buf_p) = (char *) 0;
1725 (yy_init) = 0;
1726 (yy_start) = 0;
1727
1728/* Defined in main.c */
1729#ifdef YY_STDINIT
1730 perf_pmu_in = stdin;
1731 perf_pmu_out = stdout;
1732#else
1733 perf_pmu_in = (FILE *) 0;
1734 perf_pmu_out = (FILE *) 0;
1735#endif
1736
1737 /* For future reference: Set errno on error, since we are called by
1738 * perf_pmu_lex_init()
1739 */
1740 return 0;
1741}
1742
1743/* perf_pmu_lex_destroy is for both reentrant and non-reentrant scanners. */
1744int perf_pmu_lex_destroy (void)
1745{
1746
1747 /* Pop the buffer stack, destroying each element. */
1748 while(YY_CURRENT_BUFFER){
1749 perf_pmu__delete_buffer(YY_CURRENT_BUFFER );
1750 YY_CURRENT_BUFFER_LVALUE = NULL;
1751 perf_pmu_pop_buffer_state();
1752 }
1753
1754 /* Destroy the stack itself. */
1755 perf_pmu_free((yy_buffer_stack) );
1756 (yy_buffer_stack) = NULL;
1757
1758 /* Reset the globals. This is important in a non-reentrant scanner so the next time
1759 * perf_pmu_lex() is called, initialization will occur. */
1760 yy_init_globals( );
1761
1762 return 0;
1763}
1764
1765/*
1766 * Internal utility routines.
1767 */
1768
1769#ifndef yytext_ptr
1770static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1771{
1772 register int i;
1773 for ( i = 0; i < n; ++i )
1774 s1[i] = s2[i];
1775}
1776#endif
1777
1778#ifdef YY_NEED_STRLEN
1779static int yy_flex_strlen (yyconst char * s )
1780{
1781 register int n;
1782 for ( n = 0; s[n]; ++n )
1783 ;
1784
1785 return n;
1786}
1787#endif
1788
1789void *perf_pmu_alloc (yy_size_t size )
1790{
1791 return (void *) malloc( size );
1792}
1793
1794void *perf_pmu_realloc (void * ptr, yy_size_t size )
1795{
1796 /* The cast to (char *) in the following accommodates both
1797 * implementations that use char* generic pointers, and those
1798 * that use void* generic pointers. It works with the latter
1799 * because both ANSI C and C++ allow castless assignment from
1800 * any pointer type to void*, and deal with argument conversions
1801 * as though doing an assignment.
1802 */
1803 return (void *) realloc( (char *) ptr, size );
1804}
1805
1806void perf_pmu_free (void * ptr )
1807{
1808 free( (char *) ptr ); /* see perf_pmu_realloc() for (char *) cast */
1809}
1810
1811#define YYTABLES_NAME "yytables"
1812
1813#line 38 "util/pmu.l"
1814
1815
1816
1817int perf_pmu_wrap(void)
1818{
1819 return 1;
1820}
1821
diff --git a/tools/perf/util/pmu-flex.h b/tools/perf/util/pmu-flex.h
deleted file mode 100644
index 0a29c8a0da4e..000000000000
--- a/tools/perf/util/pmu-flex.h
+++ /dev/null
@@ -1,316 +0,0 @@
1#ifndef perf_pmu_HEADER_H
2#define perf_pmu_HEADER_H 1
3#define perf_pmu_IN_HEADER 1
4
5#line 6 "util/pmu-flex.h"
6
7#define YY_INT_ALIGNED short int
8
9/* A lexical scanner generated by flex */
10
11#define FLEX_SCANNER
12#define YY_FLEX_MAJOR_VERSION 2
13#define YY_FLEX_MINOR_VERSION 5
14#define YY_FLEX_SUBMINOR_VERSION 35
15#if YY_FLEX_SUBMINOR_VERSION > 0
16#define FLEX_BETA
17#endif
18
19/* First, we deal with platform-specific or compiler-specific issues. */
20
21/* begin standard C headers. */
22#include <stdio.h>
23#include <string.h>
24#include <errno.h>
25#include <stdlib.h>
26
27/* end standard C headers. */
28
29/* flex integer type definitions */
30
31#ifndef FLEXINT_H
32#define FLEXINT_H
33
34/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
35
36#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
37
38/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
39 * if you want the limit (max/min) macros for int types.
40 */
41#ifndef __STDC_LIMIT_MACROS
42#define __STDC_LIMIT_MACROS 1
43#endif
44
45#include <inttypes.h>
46typedef int8_t flex_int8_t;
47typedef uint8_t flex_uint8_t;
48typedef int16_t flex_int16_t;
49typedef uint16_t flex_uint16_t;
50typedef int32_t flex_int32_t;
51typedef uint32_t flex_uint32_t;
52#else
53typedef signed char flex_int8_t;
54typedef short int flex_int16_t;
55typedef int flex_int32_t;
56typedef unsigned char flex_uint8_t;
57typedef unsigned short int flex_uint16_t;
58typedef unsigned int flex_uint32_t;
59#endif /* ! C99 */
60
61/* Limits of integral types. */
62#ifndef INT8_MIN
63#define INT8_MIN (-128)
64#endif
65#ifndef INT16_MIN
66#define INT16_MIN (-32767-1)
67#endif
68#ifndef INT32_MIN
69#define INT32_MIN (-2147483647-1)
70#endif
71#ifndef INT8_MAX
72#define INT8_MAX (127)
73#endif
74#ifndef INT16_MAX
75#define INT16_MAX (32767)
76#endif
77#ifndef INT32_MAX
78#define INT32_MAX (2147483647)
79#endif
80#ifndef UINT8_MAX
81#define UINT8_MAX (255U)
82#endif
83#ifndef UINT16_MAX
84#define UINT16_MAX (65535U)
85#endif
86#ifndef UINT32_MAX
87#define UINT32_MAX (4294967295U)
88#endif
89
90#endif /* ! FLEXINT_H */
91
92#ifdef __cplusplus
93
94/* The "const" storage-class-modifier is valid. */
95#define YY_USE_CONST
96
97#else /* ! __cplusplus */
98
99/* C99 requires __STDC__ to be defined as 1. */
100#if defined (__STDC__)
101
102#define YY_USE_CONST
103
104#endif /* defined (__STDC__) */
105#endif /* ! __cplusplus */
106
107#ifdef YY_USE_CONST
108#define yyconst const
109#else
110#define yyconst
111#endif
112
113/* Size of default input buffer. */
114#ifndef YY_BUF_SIZE
115#define YY_BUF_SIZE 16384
116#endif
117
118#ifndef YY_TYPEDEF_YY_BUFFER_STATE
119#define YY_TYPEDEF_YY_BUFFER_STATE
120typedef struct yy_buffer_state *YY_BUFFER_STATE;
121#endif
122
123extern int perf_pmu_leng;
124
125extern FILE *perf_pmu_in, *perf_pmu_out;
126
127#ifndef YY_TYPEDEF_YY_SIZE_T
128#define YY_TYPEDEF_YY_SIZE_T
129typedef size_t yy_size_t;
130#endif
131
132#ifndef YY_STRUCT_YY_BUFFER_STATE
133#define YY_STRUCT_YY_BUFFER_STATE
134struct yy_buffer_state
135 {
136 FILE *yy_input_file;
137
138 char *yy_ch_buf; /* input buffer */
139 char *yy_buf_pos; /* current position in input buffer */
140
141 /* Size of input buffer in bytes, not including room for EOB
142 * characters.
143 */
144 yy_size_t yy_buf_size;
145
146 /* Number of characters read into yy_ch_buf, not including EOB
147 * characters.
148 */
149 int yy_n_chars;
150
151 /* Whether we "own" the buffer - i.e., we know we created it,
152 * and can realloc() it to grow it, and should free() it to
153 * delete it.
154 */
155 int yy_is_our_buffer;
156
157 /* Whether this is an "interactive" input source; if so, and
158 * if we're using stdio for input, then we want to use getc()
159 * instead of fread(), to make sure we stop fetching input after
160 * each newline.
161 */
162 int yy_is_interactive;
163
164 /* Whether we're considered to be at the beginning of a line.
165 * If so, '^' rules will be active on the next match, otherwise
166 * not.
167 */
168 int yy_at_bol;
169
170 int yy_bs_lineno; /**< The line count. */
171 int yy_bs_column; /**< The column count. */
172
173 /* Whether to try to fill the input buffer when we reach the
174 * end of it.
175 */
176 int yy_fill_buffer;
177
178 int yy_buffer_status;
179
180 };
181#endif /* !YY_STRUCT_YY_BUFFER_STATE */
182
183void perf_pmu_restart (FILE *input_file );
184void perf_pmu__switch_to_buffer (YY_BUFFER_STATE new_buffer );
185YY_BUFFER_STATE perf_pmu__create_buffer (FILE *file,int size );
186void perf_pmu__delete_buffer (YY_BUFFER_STATE b );
187void perf_pmu__flush_buffer (YY_BUFFER_STATE b );
188void perf_pmu_push_buffer_state (YY_BUFFER_STATE new_buffer );
189void perf_pmu_pop_buffer_state (void );
190
191YY_BUFFER_STATE perf_pmu__scan_buffer (char *base,yy_size_t size );
192YY_BUFFER_STATE perf_pmu__scan_string (yyconst char *yy_str );
193YY_BUFFER_STATE perf_pmu__scan_bytes (yyconst char *bytes,int len );
194
195void *perf_pmu_alloc (yy_size_t );
196void *perf_pmu_realloc (void *,yy_size_t );
197void perf_pmu_free (void * );
198
199/* Begin user sect3 */
200
201extern int perf_pmu_lineno;
202
203extern char *perf_pmu_text;
204#define yytext_ptr perf_pmu_text
205
206#ifdef YY_HEADER_EXPORT_START_CONDITIONS
207#define INITIAL 0
208
209#endif
210
211#ifndef YY_NO_UNISTD_H
212/* Special case for "unistd.h", since it is non-ANSI. We include it way
213 * down here because we want the user's section 1 to have been scanned first.
214 * The user has a chance to override it with an option.
215 */
216#include <unistd.h>
217#endif
218
219#ifndef YY_EXTRA_TYPE
220#define YY_EXTRA_TYPE void *
221#endif
222
223/* Accessor methods to globals.
224 These are made visible to non-reentrant scanners for convenience. */
225
226int perf_pmu_lex_destroy (void );
227
228int perf_pmu_get_debug (void );
229
230void perf_pmu_set_debug (int debug_flag );
231
232YY_EXTRA_TYPE perf_pmu_get_extra (void );
233
234void perf_pmu_set_extra (YY_EXTRA_TYPE user_defined );
235
236FILE *perf_pmu_get_in (void );
237
238void perf_pmu_set_in (FILE * in_str );
239
240FILE *perf_pmu_get_out (void );
241
242void perf_pmu_set_out (FILE * out_str );
243
244int perf_pmu_get_leng (void );
245
246char *perf_pmu_get_text (void );
247
248int perf_pmu_get_lineno (void );
249
250void perf_pmu_set_lineno (int line_number );
251
252/* Macros after this point can all be overridden by user definitions in
253 * section 1.
254 */
255
256#ifndef YY_SKIP_YYWRAP
257#ifdef __cplusplus
258extern "C" int perf_pmu_wrap (void );
259#else
260extern int perf_pmu_wrap (void );
261#endif
262#endif
263
264#ifndef yytext_ptr
265static void yy_flex_strncpy (char *,yyconst char *,int );
266#endif
267
268#ifdef YY_NEED_STRLEN
269static int yy_flex_strlen (yyconst char * );
270#endif
271
272#ifndef YY_NO_INPUT
273
274#endif
275
276/* Amount of stuff to slurp up with each read. */
277#ifndef YY_READ_BUF_SIZE
278#define YY_READ_BUF_SIZE 8192
279#endif
280
281/* Number of entries by which start-condition stack grows. */
282#ifndef YY_START_STACK_INCR
283#define YY_START_STACK_INCR 25
284#endif
285
286/* Default declaration of generated scanner - a define so the user can
287 * easily add parameters.
288 */
289#ifndef YY_DECL
290#define YY_DECL_IS_OURS 1
291
292extern int perf_pmu_lex (void);
293
294#define YY_DECL int perf_pmu_lex (void)
295#endif /* !YY_DECL */
296
297/* yy_get_previous_state - get the state just before the EOB char was reached */
298
299#undef YY_NEW_FILE
300#undef YY_FLUSH_BUFFER
301#undef yy_set_bol
302#undef yy_new_buffer
303#undef yy_set_interactive
304#undef YY_DO_BEFORE_ACTION
305
306#ifdef YY_DECL_IS_OURS
307#undef YY_DECL_IS_OURS
308#undef YY_DECL
309#endif
310
311#line 38 "util/pmu.l"
312
313
314#line 315 "util/pmu-flex.h"
315#undef perf_pmu_IN_HEADER
316#endif /* perf_pmu_HEADER_H */
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 2cc162d3b78c..d448984ed789 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -972,10 +972,12 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
972 struct dwarf_callback_param *param = data; 972 struct dwarf_callback_param *param = data;
973 struct probe_finder *pf = param->data; 973 struct probe_finder *pf = param->data;
974 struct perf_probe_point *pp = &pf->pev->point; 974 struct perf_probe_point *pp = &pf->pev->point;
975 Dwarf_Attribute attr;
975 976
976 /* Check tag and diename */ 977 /* Check tag and diename */
977 if (dwarf_tag(sp_die) != DW_TAG_subprogram || 978 if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
978 !die_compare_name(sp_die, pp->function)) 979 !die_compare_name(sp_die, pp->function) ||
980 dwarf_attr(sp_die, DW_AT_declaration, &attr))
979 return DWARF_CB_OK; 981 return DWARF_CB_OK;
980 982
981 /* Check declared file */ 983 /* Check declared file */
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 5dd83c3e2c0c..c0a028c3ebaf 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1,6 +1,5 @@
1#include <dirent.h> 1#include <dirent.h>
2#include <errno.h> 2#include <errno.h>
3#include <libgen.h>
4#include <stdlib.h> 3#include <stdlib.h>
5#include <stdio.h> 4#include <stdio.h>
6#include <string.h> 5#include <string.h>
@@ -51,6 +50,8 @@ struct symbol_conf symbol_conf = {
51 50
52int dso__name_len(const struct dso *dso) 51int dso__name_len(const struct dso *dso)
53{ 52{
53 if (!dso)
54 return strlen("[unknown]");
54 if (verbose) 55 if (verbose)
55 return dso->long_name_len; 56 return dso->long_name_len;
56 57
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-26 01:18:29 -0500