aboutsummaryrefslogtreecommitdiffstats
path: root/tools
diff options
context:
space:
mode:
Diffstat (limited to 'tools')
-rw-r--r--tools/perf/Documentation/perf-report.txt5
-rw-r--r--tools/perf/Makefile49
-rw-r--r--tools/perf/builtin-report.c40
-rw-r--r--tools/perf/builtin-stat.c2
-rw-r--r--tools/perf/builtin-test.c58
-rw-r--r--tools/perf/config/feature-tests.mak15
-rw-r--r--tools/perf/util/cache.h12
-rw-r--r--tools/perf/util/evlist.c6
-rw-r--r--tools/perf/util/evsel.c6
-rw-r--r--tools/perf/util/evsel.h3
-rw-r--r--tools/perf/util/gtk/browser.c189
-rw-r--r--tools/perf/util/gtk/gtk.h8
-rw-r--r--tools/perf/util/hist.c35
-rw-r--r--tools/perf/util/hist.h19
-rw-r--r--tools/perf/util/parse-events-bison.c1852
-rw-r--r--tools/perf/util/parse-events-bison.h82
-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.c590
-rw-r--r--tools/perf/util/parse-events.h46
-rw-r--r--tools/perf/util/parse-events.l126
-rw-r--r--tools/perf/util/parse-events.y217
-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/pmu.c469
-rw-r--r--tools/perf/util/pmu.h41
-rw-r--r--tools/perf/util/pmu.l43
-rw-r--r--tools/perf/util/pmu.y93
-rw-r--r--tools/perf/util/ui/browser.h2
-rw-r--r--tools/perf/util/ui/browsers/hists.c14
-rw-r--r--tools/perf/util/ui/keysyms.h2
-rw-r--r--tools/perf/util/ui/util.c82
34 files changed, 10218 insertions, 349 deletions
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index 87feeee8b90c..2d89f02719b5 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -48,6 +48,9 @@ OPTIONS
48 Only consider these symbols. CSV that understands 48 Only consider these symbols. CSV that understands
49 file://filename entries. 49 file://filename entries.
50 50
51--symbol-filter=::
52 Only show symbols that match (partially) with this filter.
53
51-U:: 54-U::
52--hide-unresolved:: 55--hide-unresolved::
53 Only display entries resolved to a symbol. 56 Only display entries resolved to a symbol.
@@ -110,6 +113,8 @@ OPTIONS
110 requires a tty, if one is not present, as when piping to other 113 requires a tty, if one is not present, as when piping to other
111 commands, the stdio interface is used. 114 commands, the stdio interface is used.
112 115
116--gtk:: Use the GTK2 interface.
117
113-k:: 118-k::
114--vmlinux=<file>:: 119--vmlinux=<file>::
115 vmlinux pathname 120 vmlinux pathname
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index fa043404479e..cc27148635cd 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -61,6 +61,8 @@ 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
64 66
65# Additional ARCH settings for x86 67# Additional ARCH settings for x86
66ifeq ($(ARCH),i386) 68ifeq ($(ARCH),i386)
@@ -274,6 +276,7 @@ LIB_H += util/build-id.h
274LIB_H += util/debug.h 276LIB_H += util/debug.h
275LIB_H += util/debugfs.h 277LIB_H += util/debugfs.h
276LIB_H += util/sysfs.h 278LIB_H += util/sysfs.h
279LIB_H += util/pmu.h
277LIB_H += util/event.h 280LIB_H += util/event.h
278LIB_H += util/evsel.h 281LIB_H += util/evsel.h
279LIB_H += util/evlist.h 282LIB_H += util/evlist.h
@@ -321,6 +324,7 @@ LIB_OBJS += $(OUTPUT)util/config.o
321LIB_OBJS += $(OUTPUT)util/ctype.o 324LIB_OBJS += $(OUTPUT)util/ctype.o
322LIB_OBJS += $(OUTPUT)util/debugfs.o 325LIB_OBJS += $(OUTPUT)util/debugfs.o
323LIB_OBJS += $(OUTPUT)util/sysfs.o 326LIB_OBJS += $(OUTPUT)util/sysfs.o
327LIB_OBJS += $(OUTPUT)util/pmu.o
324LIB_OBJS += $(OUTPUT)util/environment.o 328LIB_OBJS += $(OUTPUT)util/environment.o
325LIB_OBJS += $(OUTPUT)util/event.o 329LIB_OBJS += $(OUTPUT)util/event.o
326LIB_OBJS += $(OUTPUT)util/evlist.o 330LIB_OBJS += $(OUTPUT)util/evlist.o
@@ -357,6 +361,10 @@ LIB_OBJS += $(OUTPUT)util/session.o
357LIB_OBJS += $(OUTPUT)util/thread.o 361LIB_OBJS += $(OUTPUT)util/thread.o
358LIB_OBJS += $(OUTPUT)util/thread_map.o 362LIB_OBJS += $(OUTPUT)util/thread_map.o
359LIB_OBJS += $(OUTPUT)util/trace-event-parse.o 363LIB_OBJS += $(OUTPUT)util/trace-event-parse.o
364LIB_OBJS += $(OUTPUT)util/parse-events-flex.o
365LIB_OBJS += $(OUTPUT)util/parse-events-bison.o
366LIB_OBJS += $(OUTPUT)util/pmu-flex.o
367LIB_OBJS += $(OUTPUT)util/pmu-bison.o
360LIB_OBJS += $(OUTPUT)util/trace-event-read.o 368LIB_OBJS += $(OUTPUT)util/trace-event-read.o
361LIB_OBJS += $(OUTPUT)util/trace-event-info.o 369LIB_OBJS += $(OUTPUT)util/trace-event-info.o
362LIB_OBJS += $(OUTPUT)util/trace-event-scripting.o 370LIB_OBJS += $(OUTPUT)util/trace-event-scripting.o
@@ -499,6 +507,20 @@ else
499 endif 507 endif
500endif 508endif
501 509
510ifdef NO_GTK2
511 BASIC_CFLAGS += -DNO_GTK2
512else
513 FLAGS_GTK2=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) $(shell pkg-config --libs --cflags gtk+-2.0)
514 ifneq ($(call try-cc,$(SOURCE_GTK2),$(FLAGS_GTK2)),y)
515 msg := $(warning GTK2 not found, disables GTK2 support. Please install gtk2-devel or libgtk2.0-dev);
516 BASIC_CFLAGS += -DNO_GTK2_SUPPORT
517 else
518 BASIC_CFLAGS += $(shell pkg-config --cflags gtk+-2.0)
519 EXTLIBS += $(shell pkg-config --libs gtk+-2.0)
520 LIB_OBJS += $(OUTPUT)util/gtk/browser.o
521 endif
522endif
523
502ifdef NO_LIBPERL 524ifdef NO_LIBPERL
503 BASIC_CFLAGS += -DNO_LIBPERL 525 BASIC_CFLAGS += -DNO_LIBPERL
504else 526else
@@ -645,6 +667,8 @@ ifndef V
645 QUIET_LINK = @echo ' ' LINK $@; 667 QUIET_LINK = @echo ' ' LINK $@;
646 QUIET_MKDIR = @echo ' ' MKDIR $@; 668 QUIET_MKDIR = @echo ' ' MKDIR $@;
647 QUIET_GEN = @echo ' ' GEN $@; 669 QUIET_GEN = @echo ' ' GEN $@;
670 QUIET_FLEX = @echo ' ' FLEX $@;
671 QUIET_BISON = @echo ' ' BISON $@;
648endif 672endif
649endif 673endif
650 674
@@ -725,12 +749,19 @@ $(OUTPUT)perf.o perf.spec \
725 $(SCRIPTS) \ 749 $(SCRIPTS) \
726 : $(OUTPUT)PERF-VERSION-FILE 750 : $(OUTPUT)PERF-VERSION-FILE
727 751
752.SUFFIXES:
753.SUFFIXES: .o .c .S .s
754
728$(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS 755$(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
729 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $< 756 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
757$(OUTPUT)%.i: %.c $(OUTPUT)PERF-CFLAGS
758 $(QUIET_CC)$(CC) -o $@ -E $(ALL_CFLAGS) $<
730$(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS 759$(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
731 $(QUIET_CC)$(CC) -S $(ALL_CFLAGS) $< 760 $(QUIET_CC)$(CC) -o $@ -S $(ALL_CFLAGS) $<
732$(OUTPUT)%.o: %.S 761$(OUTPUT)%.o: %.S
733 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $< 762 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
763$(OUTPUT)%.s: %.S
764 $(QUIET_CC)$(CC) -o $@ -E $(ALL_CFLAGS) $<
734 765
735$(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS 766$(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
736 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \ 767 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
@@ -757,6 +788,12 @@ $(OUTPUT)util/ui/browsers/map.o: util/ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
757$(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS 788$(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
758 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $< 789 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
759 790
791$(OUTPUT)util/parse-events-flex.o: util/parse-events-flex.c $(OUTPUT)PERF-CFLAGS
792 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Wno-redundant-decls -Wno-switch-default -Wno-unused-function $<
793
794$(OUTPUT)util/pmu-flex.o: util/pmu-flex.c $(OUTPUT)PERF-CFLAGS
795 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Wno-redundant-decls -Wno-switch-default -Wno-unused-function $<
796
760$(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS 797$(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
761 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $< 798 $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
762 799
@@ -793,6 +830,8 @@ help:
793 @echo ' html - make html documentation' 830 @echo ' html - make html documentation'
794 @echo ' info - make GNU info documentation (access with info <foo>)' 831 @echo ' info - make GNU info documentation (access with info <foo>)'
795 @echo ' pdf - make pdf documentation' 832 @echo ' pdf - make pdf documentation'
833 @echo ' event-parser - make event parser code'
834 @echo ' pmu-parser - make pmu format parser code'
796 @echo ' TAGS - use etags to make tag information for source browsing' 835 @echo ' TAGS - use etags to make tag information for source browsing'
797 @echo ' tags - use ctags to make tag information for source browsing' 836 @echo ' tags - use ctags to make tag information for source browsing'
798 @echo ' cscope - use cscope to make interactive browsing database' 837 @echo ' cscope - use cscope to make interactive browsing database'
@@ -842,6 +881,14 @@ cscope:
842 $(RM) cscope* 881 $(RM) cscope*
843 $(FIND) . -name '*.[hcS]' -print | xargs cscope -b 882 $(FIND) . -name '*.[hcS]' -print | xargs cscope -b
844 883
884event-parser:
885 $(QUIET_BISON)$(BISON) -v util/parse-events.y -d -o util/parse-events-bison.c
886 $(QUIET_FLEX)$(FLEX) --header-file=util/parse-events-flex.h -t util/parse-events.l > util/parse-events-flex.c
887
888pmu-parser:
889 $(QUIET_BISON)$(BISON) -v util/pmu.y -d -o util/pmu-bison.c
890 $(QUIET_FLEX)$(FLEX) --header-file=util/pmu-flex.h -t util/pmu.l > util/pmu-flex.c
891
845### Detect prefix changes 892### Detect prefix changes
846TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\ 893TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\
847 $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ) 894 $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 8e91c6eba18a..2e317438980b 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -40,7 +40,7 @@ struct perf_report {
40 struct perf_tool tool; 40 struct perf_tool tool;
41 struct perf_session *session; 41 struct perf_session *session;
42 char const *input_name; 42 char const *input_name;
43 bool force, use_tui, use_stdio; 43 bool force, use_tui, use_gtk, use_stdio;
44 bool hide_unresolved; 44 bool hide_unresolved;
45 bool dont_use_callchains; 45 bool dont_use_callchains;
46 bool show_full_info; 46 bool show_full_info;
@@ -50,6 +50,7 @@ struct perf_report {
50 const char *pretty_printing_style; 50 const char *pretty_printing_style;
51 symbol_filter_t annotate_init; 51 symbol_filter_t annotate_init;
52 const char *cpu_list; 52 const char *cpu_list;
53 const char *symbol_filter_str;
53 DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS); 54 DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
54}; 55};
55 56
@@ -400,6 +401,9 @@ static int __cmd_report(struct perf_report *rep)
400 list_for_each_entry(pos, &session->evlist->entries, node) { 401 list_for_each_entry(pos, &session->evlist->entries, node) {
401 struct hists *hists = &pos->hists; 402 struct hists *hists = &pos->hists;
402 403
404 if (pos->idx == 0)
405 hists->symbol_filter_str = rep->symbol_filter_str;
406
403 hists__collapse_resort(hists); 407 hists__collapse_resort(hists);
404 hists__output_resort(hists); 408 hists__output_resort(hists);
405 nr_samples += hists->stats.nr_events[PERF_RECORD_SAMPLE]; 409 nr_samples += hists->stats.nr_events[PERF_RECORD_SAMPLE];
@@ -411,8 +415,13 @@ static int __cmd_report(struct perf_report *rep)
411 } 415 }
412 416
413 if (use_browser > 0) { 417 if (use_browser > 0) {
414 perf_evlist__tui_browse_hists(session->evlist, help, 418 if (use_browser == 1) {
415 NULL, NULL, 0); 419 perf_evlist__tui_browse_hists(session->evlist, help,
420 NULL, NULL, 0);
421 } else if (use_browser == 2) {
422 perf_evlist__gtk_browse_hists(session->evlist, help,
423 NULL, NULL, 0);
424 }
416 } else 425 } else
417 perf_evlist__tty_browse_hists(session->evlist, rep, help); 426 perf_evlist__tty_browse_hists(session->evlist, rep, help);
418 427
@@ -569,6 +578,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
569 OPT_STRING(0, "pretty", &report.pretty_printing_style, "key", 578 OPT_STRING(0, "pretty", &report.pretty_printing_style, "key",
570 "pretty printing style key: normal raw"), 579 "pretty printing style key: normal raw"),
571 OPT_BOOLEAN(0, "tui", &report.use_tui, "Use the TUI interface"), 580 OPT_BOOLEAN(0, "tui", &report.use_tui, "Use the TUI interface"),
581 OPT_BOOLEAN(0, "gtk", &report.use_gtk, "Use the GTK2 interface"),
572 OPT_BOOLEAN(0, "stdio", &report.use_stdio, 582 OPT_BOOLEAN(0, "stdio", &report.use_stdio,
573 "Use the stdio interface"), 583 "Use the stdio interface"),
574 OPT_STRING('s', "sort", &sort_order, "key[,key2...]", 584 OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
@@ -591,6 +601,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
591 "only consider symbols in these comms"), 601 "only consider symbols in these comms"),
592 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]", 602 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
593 "only consider these symbols"), 603 "only consider these symbols"),
604 OPT_STRING(0, "symbol-filter", &report.symbol_filter_str, "filter",
605 "only show symbols that (partially) match with this filter"),
594 OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str, 606 OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
595 "width[,width...]", 607 "width[,width...]",
596 "don't try to adjust column width, use these fixed values"), 608 "don't try to adjust column width, use these fixed values"),
@@ -624,6 +636,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
624 use_browser = 0; 636 use_browser = 0;
625 else if (report.use_tui) 637 else if (report.use_tui)
626 use_browser = 1; 638 use_browser = 1;
639 else if (report.use_gtk)
640 use_browser = 2;
627 641
628 if (report.inverted_callchain) 642 if (report.inverted_callchain)
629 callchain_param.order = ORDER_CALLER; 643 callchain_param.order = ORDER_CALLER;
@@ -660,7 +674,10 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
660 } 674 }
661 675
662 if (strcmp(report.input_name, "-") != 0) { 676 if (strcmp(report.input_name, "-") != 0) {
663 setup_browser(true); 677 if (report.use_gtk)
678 perf_gtk_setup_browser(argc, argv, true);
679 else
680 setup_browser(true);
664 } else { 681 } else {
665 use_browser = 0; 682 use_browser = 0;
666 } 683 }
@@ -709,11 +726,16 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
709 } else 726 } else
710 symbol_conf.exclude_other = false; 727 symbol_conf.exclude_other = false;
711 728
712 /* 729 if (argc) {
713 * Any (unrecognized) arguments left? 730 /*
714 */ 731 * Special case: if there's an argument left then assume that
715 if (argc) 732 * it's a symbol filter:
716 usage_with_options(report_usage, options); 733 */
734 if (argc > 1)
735 usage_with_options(report_usage, options);
736
737 report.symbol_filter_str = argv[0];
738 }
717 739
718 sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout); 740 sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
719 741
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index ea40e4e8b227..c941bb640f49 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -296,7 +296,7 @@ static int create_perf_stat_counter(struct perf_evsel *evsel,
296 if (system_wide) 296 if (system_wide)
297 return perf_evsel__open_per_cpu(evsel, evsel_list->cpus, 297 return perf_evsel__open_per_cpu(evsel, evsel_list->cpus,
298 group, group_fd); 298 group, group_fd);
299 if (!target_pid && !target_tid) { 299 if (!target_pid && !target_tid && (!group || evsel == first)) {
300 attr->disabled = 1; 300 attr->disabled = 1;
301 attr->enable_on_exec = 1; 301 attr->enable_on_exec = 1;
302 } 302 }
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
index 3e087ce8daa6..86874238a350 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -13,6 +13,7 @@
13#include "util/parse-events.h" 13#include "util/parse-events.h"
14#include "util/symbol.h" 14#include "util/symbol.h"
15#include "util/thread_map.h" 15#include "util/thread_map.h"
16#include "util/pmu.h"
16#include "../../include/linux/hw_breakpoint.h" 17#include "../../include/linux/hw_breakpoint.h"
17 18
18#include <sys/mman.h> 19#include <sys/mman.h>
@@ -650,7 +651,7 @@ static int test__checkevent_raw(struct perf_evlist *evlist)
650 651
651 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries); 652 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
652 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type); 653 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
653 TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config); 654 TEST_ASSERT_VAL("wrong config", 0x1a == evsel->attr.config);
654 return 0; 655 return 0;
655} 656}
656 657
@@ -677,6 +678,24 @@ static int test__checkevent_symbolic_name(struct perf_evlist *evlist)
677 return 0; 678 return 0;
678} 679}
679 680
681static int test__checkevent_symbolic_name_config(struct perf_evlist *evlist)
682{
683 struct perf_evsel *evsel = list_entry(evlist->entries.next,
684 struct perf_evsel, node);
685
686 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
687 TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
688 TEST_ASSERT_VAL("wrong config",
689 PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
690 TEST_ASSERT_VAL("wrong period",
691 100000 == evsel->attr.sample_period);
692 TEST_ASSERT_VAL("wrong config1",
693 0 == evsel->attr.config1);
694 TEST_ASSERT_VAL("wrong config2",
695 1 == evsel->attr.config2);
696 return 0;
697}
698
680static int test__checkevent_symbolic_alias(struct perf_evlist *evlist) 699static int test__checkevent_symbolic_alias(struct perf_evlist *evlist)
681{ 700{
682 struct perf_evsel *evsel = list_entry(evlist->entries.next, 701 struct perf_evsel *evsel = list_entry(evlist->entries.next,
@@ -858,6 +877,22 @@ static int test__checkevent_genhw_modifier(struct perf_evlist *evlist)
858 return test__checkevent_genhw(evlist); 877 return test__checkevent_genhw(evlist);
859} 878}
860 879
880static int test__checkevent_pmu(struct perf_evlist *evlist)
881{
882
883 struct perf_evsel *evsel = list_entry(evlist->entries.next,
884 struct perf_evsel, node);
885
886 TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
887 TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
888 TEST_ASSERT_VAL("wrong config", 10 == evsel->attr.config);
889 TEST_ASSERT_VAL("wrong config1", 1 == evsel->attr.config1);
890 TEST_ASSERT_VAL("wrong config2", 3 == evsel->attr.config2);
891 TEST_ASSERT_VAL("wrong period", 1000 == evsel->attr.sample_period);
892
893 return 0;
894}
895
861static struct test__event_st { 896static struct test__event_st {
862 const char *name; 897 const char *name;
863 __u32 type; 898 __u32 type;
@@ -872,7 +907,7 @@ static struct test__event_st {
872 .check = test__checkevent_tracepoint_multi, 907 .check = test__checkevent_tracepoint_multi,
873 }, 908 },
874 { 909 {
875 .name = "r1", 910 .name = "r1a",
876 .check = test__checkevent_raw, 911 .check = test__checkevent_raw,
877 }, 912 },
878 { 913 {
@@ -884,6 +919,10 @@ static struct test__event_st {
884 .check = test__checkevent_symbolic_name, 919 .check = test__checkevent_symbolic_name,
885 }, 920 },
886 { 921 {
922 .name = "cycles/period=100000,config2/",
923 .check = test__checkevent_symbolic_name_config,
924 },
925 {
887 .name = "faults", 926 .name = "faults",
888 .check = test__checkevent_symbolic_alias, 927 .check = test__checkevent_symbolic_alias,
889 }, 928 },
@@ -916,7 +955,7 @@ static struct test__event_st {
916 .check = test__checkevent_tracepoint_multi_modifier, 955 .check = test__checkevent_tracepoint_multi_modifier,
917 }, 956 },
918 { 957 {
919 .name = "r1:kp", 958 .name = "r1a:kp",
920 .check = test__checkevent_raw_modifier, 959 .check = test__checkevent_raw_modifier,
921 }, 960 },
922 { 961 {
@@ -935,6 +974,10 @@ static struct test__event_st {
935 .name = "L1-dcache-load-miss:kp", 974 .name = "L1-dcache-load-miss:kp",
936 .check = test__checkevent_genhw_modifier, 975 .check = test__checkevent_genhw_modifier,
937 }, 976 },
977 {
978 .name = "cpu/config=10,config1,config2=3,period=1000/u",
979 .check = test__checkevent_pmu,
980 },
938}; 981};
939 982
940#define TEST__EVENTS_CNT (sizeof(test__events) / sizeof(struct test__event_st)) 983#define TEST__EVENTS_CNT (sizeof(test__events) / sizeof(struct test__event_st))
@@ -1462,6 +1505,11 @@ static int test__rdpmc(void)
1462 1505
1463#endif 1506#endif
1464 1507
1508static int test__perf_pmu(void)
1509{
1510 return perf_pmu__test();
1511}
1512
1465static struct test { 1513static struct test {
1466 const char *desc; 1514 const char *desc;
1467 int (*func)(void); 1515 int (*func)(void);
@@ -1497,6 +1545,10 @@ static struct test {
1497 .func = test__PERF_RECORD, 1545 .func = test__PERF_RECORD,
1498 }, 1546 },
1499 { 1547 {
1548 .desc = "Test perf pmu format parsing",
1549 .func = test__perf_pmu,
1550 },
1551 {
1500 .func = NULL, 1552 .func = NULL,
1501 }, 1553 },
1502}; 1554};
diff --git a/tools/perf/config/feature-tests.mak b/tools/perf/config/feature-tests.mak
index 6170fd2531b5..d9084e03ce56 100644
--- a/tools/perf/config/feature-tests.mak
+++ b/tools/perf/config/feature-tests.mak
@@ -65,6 +65,21 @@ int main(void)
65endef 65endef
66endif 66endif
67 67
68ifndef NO_GTK2
69define SOURCE_GTK2
70#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
71#include <gtk/gtk.h>
72#pragma GCC diagnostic error \"-Wstrict-prototypes\"
73
74int main(int argc, char *argv[])
75{
76 gtk_init(&argc, &argv);
77
78 return 0;
79}
80endef
81endif
82
68ifndef NO_LIBPERL 83ifndef NO_LIBPERL
69define SOURCE_PERL_EMBED 84define SOURCE_PERL_EMBED
70#include <EXTERN.h> 85#include <EXTERN.h>
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index fc5e5a09d5b9..8dd224df3e54 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -45,6 +45,18 @@ void setup_browser(bool fallback_to_pager);
45void exit_browser(bool wait_for_ok); 45void exit_browser(bool wait_for_ok);
46#endif 46#endif
47 47
48#ifdef NO_GTK2_SUPPORT
49static inline void perf_gtk_setup_browser(int argc __used, const char *argv[] __used, bool fallback_to_pager)
50{
51 if (fallback_to_pager)
52 setup_pager();
53}
54static inline void perf_gtk_exit_browser(bool wait_for_ok __used) {}
55#else
56void perf_gtk_setup_browser(int argc, const char *argv[], bool fallback_to_pager);
57void perf_gtk_exit_browser(bool wait_for_ok);
58#endif
59
48char *alias_lookup(const char *alias); 60char *alias_lookup(const char *alias);
49int split_cmdline(char *cmdline, const char ***argv); 61int split_cmdline(char *cmdline, const char ***argv);
50 62
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 159263d17c2d..1986d8051bd1 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -51,13 +51,15 @@ struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
51void perf_evlist__config_attrs(struct perf_evlist *evlist, 51void perf_evlist__config_attrs(struct perf_evlist *evlist,
52 struct perf_record_opts *opts) 52 struct perf_record_opts *opts)
53{ 53{
54 struct perf_evsel *evsel; 54 struct perf_evsel *evsel, *first;
55 55
56 if (evlist->cpus->map[0] < 0) 56 if (evlist->cpus->map[0] < 0)
57 opts->no_inherit = true; 57 opts->no_inherit = true;
58 58
59 first = list_entry(evlist->entries.next, struct perf_evsel, node);
60
59 list_for_each_entry(evsel, &evlist->entries, node) { 61 list_for_each_entry(evsel, &evlist->entries, node) {
60 perf_evsel__config(evsel, opts); 62 perf_evsel__config(evsel, opts, first);
61 63
62 if (evlist->nr_entries > 1) 64 if (evlist->nr_entries > 1)
63 evsel->attr.sample_type |= PERF_SAMPLE_ID; 65 evsel->attr.sample_type |= PERF_SAMPLE_ID;
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index f421f7cbc0d3..0221700075c5 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -63,7 +63,8 @@ struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
63 return evsel; 63 return evsel;
64} 64}
65 65
66void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts) 66void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
67 struct perf_evsel *first)
67{ 68{
68 struct perf_event_attr *attr = &evsel->attr; 69 struct perf_event_attr *attr = &evsel->attr;
69 int track = !evsel->idx; /* only the first counter needs these */ 70 int track = !evsel->idx; /* only the first counter needs these */
@@ -134,7 +135,8 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts)
134 attr->mmap = track; 135 attr->mmap = track;
135 attr->comm = track; 136 attr->comm = track;
136 137
137 if (!opts->target_pid && !opts->target_tid && !opts->system_wide) { 138 if (!opts->target_pid && !opts->target_tid && !opts->system_wide &&
139 (!opts->group || evsel == first)) {
138 attr->disabled = 1; 140 attr->disabled = 1;
139 attr->enable_on_exec = 1; 141 attr->enable_on_exec = 1;
140 } 142 }
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 326b8e4d5035..3158ca3d69a1 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -80,7 +80,8 @@ void perf_evsel__exit(struct perf_evsel *evsel);
80void perf_evsel__delete(struct perf_evsel *evsel); 80void perf_evsel__delete(struct perf_evsel *evsel);
81 81
82void perf_evsel__config(struct perf_evsel *evsel, 82void perf_evsel__config(struct perf_evsel *evsel,
83 struct perf_record_opts *opts); 83 struct perf_record_opts *opts,
84 struct perf_evsel *first);
84 85
85int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads); 86int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
86int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads); 87int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads);
diff --git a/tools/perf/util/gtk/browser.c b/tools/perf/util/gtk/browser.c
new file mode 100644
index 000000000000..258352a2356c
--- /dev/null
+++ b/tools/perf/util/gtk/browser.c
@@ -0,0 +1,189 @@
1#include "../evlist.h"
2#include "../cache.h"
3#include "../evsel.h"
4#include "../sort.h"
5#include "../hist.h"
6#include "gtk.h"
7
8#include <signal.h>
9
10#define MAX_COLUMNS 32
11
12void perf_gtk_setup_browser(int argc, const char *argv[],
13 bool fallback_to_pager __used)
14{
15 gtk_init(&argc, (char ***)&argv);
16}
17
18void perf_gtk_exit_browser(bool wait_for_ok __used)
19{
20 gtk_main_quit();
21}
22
23static void perf_gtk_signal(int sig)
24{
25 psignal(sig, "perf");
26 gtk_main_quit();
27}
28
29static void perf_gtk_resize_window(GtkWidget *window)
30{
31 GdkRectangle rect;
32 GdkScreen *screen;
33 int monitor;
34 int height;
35 int width;
36
37 screen = gtk_widget_get_screen(window);
38
39 monitor = gdk_screen_get_monitor_at_window(screen, window->window);
40
41 gdk_screen_get_monitor_geometry(screen, monitor, &rect);
42
43 width = rect.width * 3 / 4;
44 height = rect.height * 3 / 4;
45
46 gtk_window_resize(GTK_WINDOW(window), width, height);
47}
48
49static void perf_gtk_show_hists(GtkWidget *window, struct hists *hists)
50{
51 GType col_types[MAX_COLUMNS];
52 GtkCellRenderer *renderer;
53 struct sort_entry *se;
54 GtkListStore *store;
55 struct rb_node *nd;
56 u64 total_period;
57 GtkWidget *view;
58 int col_idx;
59 int nr_cols;
60
61 nr_cols = 0;
62
63 /* The percentage column */
64 col_types[nr_cols++] = G_TYPE_STRING;
65
66 list_for_each_entry(se, &hist_entry__sort_list, list) {
67 if (se->elide)
68 continue;
69
70 col_types[nr_cols++] = G_TYPE_STRING;
71 }
72
73 store = gtk_list_store_newv(nr_cols, col_types);
74
75 view = gtk_tree_view_new();
76
77 renderer = gtk_cell_renderer_text_new();
78
79 col_idx = 0;
80
81 /* The percentage column */
82 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
83 -1, "Overhead (%)",
84 renderer, "text",
85 col_idx++, NULL);
86
87 list_for_each_entry(se, &hist_entry__sort_list, list) {
88 if (se->elide)
89 continue;
90
91 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
92 -1, se->se_header,
93 renderer, "text",
94 col_idx++, NULL);
95 }
96
97 gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
98
99 g_object_unref(GTK_TREE_MODEL(store));
100
101 total_period = hists->stats.total_period;
102
103 for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
104 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
105 GtkTreeIter iter;
106 double percent;
107 char s[512];
108
109 if (h->filtered)
110 continue;
111
112 gtk_list_store_append(store, &iter);
113
114 col_idx = 0;
115
116 percent = (h->period * 100.0) / total_period;
117
118 snprintf(s, ARRAY_SIZE(s), "%.2f", percent);
119
120 gtk_list_store_set(store, &iter, col_idx++, s, -1);
121
122 list_for_each_entry(se, &hist_entry__sort_list, list) {
123 if (se->elide)
124 continue;
125
126 se->se_snprintf(h, s, ARRAY_SIZE(s),
127 hists__col_len(hists, se->se_width_idx));
128
129 gtk_list_store_set(store, &iter, col_idx++, s, -1);
130 }
131 }
132
133 gtk_container_add(GTK_CONTAINER(window), view);
134}
135
136int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
137 const char *help __used,
138 void (*timer) (void *arg)__used,
139 void *arg __used, int delay_secs __used)
140{
141 struct perf_evsel *pos;
142 GtkWidget *notebook;
143 GtkWidget *window;
144
145 signal(SIGSEGV, perf_gtk_signal);
146 signal(SIGFPE, perf_gtk_signal);
147 signal(SIGINT, perf_gtk_signal);
148 signal(SIGQUIT, perf_gtk_signal);
149 signal(SIGTERM, perf_gtk_signal);
150
151 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
152
153 gtk_window_set_title(GTK_WINDOW(window), "perf report");
154
155 g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
156
157 notebook = gtk_notebook_new();
158
159 list_for_each_entry(pos, &evlist->entries, node) {
160 struct hists *hists = &pos->hists;
161 const char *evname = event_name(pos);
162 GtkWidget *scrolled_window;
163 GtkWidget *tab_label;
164
165 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
166
167 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
168 GTK_POLICY_AUTOMATIC,
169 GTK_POLICY_AUTOMATIC);
170
171 perf_gtk_show_hists(scrolled_window, hists);
172
173 tab_label = gtk_label_new(evname);
174
175 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
176 }
177
178 gtk_container_add(GTK_CONTAINER(window), notebook);
179
180 gtk_widget_show_all(window);
181
182 perf_gtk_resize_window(window);
183
184 gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
185
186 gtk_main();
187
188 return 0;
189}
diff --git a/tools/perf/util/gtk/gtk.h b/tools/perf/util/gtk/gtk.h
new file mode 100644
index 000000000000..75177ee04032
--- /dev/null
+++ b/tools/perf/util/gtk/gtk.h
@@ -0,0 +1,8 @@
1#ifndef _PERF_GTK_H_
2#define _PERF_GTK_H_ 1
3
4#pragma GCC diagnostic ignored "-Wstrict-prototypes"
5#include <gtk/gtk.h>
6#pragma GCC diagnostic error "-Wstrict-prototypes"
7
8#endif /* _PERF_GTK_H_ */
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 8380c3db1c92..2c624ad371a7 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -10,11 +10,14 @@ static bool hists__filter_entry_by_dso(struct hists *hists,
10 struct hist_entry *he); 10 struct hist_entry *he);
11static bool hists__filter_entry_by_thread(struct hists *hists, 11static bool hists__filter_entry_by_thread(struct hists *hists,
12 struct hist_entry *he); 12 struct hist_entry *he);
13static bool hists__filter_entry_by_symbol(struct hists *hists,
14 struct hist_entry *he);
13 15
14enum hist_filter { 16enum hist_filter {
15 HIST_FILTER__DSO, 17 HIST_FILTER__DSO,
16 HIST_FILTER__THREAD, 18 HIST_FILTER__THREAD,
17 HIST_FILTER__PARENT, 19 HIST_FILTER__PARENT,
20 HIST_FILTER__SYMBOL,
18}; 21};
19 22
20struct callchain_param callchain_param = { 23struct callchain_param callchain_param = {
@@ -420,6 +423,7 @@ static void hists__apply_filters(struct hists *hists, struct hist_entry *he)
420{ 423{
421 hists__filter_entry_by_dso(hists, he); 424 hists__filter_entry_by_dso(hists, he);
422 hists__filter_entry_by_thread(hists, he); 425 hists__filter_entry_by_thread(hists, he);
426 hists__filter_entry_by_symbol(hists, he);
423} 427}
424 428
425static void __hists__collapse_resort(struct hists *hists, bool threaded) 429static void __hists__collapse_resort(struct hists *hists, bool threaded)
@@ -1247,6 +1251,37 @@ void hists__filter_by_thread(struct hists *hists)
1247 } 1251 }
1248} 1252}
1249 1253
1254static bool hists__filter_entry_by_symbol(struct hists *hists,
1255 struct hist_entry *he)
1256{
1257 if (hists->symbol_filter_str != NULL &&
1258 (!he->ms.sym || strstr(he->ms.sym->name,
1259 hists->symbol_filter_str) == NULL)) {
1260 he->filtered |= (1 << HIST_FILTER__SYMBOL);
1261 return true;
1262 }
1263
1264 return false;
1265}
1266
1267void hists__filter_by_symbol(struct hists *hists)
1268{
1269 struct rb_node *nd;
1270
1271 hists->nr_entries = hists->stats.total_period = 0;
1272 hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
1273 hists__reset_col_len(hists);
1274
1275 for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
1276 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
1277
1278 if (hists__filter_entry_by_symbol(hists, h))
1279 continue;
1280
1281 hists__remove_entry_filter(hists, h, HIST_FILTER__SYMBOL);
1282 }
1283}
1284
1250int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip) 1285int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip)
1251{ 1286{
1252 return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip); 1287 return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip);
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 9413f3e31fea..2cae9df40e04 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -62,6 +62,7 @@ struct hists {
62 const struct thread *thread_filter; 62 const struct thread *thread_filter;
63 const struct dso *dso_filter; 63 const struct dso *dso_filter;
64 const char *uid_filter_str; 64 const char *uid_filter_str;
65 const char *symbol_filter_str;
65 pthread_mutex_t lock; 66 pthread_mutex_t lock;
66 struct events_stats stats; 67 struct events_stats stats;
67 u64 event_stream; 68 u64 event_stream;
@@ -107,6 +108,7 @@ int hist_entry__annotate(struct hist_entry *self, size_t privsize);
107 108
108void hists__filter_by_dso(struct hists *hists); 109void hists__filter_by_dso(struct hists *hists);
109void hists__filter_by_thread(struct hists *hists); 110void hists__filter_by_thread(struct hists *hists);
111void hists__filter_by_symbol(struct hists *hists);
110 112
111u16 hists__col_len(struct hists *self, enum hist_column col); 113u16 hists__col_len(struct hists *self, enum hist_column col);
112void hists__set_col_len(struct hists *self, enum hist_column col, u16 len); 114void hists__set_col_len(struct hists *self, enum hist_column col, u16 len);
@@ -145,6 +147,23 @@ int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
145 int refresh); 147 int refresh);
146#endif 148#endif
147 149
150#ifdef NO_GTK2_SUPPORT
151static inline
152int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist __used,
153 const char *help __used,
154 void(*timer)(void *arg) __used,
155 void *arg __used,
156 int refresh __used)
157{
158 return 0;
159}
160
161#else
162int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist, const char *help,
163 void(*timer)(void *arg), void *arg,
164 int refresh);
165#endif
166
148unsigned int hists__sort_list_width(struct hists *self); 167unsigned int hists__sort_list_width(struct hists *self);
149 168
150#endif /* __PERF_HIST_H */ 169#endif /* __PERF_HIST_H */
diff --git a/tools/perf/util/parse-events-bison.c b/tools/perf/util/parse-events-bison.c
new file mode 100644
index 000000000000..4a0fd6d5cebf
--- /dev/null
+++ b/tools/perf/util/parse-events-bison.c
@@ -0,0 +1,1852 @@
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 parse_events_parse
67#define yylex parse_events_lex
68#define yyerror parse_events_error
69#define yylval parse_events_lval
70#define yychar parse_events_char
71#define yydebug parse_events_debug
72#define yynerrs parse_events_nerrs
73
74
75/* Copy the first part of user declarations. */
76
77/* Line 189 of yacc.c */
78#line 6 "util/parse-events.y"
79
80
81#define YYDEBUG 1
82
83#include <linux/compiler.h>
84#include <linux/list.h>
85#include "types.h"
86#include "util.h"
87#include "parse-events.h"
88
89extern int parse_events_lex (void);
90
91#define ABORT_ON(val) \
92do { \
93 if (val) \
94 YYABORT; \
95} while (0)
96
97
98
99/* Line 189 of yacc.c */
100#line 101 "util/parse-events-bison.c"
101
102/* Enabling traces. */
103#ifndef YYDEBUG
104# define YYDEBUG 0
105#endif
106
107/* Enabling verbose error messages. */
108#ifdef YYERROR_VERBOSE
109# undef YYERROR_VERBOSE
110# define YYERROR_VERBOSE 1
111#else
112# define YYERROR_VERBOSE 0
113#endif
114
115/* Enabling the token table. */
116#ifndef YYTOKEN_TABLE
117# define YYTOKEN_TABLE 0
118#endif
119
120
121/* Tokens. */
122#ifndef YYTOKENTYPE
123# define YYTOKENTYPE
124 /* Put the tokens into the symbol table, so that GDB and other debuggers
125 know about them. */
126 enum yytokentype {
127 PE_VALUE = 258,
128 PE_VALUE_SYM = 259,
129 PE_RAW = 260,
130 PE_TERM = 261,
131 PE_NAME = 262,
132 PE_MODIFIER_EVENT = 263,
133 PE_MODIFIER_BP = 264,
134 PE_NAME_CACHE_TYPE = 265,
135 PE_NAME_CACHE_OP_RESULT = 266,
136 PE_PREFIX_MEM = 267,
137 PE_PREFIX_RAW = 268,
138 PE_ERROR = 269
139 };
140#endif
141
142
143
144#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
145typedef union YYSTYPE
146{
147
148/* Line 214 of yacc.c */
149#line 45 "util/parse-events.y"
150
151 char *str;
152 unsigned long num;
153 struct list_head *head;
154 struct parse_events__term *term;
155
156
157
158/* Line 214 of yacc.c */
159#line 160 "util/parse-events-bison.c"
160} YYSTYPE;
161# define YYSTYPE_IS_TRIVIAL 1
162# define yystype YYSTYPE /* obsolescent; will be withdrawn */
163# define YYSTYPE_IS_DECLARED 1
164#endif
165
166
167/* Copy the second part of user declarations. */
168
169
170/* Line 264 of yacc.c */
171#line 172 "util/parse-events-bison.c"
172
173#ifdef short
174# undef short
175#endif
176
177#ifdef YYTYPE_UINT8
178typedef YYTYPE_UINT8 yytype_uint8;
179#else
180typedef unsigned char yytype_uint8;
181#endif
182
183#ifdef YYTYPE_INT8
184typedef YYTYPE_INT8 yytype_int8;
185#elif (defined __STDC__ || defined __C99__FUNC__ \
186 || defined __cplusplus || defined _MSC_VER)
187typedef signed char yytype_int8;
188#else
189typedef short int yytype_int8;
190#endif
191
192#ifdef YYTYPE_UINT16
193typedef YYTYPE_UINT16 yytype_uint16;
194#else
195typedef unsigned short int yytype_uint16;
196#endif
197
198#ifdef YYTYPE_INT16
199typedef YYTYPE_INT16 yytype_int16;
200#else
201typedef short int yytype_int16;
202#endif
203
204#ifndef YYSIZE_T
205# ifdef __SIZE_TYPE__
206# define YYSIZE_T __SIZE_TYPE__
207# elif defined size_t
208# define YYSIZE_T size_t
209# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
210 || defined __cplusplus || defined _MSC_VER)
211# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
212# define YYSIZE_T size_t
213# else
214# define YYSIZE_T unsigned int
215# endif
216#endif
217
218#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
219
220#ifndef YY_
221# if defined YYENABLE_NLS && YYENABLE_NLS
222# if ENABLE_NLS
223# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
224# define YY_(msgid) dgettext ("bison-runtime", msgid)
225# endif
226# endif
227# ifndef YY_
228# define YY_(msgid) msgid
229# endif
230#endif
231
232/* Suppress unused-variable warnings by "using" E. */
233#if ! defined lint || defined __GNUC__
234# define YYUSE(e) ((void) (e))
235#else
236# define YYUSE(e) /* empty */
237#endif
238
239/* Identity function, used to suppress warnings about constant conditions. */
240#ifndef lint
241# define YYID(n) (n)
242#else
243#if (defined __STDC__ || defined __C99__FUNC__ \
244 || defined __cplusplus || defined _MSC_VER)
245static int
246YYID (int yyi)
247#else
248static int
249YYID (yyi)
250 int yyi;
251#endif
252{
253 return yyi;
254}
255#endif
256
257#if ! defined yyoverflow || YYERROR_VERBOSE
258
259/* The parser invokes alloca or malloc; define the necessary symbols. */
260
261# ifdef YYSTACK_USE_ALLOCA
262# if YYSTACK_USE_ALLOCA
263# ifdef __GNUC__
264# define YYSTACK_ALLOC __builtin_alloca
265# elif defined __BUILTIN_VA_ARG_INCR
266# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
267# elif defined _AIX
268# define YYSTACK_ALLOC __alloca
269# elif defined _MSC_VER
270# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
271# define alloca _alloca
272# else
273# define YYSTACK_ALLOC alloca
274# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
275 || defined __cplusplus || defined _MSC_VER)
276# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
277# ifndef _STDLIB_H
278# define _STDLIB_H 1
279# endif
280# endif
281# endif
282# endif
283# endif
284
285# ifdef YYSTACK_ALLOC
286 /* Pacify GCC's `empty if-body' warning. */
287# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
288# ifndef YYSTACK_ALLOC_MAXIMUM
289 /* The OS might guarantee only one guard page at the bottom of the stack,
290 and a page size can be as small as 4096 bytes. So we cannot safely
291 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
292 to allow for a few compiler-allocated temporary stack slots. */
293# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
294# endif
295# else
296# define YYSTACK_ALLOC YYMALLOC
297# define YYSTACK_FREE YYFREE
298# ifndef YYSTACK_ALLOC_MAXIMUM
299# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
300# endif
301# if (defined __cplusplus && ! defined _STDLIB_H \
302 && ! ((defined YYMALLOC || defined malloc) \
303 && (defined YYFREE || defined free)))
304# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
305# ifndef _STDLIB_H
306# define _STDLIB_H 1
307# endif
308# endif
309# ifndef YYMALLOC
310# define YYMALLOC malloc
311# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
312 || defined __cplusplus || defined _MSC_VER)
313void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
314# endif
315# endif
316# ifndef YYFREE
317# define YYFREE free
318# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
319 || defined __cplusplus || defined _MSC_VER)
320void free (void *); /* INFRINGES ON USER NAME SPACE */
321# endif
322# endif
323# endif
324#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
325
326
327#if (! defined yyoverflow \
328 && (! defined __cplusplus \
329 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
330
331/* A type that is properly aligned for any stack member. */
332union yyalloc
333{
334 yytype_int16 yyss_alloc;
335 YYSTYPE yyvs_alloc;
336};
337
338/* The size of the maximum gap between one aligned stack and the next. */
339# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
340
341/* The size of an array large to enough to hold all stacks, each with
342 N elements. */
343# define YYSTACK_BYTES(N) \
344 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
345 + YYSTACK_GAP_MAXIMUM)
346
347/* Copy COUNT objects from FROM to TO. The source and destination do
348 not overlap. */
349# ifndef YYCOPY
350# if defined __GNUC__ && 1 < __GNUC__
351# define YYCOPY(To, From, Count) \
352 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
353# else
354# define YYCOPY(To, From, Count) \
355 do \
356 { \
357 YYSIZE_T yyi; \
358 for (yyi = 0; yyi < (Count); yyi++) \
359 (To)[yyi] = (From)[yyi]; \
360 } \
361 while (YYID (0))
362# endif
363# endif
364
365/* Relocate STACK from its old location to the new one. The
366 local variables YYSIZE and YYSTACKSIZE give the old and new number of
367 elements in the stack, and YYPTR gives the new location of the
368 stack. Advance YYPTR to a properly aligned location for the next
369 stack. */
370# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
371 do \
372 { \
373 YYSIZE_T yynewbytes; \
374 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
375 Stack = &yyptr->Stack_alloc; \
376 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
377 yyptr += yynewbytes / sizeof (*yyptr); \
378 } \
379 while (YYID (0))
380
381#endif
382
383/* YYFINAL -- State number of the termination state. */
384#define YYFINAL 25
385/* YYLAST -- Last index in YYTABLE. */
386#define YYLAST 43
387
388/* YYNTOKENS -- Number of terminals. */
389#define YYNTOKENS 20
390/* YYNNTS -- Number of nonterminals. */
391#define YYNNTS 15
392/* YYNRULES -- Number of rules. */
393#define YYNRULES 35
394/* YYNRULES -- Number of states. */
395#define YYNSTATES 57
396
397/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
398#define YYUNDEFTOK 2
399#define YYMAXUTOK 269
400
401#define YYTRANSLATE(YYX) \
402 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
403
404/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
405static const yytype_uint8 yytranslate[] =
406{
407 0, 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, 15, 17, 2, 16, 2, 2,
412 2, 2, 2, 2, 2, 2, 2, 2, 18, 2,
413 2, 19, 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, 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, 1, 2, 3, 4,
433 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
434};
435
436#if YYDEBUG
437/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
438 YYRHS. */
439static const yytype_uint8 yyprhs[] =
440{
441 0, 0, 3, 7, 9, 12, 14, 16, 18, 21,
442 23, 26, 29, 32, 37, 42, 45, 51, 55, 57,
443 63, 67, 71, 75, 77, 81, 83, 87, 91, 93,
444 97, 99, 101, 102, 104, 106
445};
446
447/* YYRHS -- A `-1'-separated list of the rules' RHS. */
448static const yytype_int8 yyrhs[] =
449{
450 21, 0, -1, 21, 15, 22, -1, 22, -1, 23,
451 8, -1, 23, -1, 24, -1, 25, -1, 26, 33,
452 -1, 27, -1, 28, 33, -1, 29, 33, -1, 30,
453 33, -1, 7, 16, 31, 16, -1, 4, 16, 31,
454 16, -1, 4, 34, -1, 10, 17, 11, 17, 11,
455 -1, 10, 17, 11, -1, 10, -1, 12, 3, 18,
456 9, 33, -1, 12, 3, 33, -1, 7, 18, 7,
457 -1, 3, 18, 3, -1, 5, -1, 31, 15, 32,
458 -1, 32, -1, 7, 19, 7, -1, 7, 19, 3,
459 -1, 7, -1, 6, 19, 3, -1, 6, -1, 18,
460 -1, -1, 16, -1, 18, -1, -1
461};
462
463/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
464static const yytype_uint8 yyrline[] =
465{
466 0, 54, 54, 54, 57, 62, 64, 65, 66, 67,
467 68, 69, 70, 73, 80, 89, 98, 103, 108, 114,
468 119, 125, 131, 137, 143, 153, 165, 174, 183, 192,
469 200, 208, 208, 210, 210, 210
470};
471#endif
472
473#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
474/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
475 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
476static const char *const yytname[] =
477{
478 "$end", "error", "$undefined", "PE_VALUE", "PE_VALUE_SYM", "PE_RAW",
479 "PE_TERM", "PE_NAME", "PE_MODIFIER_EVENT", "PE_MODIFIER_BP",
480 "PE_NAME_CACHE_TYPE", "PE_NAME_CACHE_OP_RESULT", "PE_PREFIX_MEM",
481 "PE_PREFIX_RAW", "PE_ERROR", "','", "'/'", "'-'", "':'", "'='",
482 "$accept", "events", "event", "event_def", "event_pmu",
483 "event_legacy_symbol", "event_legacy_cache", "event_legacy_mem",
484 "event_legacy_tracepoint", "event_legacy_numeric", "event_legacy_raw",
485 "event_config", "event_term", "sep_dc", "sep_slash_dc", 0
486};
487#endif
488
489# ifdef YYPRINT
490/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
491 token YYLEX-NUM. */
492static const yytype_uint16 yytoknum[] =
493{
494 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
495 265, 266, 267, 268, 269, 44, 47, 45, 58, 61
496};
497# endif
498
499/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
500static const yytype_uint8 yyr1[] =
501{
502 0, 20, 21, 21, 22, 22, 23, 23, 23, 23,
503 23, 23, 23, 24, 25, 25, 26, 26, 26, 27,
504 27, 28, 29, 30, 31, 31, 32, 32, 32, 32,
505 32, 33, 33, 34, 34, 34
506};
507
508/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
509static const yytype_uint8 yyr2[] =
510{
511 0, 2, 3, 1, 2, 1, 1, 1, 2, 1,
512 2, 2, 2, 4, 4, 2, 5, 3, 1, 5,
513 3, 3, 3, 1, 3, 1, 3, 3, 1, 3,
514 1, 1, 0, 1, 1, 0
515};
516
517/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
518 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
519 means the default is an error. */
520static const yytype_uint8 yydefact[] =
521{
522 0, 0, 35, 23, 0, 18, 0, 0, 3, 5,
523 6, 7, 32, 9, 32, 32, 32, 0, 33, 34,
524 15, 0, 0, 0, 32, 1, 0, 4, 31, 8,
525 10, 11, 12, 22, 30, 28, 0, 25, 0, 21,
526 17, 31, 20, 2, 0, 0, 0, 14, 13, 0,
527 32, 29, 27, 26, 24, 16, 19
528};
529
530/* YYDEFGOTO[NTERM-NUM]. */
531static const yytype_int8 yydefgoto[] =
532{
533 -1, 7, 8, 9, 10, 11, 12, 13, 14, 15,
534 16, 36, 37, 29, 20
535};
536
537/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
538 STATE-NUM. */
539#define YYPACT_NINF -15
540static const yytype_int8 yypact[] =
541{
542 1, -4, -9, -15, -1, 10, 22, 3, -15, 18,
543 -15, -15, 11, -15, 11, 11, 11, 25, 13, -15,
544 -15, 13, 23, 20, 14, -15, 1, -15, -15, -15,
545 -15, -15, -15, -15, 15, 16, 6, -15, 8, -15,
546 21, 24, -15, -15, 34, 9, 13, -15, -15, 28,
547 11, -15, -15, -15, -15, -15, -15
548};
549
550/* YYPGOTO[NTERM-NUM]. */
551static const yytype_int8 yypgoto[] =
552{
553 -15, -15, 17, -15, -15, -15, -15, -15, -15, -15,
554 -15, 19, -5, -14, -15
555};
556
557/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
558 positive, shift that token. If negative, reduce the rule which
559 number is the opposite. If zero, do what YYDEFACT says.
560 If YYTABLE_NINF, syntax error. */
561#define YYTABLE_NINF -1
562static const yytype_uint8 yytable[] =
563{
564 30, 31, 32, 25, 1, 2, 3, 18, 4, 19,
565 42, 5, 52, 6, 17, 21, 53, 22, 26, 34,
566 35, 46, 47, 46, 48, 24, 27, 23, 33, 28,
567 39, 40, 41, 50, 44, 45, 56, 51, 49, 55,
568 38, 54, 0, 43
569};
570
571static const yytype_int8 yycheck[] =
572{
573 14, 15, 16, 0, 3, 4, 5, 16, 7, 18,
574 24, 10, 3, 12, 18, 16, 7, 18, 15, 6,
575 7, 15, 16, 15, 16, 3, 8, 17, 3, 18,
576 7, 11, 18, 9, 19, 19, 50, 3, 17, 11,
577 21, 46, -1, 26
578};
579
580/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
581 symbol of state STATE-NUM. */
582static const yytype_uint8 yystos[] =
583{
584 0, 3, 4, 5, 7, 10, 12, 21, 22, 23,
585 24, 25, 26, 27, 28, 29, 30, 18, 16, 18,
586 34, 16, 18, 17, 3, 0, 15, 8, 18, 33,
587 33, 33, 33, 3, 6, 7, 31, 32, 31, 7,
588 11, 18, 33, 22, 19, 19, 15, 16, 16, 17,
589 9, 3, 3, 7, 32, 11, 33
590};
591
592#define yyerrok (yyerrstatus = 0)
593#define yyclearin (yychar = YYEMPTY)
594#define YYEMPTY (-2)
595#define YYEOF 0
596
597#define YYACCEPT goto yyacceptlab
598#define YYABORT goto yyabortlab
599#define YYERROR goto yyerrorlab
600
601
602/* Like YYERROR except do call yyerror. This remains here temporarily
603 to ease the transition to the new meaning of YYERROR, for GCC.
604 Once GCC version 2 has supplanted version 1, this can go. However,
605 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
606 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
607 discussed. */
608
609#define YYFAIL goto yyerrlab
610#if defined YYFAIL
611 /* This is here to suppress warnings from the GCC cpp's
612 -Wunused-macros. Normally we don't worry about that warning, but
613 some users do, and we want to make it easy for users to remove
614 YYFAIL uses, which will produce warnings from Bison 2.5. */
615#endif
616
617#define YYRECOVERING() (!!yyerrstatus)
618
619#define YYBACKUP(Token, Value) \
620do \
621 if (yychar == YYEMPTY && yylen == 1) \
622 { \
623 yychar = (Token); \
624 yylval = (Value); \
625 yytoken = YYTRANSLATE (yychar); \
626 YYPOPSTACK (1); \
627 goto yybackup; \
628 } \
629 else \
630 { \
631 yyerror (list, idx, YY_("syntax error: cannot back up")); \
632 YYERROR; \
633 } \
634while (YYID (0))
635
636
637#define YYTERROR 1
638#define YYERRCODE 256
639
640
641/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
642 If N is 0, then set CURRENT to the empty location which ends
643 the previous symbol: RHS[0] (always defined). */
644
645#define YYRHSLOC(Rhs, K) ((Rhs)[K])
646#ifndef YYLLOC_DEFAULT
647# define YYLLOC_DEFAULT(Current, Rhs, N) \
648 do \
649 if (YYID (N)) \
650 { \
651 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
652 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
653 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
654 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
655 } \
656 else \
657 { \
658 (Current).first_line = (Current).last_line = \
659 YYRHSLOC (Rhs, 0).last_line; \
660 (Current).first_column = (Current).last_column = \
661 YYRHSLOC (Rhs, 0).last_column; \
662 } \
663 while (YYID (0))
664#endif
665
666
667/* YY_LOCATION_PRINT -- Print the location on the stream.
668 This macro was not mandated originally: define only if we know
669 we won't break user code: when these are the locations we know. */
670
671#ifndef YY_LOCATION_PRINT
672# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
673# define YY_LOCATION_PRINT(File, Loc) \
674 fprintf (File, "%d.%d-%d.%d", \
675 (Loc).first_line, (Loc).first_column, \
676 (Loc).last_line, (Loc).last_column)
677# else
678# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
679# endif
680#endif
681
682
683/* YYLEX -- calling `yylex' with the right arguments. */
684
685#ifdef YYLEX_PARAM
686# define YYLEX yylex (YYLEX_PARAM)
687#else
688# define YYLEX yylex ()
689#endif
690
691/* Enable debugging if requested. */
692#if YYDEBUG
693
694# ifndef YYFPRINTF
695# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
696# define YYFPRINTF fprintf
697# endif
698
699# define YYDPRINTF(Args) \
700do { \
701 if (yydebug) \
702 YYFPRINTF Args; \
703} while (YYID (0))
704
705# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
706do { \
707 if (yydebug) \
708 { \
709 YYFPRINTF (stderr, "%s ", Title); \
710 yy_symbol_print (stderr, \
711 Type, Value, list, idx); \
712 YYFPRINTF (stderr, "\n"); \
713 } \
714} while (YYID (0))
715
716
717/*--------------------------------.
718| Print this symbol on YYOUTPUT. |
719`--------------------------------*/
720
721/*ARGSUSED*/
722#if (defined __STDC__ || defined __C99__FUNC__ \
723 || defined __cplusplus || defined _MSC_VER)
724static void
725yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *list, int *idx)
726#else
727static void
728yy_symbol_value_print (yyoutput, yytype, yyvaluep, list, idx)
729 FILE *yyoutput;
730 int yytype;
731 YYSTYPE const * const yyvaluep;
732 struct list_head *list;
733 int *idx;
734#endif
735{
736 if (!yyvaluep)
737 return;
738 YYUSE (list);
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, int *idx)
762#else
763static void
764yy_symbol_print (yyoutput, yytype, yyvaluep, list, idx)
765 FILE *yyoutput;
766 int yytype;
767 YYSTYPE const * const yyvaluep;
768 struct list_head *list;
769 int *idx;
770#endif
771{
772 if (yytype < YYNTOKENS)
773 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
774 else
775 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
776
777 yy_symbol_value_print (yyoutput, yytype, yyvaluep, list, idx);
778 YYFPRINTF (yyoutput, ")");
779}
780
781/*------------------------------------------------------------------.
782| yy_stack_print -- Print the state stack from its BOTTOM up to its |
783| TOP (included). |
784`------------------------------------------------------------------*/
785
786#if (defined __STDC__ || defined __C99__FUNC__ \
787 || defined __cplusplus || defined _MSC_VER)
788static void
789yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
790#else
791static void
792yy_stack_print (yybottom, yytop)
793 yytype_int16 *yybottom;
794 yytype_int16 *yytop;
795#endif
796{
797 YYFPRINTF (stderr, "Stack now");
798 for (; yybottom <= yytop; yybottom++)
799 {
800 int yybot = *yybottom;
801 YYFPRINTF (stderr, " %d", yybot);
802 }
803 YYFPRINTF (stderr, "\n");
804}
805
806# define YY_STACK_PRINT(Bottom, Top) \
807do { \
808 if (yydebug) \
809 yy_stack_print ((Bottom), (Top)); \
810} while (YYID (0))
811
812
813/*------------------------------------------------.
814| Report that the YYRULE is going to be reduced. |
815`------------------------------------------------*/
816
817#if (defined __STDC__ || defined __C99__FUNC__ \
818 || defined __cplusplus || defined _MSC_VER)
819static void
820yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct list_head *list, int *idx)
821#else
822static void
823yy_reduce_print (yyvsp, yyrule, list, idx)
824 YYSTYPE *yyvsp;
825 int yyrule;
826 struct list_head *list;
827 int *idx;
828#endif
829{
830 int yynrhs = yyr2[yyrule];
831 int yyi;
832 unsigned long int yylno = yyrline[yyrule];
833 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
834 yyrule - 1, yylno);
835 /* The symbols being reduced. */
836 for (yyi = 0; yyi < yynrhs; yyi++)
837 {
838 YYFPRINTF (stderr, " $%d = ", yyi + 1);
839 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
840 &(yyvsp[(yyi + 1) - (yynrhs)])
841 , list, idx);
842 YYFPRINTF (stderr, "\n");
843 }
844}
845
846# define YY_REDUCE_PRINT(Rule) \
847do { \
848 if (yydebug) \
849 yy_reduce_print (yyvsp, Rule, list, idx); \
850} while (YYID (0))
851
852/* Nonzero means print parse trace. It is left uninitialized so that
853 multiple parsers can coexist. */
854int yydebug;
855#else /* !YYDEBUG */
856# define YYDPRINTF(Args)
857# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
858# define YY_STACK_PRINT(Bottom, Top)
859# define YY_REDUCE_PRINT(Rule)
860#endif /* !YYDEBUG */
861
862
863/* YYINITDEPTH -- initial size of the parser's stacks. */
864#ifndef YYINITDEPTH
865# define YYINITDEPTH 200
866#endif
867
868/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
869 if the built-in stack extension method is used).
870
871 Do not make this value too large; the results are undefined if
872 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
873 evaluated with infinite-precision integer arithmetic. */
874
875#ifndef YYMAXDEPTH
876# define YYMAXDEPTH 10000
877#endif
878
879
880
881#if YYERROR_VERBOSE
882
883# ifndef yystrlen
884# if defined __GLIBC__ && defined _STRING_H
885# define yystrlen strlen
886# else
887/* Return the length of YYSTR. */
888#if (defined __STDC__ || defined __C99__FUNC__ \
889 || defined __cplusplus || defined _MSC_VER)
890static YYSIZE_T
891yystrlen (const char *yystr)
892#else
893static YYSIZE_T
894yystrlen (yystr)
895 const char *yystr;
896#endif
897{
898 YYSIZE_T yylen;
899 for (yylen = 0; yystr[yylen]; yylen++)
900 continue;
901 return yylen;
902}
903# endif
904# endif
905
906# ifndef yystpcpy
907# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
908# define yystpcpy stpcpy
909# else
910/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
911 YYDEST. */
912#if (defined __STDC__ || defined __C99__FUNC__ \
913 || defined __cplusplus || defined _MSC_VER)
914static char *
915yystpcpy (char *yydest, const char *yysrc)
916#else
917static char *
918yystpcpy (yydest, yysrc)
919 char *yydest;
920 const char *yysrc;
921#endif
922{
923 char *yyd = yydest;
924 const char *yys = yysrc;
925
926 while ((*yyd++ = *yys++) != '\0')
927 continue;
928
929 return yyd - 1;
930}
931# endif
932# endif
933
934# ifndef yytnamerr
935/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
936 quotes and backslashes, so that it's suitable for yyerror. The
937 heuristic is that double-quoting is unnecessary unless the string
938 contains an apostrophe, a comma, or backslash (other than
939 backslash-backslash). YYSTR is taken from yytname. If YYRES is
940 null, do not copy; instead, return the length of what the result
941 would have been. */
942static YYSIZE_T
943yytnamerr (char *yyres, const char *yystr)
944{
945 if (*yystr == '"')
946 {
947 YYSIZE_T yyn = 0;
948 char const *yyp = yystr;
949
950 for (;;)
951 switch (*++yyp)
952 {
953 case '\'':
954 case ',':
955 goto do_not_strip_quotes;
956
957 case '\\':
958 if (*++yyp != '\\')
959 goto do_not_strip_quotes;
960 /* Fall through. */
961 default:
962 if (yyres)
963 yyres[yyn] = *yyp;
964 yyn++;
965 break;
966
967 case '"':
968 if (yyres)
969 yyres[yyn] = '\0';
970 return yyn;
971 }
972 do_not_strip_quotes: ;
973 }
974
975 if (! yyres)
976 return yystrlen (yystr);
977
978 return yystpcpy (yyres, yystr) - yyres;
979}
980# endif
981
982/* Copy into YYRESULT an error message about the unexpected token
983 YYCHAR while in state YYSTATE. Return the number of bytes copied,
984 including the terminating null byte. If YYRESULT is null, do not
985 copy anything; just return the number of bytes that would be
986 copied. As a special case, return 0 if an ordinary "syntax error"
987 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
988 size calculation. */
989static YYSIZE_T
990yysyntax_error (char *yyresult, int yystate, int yychar)
991{
992 int yyn = yypact[yystate];
993
994 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
995 return 0;
996 else
997 {
998 int yytype = YYTRANSLATE (yychar);
999 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1000 YYSIZE_T yysize = yysize0;
1001 YYSIZE_T yysize1;
1002 int yysize_overflow = 0;
1003 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1004 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1005 int yyx;
1006
1007# if 0
1008 /* This is so xgettext sees the translatable formats that are
1009 constructed on the fly. */
1010 YY_("syntax error, unexpected %s");
1011 YY_("syntax error, unexpected %s, expecting %s");
1012 YY_("syntax error, unexpected %s, expecting %s or %s");
1013 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1014 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1015# endif
1016 char *yyfmt;
1017 char const *yyf;
1018 static char const yyunexpected[] = "syntax error, unexpected %s";
1019 static char const yyexpecting[] = ", expecting %s";
1020 static char const yyor[] = " or %s";
1021 char yyformat[sizeof yyunexpected
1022 + sizeof yyexpecting - 1
1023 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1024 * (sizeof yyor - 1))];
1025 char const *yyprefix = yyexpecting;
1026
1027 /* Start YYX at -YYN if negative to avoid negative indexes in
1028 YYCHECK. */
1029 int yyxbegin = yyn < 0 ? -yyn : 0;
1030
1031 /* Stay within bounds of both yycheck and yytname. */
1032 int yychecklim = YYLAST - yyn + 1;
1033 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1034 int yycount = 1;
1035
1036 yyarg[0] = yytname[yytype];
1037 yyfmt = yystpcpy (yyformat, yyunexpected);
1038
1039 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1040 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1041 {
1042 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1043 {
1044 yycount = 1;
1045 yysize = yysize0;
1046 yyformat[sizeof yyunexpected - 1] = '\0';
1047 break;
1048 }
1049 yyarg[yycount++] = yytname[yyx];
1050 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1051 yysize_overflow |= (yysize1 < yysize);
1052 yysize = yysize1;
1053 yyfmt = yystpcpy (yyfmt, yyprefix);
1054 yyprefix = yyor;
1055 }
1056
1057 yyf = YY_(yyformat);
1058 yysize1 = yysize + yystrlen (yyf);
1059 yysize_overflow |= (yysize1 < yysize);
1060 yysize = yysize1;
1061
1062 if (yysize_overflow)
1063 return YYSIZE_MAXIMUM;
1064
1065 if (yyresult)
1066 {
1067 /* Avoid sprintf, as that infringes on the user's name space.
1068 Don't have undefined behavior even if the translation
1069 produced a string with the wrong number of "%s"s. */
1070 char *yyp = yyresult;
1071 int yyi = 0;
1072 while ((*yyp = *yyf) != '\0')
1073 {
1074 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1075 {
1076 yyp += yytnamerr (yyp, yyarg[yyi++]);
1077 yyf += 2;
1078 }
1079 else
1080 {
1081 yyp++;
1082 yyf++;
1083 }
1084 }
1085 }
1086 return yysize;
1087 }
1088}
1089#endif /* YYERROR_VERBOSE */
1090
1091
1092/*-----------------------------------------------.
1093| Release the memory associated to this symbol. |
1094`-----------------------------------------------*/
1095
1096/*ARGSUSED*/
1097#if (defined __STDC__ || defined __C99__FUNC__ \
1098 || defined __cplusplus || defined _MSC_VER)
1099static void
1100yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct list_head *list, int *idx)
1101#else
1102static void
1103yydestruct (yymsg, yytype, yyvaluep, list, idx)
1104 const char *yymsg;
1105 int yytype;
1106 YYSTYPE *yyvaluep;
1107 struct list_head *list;
1108 int *idx;
1109#endif
1110{
1111 YYUSE (yyvaluep);
1112 YYUSE (list);
1113 YYUSE (idx);
1114
1115 if (!yymsg)
1116 yymsg = "Deleting";
1117 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1118
1119 switch (yytype)
1120 {
1121
1122 default:
1123 break;
1124 }
1125}
1126
1127/* Prevent warnings from -Wmissing-prototypes. */
1128#ifdef YYPARSE_PARAM
1129#if defined __STDC__ || defined __cplusplus
1130int yyparse (void *YYPARSE_PARAM);
1131#else
1132int yyparse ();
1133#endif
1134#else /* ! YYPARSE_PARAM */
1135#if defined __STDC__ || defined __cplusplus
1136int yyparse (struct list_head *list, int *idx);
1137#else
1138int yyparse ();
1139#endif
1140#endif /* ! YYPARSE_PARAM */
1141
1142
1143/* The lookahead symbol. */
1144int yychar;
1145
1146/* The semantic value of the lookahead symbol. */
1147YYSTYPE yylval;
1148
1149/* Number of syntax errors so far. */
1150int yynerrs;
1151
1152
1153
1154/*-------------------------.
1155| yyparse or yypush_parse. |
1156`-------------------------*/
1157
1158#ifdef YYPARSE_PARAM
1159#if (defined __STDC__ || defined __C99__FUNC__ \
1160 || defined __cplusplus || defined _MSC_VER)
1161int
1162yyparse (void *YYPARSE_PARAM)
1163#else
1164int
1165yyparse (YYPARSE_PARAM)
1166 void *YYPARSE_PARAM;
1167#endif
1168#else /* ! YYPARSE_PARAM */
1169#if (defined __STDC__ || defined __C99__FUNC__ \
1170 || defined __cplusplus || defined _MSC_VER)
1171int
1172yyparse (struct list_head *list, int *idx)
1173#else
1174int
1175yyparse (list, idx)
1176 struct list_head *list;
1177 int *idx;
1178#endif
1179#endif
1180{
1181
1182
1183 int yystate;
1184 /* Number of tokens to shift before error messages enabled. */
1185 int yyerrstatus;
1186
1187 /* The stacks and their tools:
1188 `yyss': related to states.
1189 `yyvs': related to semantic values.
1190
1191 Refer to the stacks thru separate pointers, to allow yyoverflow
1192 to reallocate them elsewhere. */
1193
1194 /* The state stack. */
1195 yytype_int16 yyssa[YYINITDEPTH];
1196 yytype_int16 *yyss;
1197 yytype_int16 *yyssp;
1198
1199 /* The semantic value stack. */
1200 YYSTYPE yyvsa[YYINITDEPTH];
1201 YYSTYPE *yyvs;
1202 YYSTYPE *yyvsp;
1203
1204 YYSIZE_T yystacksize;
1205
1206 int yyn;
1207 int yyresult;
1208 /* Lookahead token as an internal (translated) token number. */
1209 int yytoken;
1210 /* The variables used to return semantic value and location from the
1211 action routines. */
1212 YYSTYPE yyval;
1213
1214#if YYERROR_VERBOSE
1215 /* Buffer for error messages, and its allocated size. */
1216 char yymsgbuf[128];
1217 char *yymsg = yymsgbuf;
1218 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1219#endif
1220
1221#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1222
1223 /* The number of symbols on the RHS of the reduced rule.
1224 Keep to zero when no symbol should be popped. */
1225 int yylen = 0;
1226
1227 yytoken = 0;
1228 yyss = yyssa;
1229 yyvs = yyvsa;
1230 yystacksize = YYINITDEPTH;
1231
1232 YYDPRINTF ((stderr, "Starting parse\n"));
1233
1234 yystate = 0;
1235 yyerrstatus = 0;
1236 yynerrs = 0;
1237 yychar = YYEMPTY; /* Cause a token to be read. */
1238
1239 /* Initialize stack pointers.
1240 Waste one element of value and location stack
1241 so that they stay on the same level as the state stack.
1242 The wasted elements are never initialized. */
1243 yyssp = yyss;
1244 yyvsp = yyvs;
1245
1246 goto yysetstate;
1247
1248/*------------------------------------------------------------.
1249| yynewstate -- Push a new state, which is found in yystate. |
1250`------------------------------------------------------------*/
1251 yynewstate:
1252 /* In all cases, when you get here, the value and location stacks
1253 have just been pushed. So pushing a state here evens the stacks. */
1254 yyssp++;
1255
1256 yysetstate:
1257 *yyssp = yystate;
1258
1259 if (yyss + yystacksize - 1 <= yyssp)
1260 {
1261 /* Get the current used size of the three stacks, in elements. */
1262 YYSIZE_T yysize = yyssp - yyss + 1;
1263
1264#ifdef yyoverflow
1265 {
1266 /* Give user a chance to reallocate the stack. Use copies of
1267 these so that the &'s don't force the real ones into
1268 memory. */
1269 YYSTYPE *yyvs1 = yyvs;
1270 yytype_int16 *yyss1 = yyss;
1271
1272 /* Each stack pointer address is followed by the size of the
1273 data in use in that stack, in bytes. This used to be a
1274 conditional around just the two extra args, but that might
1275 be undefined if yyoverflow is a macro. */
1276 yyoverflow (YY_("memory exhausted"),
1277 &yyss1, yysize * sizeof (*yyssp),
1278 &yyvs1, yysize * sizeof (*yyvsp),
1279 &yystacksize);
1280
1281 yyss = yyss1;
1282 yyvs = yyvs1;
1283 }
1284#else /* no yyoverflow */
1285# ifndef YYSTACK_RELOCATE
1286 goto yyexhaustedlab;
1287# else
1288 /* Extend the stack our own way. */
1289 if (YYMAXDEPTH <= yystacksize)
1290 goto yyexhaustedlab;
1291 yystacksize *= 2;
1292 if (YYMAXDEPTH < yystacksize)
1293 yystacksize = YYMAXDEPTH;
1294
1295 {
1296 yytype_int16 *yyss1 = yyss;
1297 union yyalloc *yyptr =
1298 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1299 if (! yyptr)
1300 goto yyexhaustedlab;
1301 YYSTACK_RELOCATE (yyss_alloc, yyss);
1302 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1303# undef YYSTACK_RELOCATE
1304 if (yyss1 != yyssa)
1305 YYSTACK_FREE (yyss1);
1306 }
1307# endif
1308#endif /* no yyoverflow */
1309
1310 yyssp = yyss + yysize - 1;
1311 yyvsp = yyvs + yysize - 1;
1312
1313 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1314 (unsigned long int) yystacksize));
1315
1316 if (yyss + yystacksize - 1 <= yyssp)
1317 YYABORT;
1318 }
1319
1320 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1321
1322 if (yystate == YYFINAL)
1323 YYACCEPT;
1324
1325 goto yybackup;
1326
1327/*-----------.
1328| yybackup. |
1329`-----------*/
1330yybackup:
1331
1332 /* Do appropriate processing given the current state. Read a
1333 lookahead token if we need one and don't already have one. */
1334
1335 /* First try to decide what to do without reference to lookahead token. */
1336 yyn = yypact[yystate];
1337 if (yyn == YYPACT_NINF)
1338 goto yydefault;
1339
1340 /* Not known => get a lookahead token if don't already have one. */
1341
1342 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1343 if (yychar == YYEMPTY)
1344 {
1345 YYDPRINTF ((stderr, "Reading a token: "));
1346 yychar = YYLEX;
1347 }
1348
1349 if (yychar <= YYEOF)
1350 {
1351 yychar = yytoken = YYEOF;
1352 YYDPRINTF ((stderr, "Now at end of input.\n"));
1353 }
1354 else
1355 {
1356 yytoken = YYTRANSLATE (yychar);
1357 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1358 }
1359
1360 /* If the proper action on seeing token YYTOKEN is to reduce or to
1361 detect an error, take that action. */
1362 yyn += yytoken;
1363 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1364 goto yydefault;
1365 yyn = yytable[yyn];
1366 if (yyn <= 0)
1367 {
1368 if (yyn == 0 || yyn == YYTABLE_NINF)
1369 goto yyerrlab;
1370 yyn = -yyn;
1371 goto yyreduce;
1372 }
1373
1374 /* Count tokens shifted since error; after three, turn off error
1375 status. */
1376 if (yyerrstatus)
1377 yyerrstatus--;
1378
1379 /* Shift the lookahead token. */
1380 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1381
1382 /* Discard the shifted token. */
1383 yychar = YYEMPTY;
1384
1385 yystate = yyn;
1386 *++yyvsp = yylval;
1387
1388 goto yynewstate;
1389
1390
1391/*-----------------------------------------------------------.
1392| yydefault -- do the default action for the current state. |
1393`-----------------------------------------------------------*/
1394yydefault:
1395 yyn = yydefact[yystate];
1396 if (yyn == 0)
1397 goto yyerrlab;
1398 goto yyreduce;
1399
1400
1401/*-----------------------------.
1402| yyreduce -- Do a reduction. |
1403`-----------------------------*/
1404yyreduce:
1405 /* yyn is the number of a rule to reduce with. */
1406 yylen = yyr2[yyn];
1407
1408 /* If YYLEN is nonzero, implement the default value of the action:
1409 `$$ = $1'.
1410
1411 Otherwise, the following line sets YYVAL to garbage.
1412 This behavior is undocumented and Bison
1413 users should not rely upon it. Assigning to YYVAL
1414 unconditionally makes the parser a bit smaller, and it avoids a
1415 GCC warning that YYVAL may be used uninitialized. */
1416 yyval = yyvsp[1-yylen];
1417
1418
1419 YY_REDUCE_PRINT (yyn);
1420 switch (yyn)
1421 {
1422 case 4:
1423
1424/* Line 1464 of yacc.c */
1425#line 58 "util/parse-events.y"
1426 {
1427 ABORT_ON(parse_events_modifier(list, (yyvsp[(2) - (2)].str)));
1428;}
1429 break;
1430
1431 case 13:
1432
1433/* Line 1464 of yacc.c */
1434#line 74 "util/parse-events.y"
1435 {
1436 ABORT_ON(parse_events_add_pmu(list, idx, (yyvsp[(1) - (4)].str), (yyvsp[(3) - (4)].head)));
1437 parse_events__free_terms((yyvsp[(3) - (4)].head));
1438;}
1439 break;
1440
1441 case 14:
1442
1443/* Line 1464 of yacc.c */
1444#line 81 "util/parse-events.y"
1445 {
1446 int type = (yyvsp[(1) - (4)].num) >> 16;
1447 int config = (yyvsp[(1) - (4)].num) & 255;
1448
1449 ABORT_ON(parse_events_add_numeric(list, idx, type, config, (yyvsp[(3) - (4)].head)));
1450 parse_events__free_terms((yyvsp[(3) - (4)].head));
1451;}
1452 break;
1453
1454 case 15:
1455
1456/* Line 1464 of yacc.c */
1457#line 90 "util/parse-events.y"
1458 {
1459 int type = (yyvsp[(1) - (2)].num) >> 16;
1460 int config = (yyvsp[(1) - (2)].num) & 255;
1461
1462 ABORT_ON(parse_events_add_numeric(list, idx, type, config, NULL));
1463;}
1464 break;
1465
1466 case 16:
1467
1468/* Line 1464 of yacc.c */
1469#line 99 "util/parse-events.y"
1470 {
1471 ABORT_ON(parse_events_add_cache(list, idx, (yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (yyvsp[(5) - (5)].str)));
1472;}
1473 break;
1474
1475 case 17:
1476
1477/* Line 1464 of yacc.c */
1478#line 104 "util/parse-events.y"
1479 {
1480 ABORT_ON(parse_events_add_cache(list, idx, (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str), NULL));
1481;}
1482 break;
1483
1484 case 18:
1485
1486/* Line 1464 of yacc.c */
1487#line 109 "util/parse-events.y"
1488 {
1489 ABORT_ON(parse_events_add_cache(list, idx, (yyvsp[(1) - (1)].str), NULL, NULL));
1490;}
1491 break;
1492
1493 case 19:
1494
1495/* Line 1464 of yacc.c */
1496#line 115 "util/parse-events.y"
1497 {
1498 ABORT_ON(parse_events_add_breakpoint(list, idx, (void *) (yyvsp[(2) - (5)].num), (yyvsp[(4) - (5)].str)));
1499;}
1500 break;
1501
1502 case 20:
1503
1504/* Line 1464 of yacc.c */
1505#line 120 "util/parse-events.y"
1506 {
1507 ABORT_ON(parse_events_add_breakpoint(list, idx, (void *) (yyvsp[(2) - (3)].num), NULL));
1508;}
1509 break;
1510
1511 case 21:
1512
1513/* Line 1464 of yacc.c */
1514#line 126 "util/parse-events.y"
1515 {
1516 ABORT_ON(parse_events_add_tracepoint(list, idx, (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)));
1517;}
1518 break;
1519
1520 case 22:
1521
1522/* Line 1464 of yacc.c */
1523#line 132 "util/parse-events.y"
1524 {
1525 ABORT_ON(parse_events_add_numeric(list, idx, (yyvsp[(1) - (3)].num), (yyvsp[(3) - (3)].num), NULL));
1526;}
1527 break;
1528
1529 case 23:
1530
1531/* Line 1464 of yacc.c */
1532#line 138 "util/parse-events.y"
1533 {
1534 ABORT_ON(parse_events_add_numeric(list, idx, PERF_TYPE_RAW, (yyvsp[(1) - (1)].num), NULL));
1535;}
1536 break;
1537
1538 case 24:
1539
1540/* Line 1464 of yacc.c */
1541#line 144 "util/parse-events.y"
1542 {
1543 struct list_head *head = (yyvsp[(1) - (3)].head);
1544 struct parse_events__term *term = (yyvsp[(3) - (3)].term);
1545
1546 ABORT_ON(!head);
1547 list_add_tail(&term->list, head);
1548 (yyval.head) = (yyvsp[(1) - (3)].head);
1549;}
1550 break;
1551
1552 case 25:
1553
1554/* Line 1464 of yacc.c */
1555#line 154 "util/parse-events.y"
1556 {
1557 struct list_head *head = malloc(sizeof(*head));
1558 struct parse_events__term *term = (yyvsp[(1) - (1)].term);
1559
1560 ABORT_ON(!head);
1561 INIT_LIST_HEAD(head);
1562 list_add_tail(&term->list, head);
1563 (yyval.head) = head;
1564;}
1565 break;
1566
1567 case 26:
1568
1569/* Line 1464 of yacc.c */
1570#line 166 "util/parse-events.y"
1571 {
1572 struct parse_events__term *term;
1573
1574 ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_STR,
1575 (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str), 0));
1576 (yyval.term) = term;
1577;}
1578 break;
1579
1580 case 27:
1581
1582/* Line 1464 of yacc.c */
1583#line 175 "util/parse-events.y"
1584 {
1585 struct parse_events__term *term;
1586
1587 ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
1588 (yyvsp[(1) - (3)].str), NULL, (yyvsp[(3) - (3)].num)));
1589 (yyval.term) = term;
1590;}
1591 break;
1592
1593 case 28:
1594
1595/* Line 1464 of yacc.c */
1596#line 184 "util/parse-events.y"
1597 {
1598 struct parse_events__term *term;
1599
1600 ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
1601 (yyvsp[(1) - (1)].str), NULL, 1));
1602 (yyval.term) = term;
1603;}
1604 break;
1605
1606 case 29:
1607
1608/* Line 1464 of yacc.c */
1609#line 193 "util/parse-events.y"
1610 {
1611 struct parse_events__term *term;
1612
1613 ABORT_ON(parse_events__new_term(&term, (yyvsp[(1) - (3)].num), NULL, NULL, (yyvsp[(3) - (3)].num)));
1614 (yyval.term) = term;
1615;}
1616 break;
1617
1618 case 30:
1619
1620/* Line 1464 of yacc.c */
1621#line 201 "util/parse-events.y"
1622 {
1623 struct parse_events__term *term;
1624
1625 ABORT_ON(parse_events__new_term(&term, (yyvsp[(1) - (1)].num), NULL, NULL, 1));
1626 (yyval.term) = term;
1627;}
1628 break;
1629
1630
1631
1632/* Line 1464 of yacc.c */
1633#line 1634 "util/parse-events-bison.c"
1634 default: break;
1635 }
1636 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1637
1638 YYPOPSTACK (yylen);
1639 yylen = 0;
1640 YY_STACK_PRINT (yyss, yyssp);
1641
1642 *++yyvsp = yyval;
1643
1644 /* Now `shift' the result of the reduction. Determine what state
1645 that goes to, based on the state we popped back to and the rule
1646 number reduced by. */
1647
1648 yyn = yyr1[yyn];
1649
1650 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1651 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1652 yystate = yytable[yystate];
1653 else
1654 yystate = yydefgoto[yyn - YYNTOKENS];
1655
1656 goto yynewstate;
1657
1658
1659/*------------------------------------.
1660| yyerrlab -- here on detecting error |
1661`------------------------------------*/
1662yyerrlab:
1663 /* If not already recovering from an error, report this error. */
1664 if (!yyerrstatus)
1665 {
1666 ++yynerrs;
1667#if ! YYERROR_VERBOSE
1668 yyerror (list, idx, YY_("syntax error"));
1669#else
1670 {
1671 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1672 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1673 {
1674 YYSIZE_T yyalloc = 2 * yysize;
1675 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1676 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1677 if (yymsg != yymsgbuf)
1678 YYSTACK_FREE (yymsg);
1679 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1680 if (yymsg)
1681 yymsg_alloc = yyalloc;
1682 else
1683 {
1684 yymsg = yymsgbuf;
1685 yymsg_alloc = sizeof yymsgbuf;
1686 }
1687 }
1688
1689 if (0 < yysize && yysize <= yymsg_alloc)
1690 {
1691 (void) yysyntax_error (yymsg, yystate, yychar);
1692 yyerror (list, idx, yymsg);
1693 }
1694 else
1695 {
1696 yyerror (list, idx, YY_("syntax error"));
1697 if (yysize != 0)
1698 goto yyexhaustedlab;
1699 }
1700 }
1701#endif
1702 }
1703
1704
1705
1706 if (yyerrstatus == 3)
1707 {
1708 /* If just tried and failed to reuse lookahead token after an
1709 error, discard it. */
1710
1711 if (yychar <= YYEOF)
1712 {
1713 /* Return failure if at end of input. */
1714 if (yychar == YYEOF)
1715 YYABORT;
1716 }
1717 else
1718 {
1719 yydestruct ("Error: discarding",
1720 yytoken, &yylval, list, idx);
1721 yychar = YYEMPTY;
1722 }
1723 }
1724
1725 /* Else will try to reuse lookahead token after shifting the error
1726 token. */
1727 goto yyerrlab1;
1728
1729
1730/*---------------------------------------------------.
1731| yyerrorlab -- error raised explicitly by YYERROR. |
1732`---------------------------------------------------*/
1733yyerrorlab:
1734
1735 /* Pacify compilers like GCC when the user code never invokes
1736 YYERROR and the label yyerrorlab therefore never appears in user
1737 code. */
1738 if (/*CONSTCOND*/ 0)
1739 goto yyerrorlab;
1740
1741 /* Do not reclaim the symbols of the rule which action triggered
1742 this YYERROR. */
1743 YYPOPSTACK (yylen);
1744 yylen = 0;
1745 YY_STACK_PRINT (yyss, yyssp);
1746 yystate = *yyssp;
1747 goto yyerrlab1;
1748
1749
1750/*-------------------------------------------------------------.
1751| yyerrlab1 -- common code for both syntax error and YYERROR. |
1752`-------------------------------------------------------------*/
1753yyerrlab1:
1754 yyerrstatus = 3; /* Each real token shifted decrements this. */
1755
1756 for (;;)
1757 {
1758 yyn = yypact[yystate];
1759 if (yyn != YYPACT_NINF)
1760 {
1761 yyn += YYTERROR;
1762 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1763 {
1764 yyn = yytable[yyn];
1765 if (0 < yyn)
1766 break;
1767 }
1768 }
1769
1770 /* Pop the current state because it cannot handle the error token. */
1771 if (yyssp == yyss)
1772 YYABORT;
1773
1774
1775 yydestruct ("Error: popping",
1776 yystos[yystate], yyvsp, list, idx);
1777 YYPOPSTACK (1);
1778 yystate = *yyssp;
1779 YY_STACK_PRINT (yyss, yyssp);
1780 }
1781
1782 *++yyvsp = yylval;
1783
1784
1785 /* Shift the error token. */
1786 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1787
1788 yystate = yyn;
1789 goto yynewstate;
1790
1791
1792/*-------------------------------------.
1793| yyacceptlab -- YYACCEPT comes here. |
1794`-------------------------------------*/
1795yyacceptlab:
1796 yyresult = 0;
1797 goto yyreturn;
1798
1799/*-----------------------------------.
1800| yyabortlab -- YYABORT comes here. |
1801`-----------------------------------*/
1802yyabortlab:
1803 yyresult = 1;
1804 goto yyreturn;
1805
1806#if !defined(yyoverflow) || YYERROR_VERBOSE
1807/*-------------------------------------------------.
1808| yyexhaustedlab -- memory exhaustion comes here. |
1809`-------------------------------------------------*/
1810yyexhaustedlab:
1811 yyerror (list, idx, YY_("memory exhausted"));
1812 yyresult = 2;
1813 /* Fall through. */
1814#endif
1815
1816yyreturn:
1817 if (yychar != YYEMPTY)
1818 yydestruct ("Cleanup: discarding lookahead",
1819 yytoken, &yylval, list, idx);
1820 /* Do not reclaim the symbols of the rule which action triggered
1821 this YYABORT or YYACCEPT. */
1822 YYPOPSTACK (yylen);
1823 YY_STACK_PRINT (yyss, yyssp);
1824 while (yyssp != yyss)
1825 {
1826 yydestruct ("Cleanup: popping",
1827 yystos[*yyssp], yyvsp, list, idx);
1828 YYPOPSTACK (1);
1829 }
1830#ifndef yyoverflow
1831 if (yyss != yyssa)
1832 YYSTACK_FREE (yyss);
1833#endif
1834#if YYERROR_VERBOSE
1835 if (yymsg != yymsgbuf)
1836 YYSTACK_FREE (yymsg);
1837#endif
1838 /* Make sure YYID is used. */
1839 return YYID (yyresult);
1840}
1841
1842
1843
1844/* Line 1684 of yacc.c */
1845#line 212 "util/parse-events.y"
1846
1847
1848void parse_events_error(struct list_head *list __used, int *idx __used,
1849 char const *msg __used)
1850{
1851}
1852
diff --git a/tools/perf/util/parse-events-bison.h b/tools/perf/util/parse-events-bison.h
new file mode 100644
index 000000000000..c58b76584f92
--- /dev/null
+++ b/tools/perf/util/parse-events-bison.h
@@ -0,0 +1,82 @@
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 PE_VALUE = 258,
42 PE_VALUE_SYM = 259,
43 PE_RAW = 260,
44 PE_TERM = 261,
45 PE_NAME = 262,
46 PE_MODIFIER_EVENT = 263,
47 PE_MODIFIER_BP = 264,
48 PE_NAME_CACHE_TYPE = 265,
49 PE_NAME_CACHE_OP_RESULT = 266,
50 PE_PREFIX_MEM = 267,
51 PE_PREFIX_RAW = 268,
52 PE_ERROR = 269
53 };
54#endif
55
56
57
58#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
59typedef union YYSTYPE
60{
61
62/* Line 1685 of yacc.c */
63#line 45 "util/parse-events.y"
64
65 char *str;
66 unsigned long num;
67 struct list_head *head;
68 struct parse_events__term *term;
69
70
71
72/* Line 1685 of yacc.c */
73#line 74 "util/parse-events-bison.h"
74} YYSTYPE;
75# define YYSTYPE_IS_TRIVIAL 1
76# define yystype YYSTYPE /* obsolescent; will be withdrawn */
77# define YYSTYPE_IS_DECLARED 1
78#endif
79
80extern YYSTYPE parse_events_lval;
81
82
diff --git a/tools/perf/util/parse-events-flex.c b/tools/perf/util/parse-events-flex.c
new file mode 100644
index 000000000000..34cfc85c4f79
--- /dev/null
+++ b/tools/perf/util/parse-events-flex.c
@@ -0,0 +1,2272 @@
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
new file mode 100644
index 000000000000..ceb9b20d732c
--- /dev/null
+++ b/tools/perf/util/parse-events-flex.h
@@ -0,0 +1,316 @@
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.c b/tools/perf/util/parse-events.c
index b029296d20d9..bec1cc6a1f38 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -11,6 +11,10 @@
11#include "cache.h" 11#include "cache.h"
12#include "header.h" 12#include "header.h"
13#include "debugfs.h" 13#include "debugfs.h"
14#include "parse-events-flex.h"
15#include "pmu.h"
16
17#define MAX_NAME_LEN 100
14 18
15struct event_symbol { 19struct event_symbol {
16 u8 type; 20 u8 type;
@@ -19,11 +23,7 @@ struct event_symbol {
19 const char *alias; 23 const char *alias;
20}; 24};
21 25
22enum event_result { 26int parse_events_parse(struct list_head *list, int *idx);
23 EVT_FAILED,
24 EVT_HANDLED,
25 EVT_HANDLED_ALL
26};
27 27
28#define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x 28#define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
29#define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x 29#define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x
@@ -354,7 +354,24 @@ const char *__event_name(int type, u64 config)
354 return "unknown"; 354 return "unknown";
355} 355}
356 356
357static int parse_aliases(const char **str, const char *names[][MAX_ALIASES], int size) 357static int add_event(struct list_head *list, int *idx,
358 struct perf_event_attr *attr, char *name)
359{
360 struct perf_evsel *evsel;
361
362 event_attr_init(attr);
363
364 evsel = perf_evsel__new(attr, (*idx)++);
365 if (!evsel)
366 return -ENOMEM;
367
368 list_add_tail(&evsel->node, list);
369
370 evsel->name = strdup(name);
371 return 0;
372}
373
374static int parse_aliases(char *str, const char *names[][MAX_ALIASES], int size)
358{ 375{
359 int i, j; 376 int i, j;
360 int n, longest = -1; 377 int n, longest = -1;
@@ -362,58 +379,57 @@ static int parse_aliases(const char **str, const char *names[][MAX_ALIASES], int
362 for (i = 0; i < size; i++) { 379 for (i = 0; i < size; i++) {
363 for (j = 0; j < MAX_ALIASES && names[i][j]; j++) { 380 for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
364 n = strlen(names[i][j]); 381 n = strlen(names[i][j]);
365 if (n > longest && !strncasecmp(*str, names[i][j], n)) 382 if (n > longest && !strncasecmp(str, names[i][j], n))
366 longest = n; 383 longest = n;
367 } 384 }
368 if (longest > 0) { 385 if (longest > 0)
369 *str += longest;
370 return i; 386 return i;
371 }
372 } 387 }
373 388
374 return -1; 389 return -1;
375} 390}
376 391
377static enum event_result 392int parse_events_add_cache(struct list_head *list, int *idx,
378parse_generic_hw_event(const char **str, struct perf_event_attr *attr) 393 char *type, char *op_result1, char *op_result2)
379{ 394{
380 const char *s = *str; 395 struct perf_event_attr attr;
396 char name[MAX_NAME_LEN];
381 int cache_type = -1, cache_op = -1, cache_result = -1; 397 int cache_type = -1, cache_op = -1, cache_result = -1;
398 char *op_result[2] = { op_result1, op_result2 };
399 int i, n;
382 400
383 cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX);
384 /* 401 /*
385 * No fallback - if we cannot get a clear cache type 402 * No fallback - if we cannot get a clear cache type
386 * then bail out: 403 * then bail out:
387 */ 404 */
405 cache_type = parse_aliases(type, hw_cache,
406 PERF_COUNT_HW_CACHE_MAX);
388 if (cache_type == -1) 407 if (cache_type == -1)
389 return EVT_FAILED; 408 return -EINVAL;
390 409
391 while ((cache_op == -1 || cache_result == -1) && *s == '-') { 410 n = snprintf(name, MAX_NAME_LEN, "%s", type);
392 ++s; 411
412 for (i = 0; (i < 2) && (op_result[i]); i++) {
413 char *str = op_result[i];
414
415 snprintf(name + n, MAX_NAME_LEN - n, "-%s\n", str);
393 416
394 if (cache_op == -1) { 417 if (cache_op == -1) {
395 cache_op = parse_aliases(&s, hw_cache_op, 418 cache_op = parse_aliases(str, hw_cache_op,
396 PERF_COUNT_HW_CACHE_OP_MAX); 419 PERF_COUNT_HW_CACHE_OP_MAX);
397 if (cache_op >= 0) { 420 if (cache_op >= 0) {
398 if (!is_cache_op_valid(cache_type, cache_op)) 421 if (!is_cache_op_valid(cache_type, cache_op))
399 return EVT_FAILED; 422 return -EINVAL;
400 continue; 423 continue;
401 } 424 }
402 } 425 }
403 426
404 if (cache_result == -1) { 427 if (cache_result == -1) {
405 cache_result = parse_aliases(&s, hw_cache_result, 428 cache_result = parse_aliases(str, hw_cache_result,
406 PERF_COUNT_HW_CACHE_RESULT_MAX); 429 PERF_COUNT_HW_CACHE_RESULT_MAX);
407 if (cache_result >= 0) 430 if (cache_result >= 0)
408 continue; 431 continue;
409 } 432 }
410
411 /*
412 * Can't parse this as a cache op or result, so back up
413 * to the '-'.
414 */
415 --s;
416 break;
417 } 433 }
418 434
419 /* 435 /*
@@ -428,20 +444,17 @@ parse_generic_hw_event(const char **str, struct perf_event_attr *attr)
428 if (cache_result == -1) 444 if (cache_result == -1)
429 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS; 445 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
430 446
431 attr->config = cache_type | (cache_op << 8) | (cache_result << 16); 447 memset(&attr, 0, sizeof(attr));
432 attr->type = PERF_TYPE_HW_CACHE; 448 attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
433 449 attr.type = PERF_TYPE_HW_CACHE;
434 *str = s; 450 return add_event(list, idx, &attr, name);
435 return EVT_HANDLED;
436} 451}
437 452
438static enum event_result 453static int add_tracepoint(struct list_head *list, int *idx,
439parse_single_tracepoint_event(char *sys_name, 454 char *sys_name, char *evt_name)
440 const char *evt_name,
441 unsigned int evt_length,
442 struct perf_event_attr *attr,
443 const char **strp)
444{ 455{
456 struct perf_event_attr attr;
457 char name[MAX_NAME_LEN];
445 char evt_path[MAXPATHLEN]; 458 char evt_path[MAXPATHLEN];
446 char id_buf[4]; 459 char id_buf[4];
447 u64 id; 460 u64 id;
@@ -452,130 +465,80 @@ parse_single_tracepoint_event(char *sys_name,
452 465
453 fd = open(evt_path, O_RDONLY); 466 fd = open(evt_path, O_RDONLY);
454 if (fd < 0) 467 if (fd < 0)
455 return EVT_FAILED; 468 return -1;
456 469
457 if (read(fd, id_buf, sizeof(id_buf)) < 0) { 470 if (read(fd, id_buf, sizeof(id_buf)) < 0) {
458 close(fd); 471 close(fd);
459 return EVT_FAILED; 472 return -1;
460 } 473 }
461 474
462 close(fd); 475 close(fd);
463 id = atoll(id_buf); 476 id = atoll(id_buf);
464 attr->config = id;
465 attr->type = PERF_TYPE_TRACEPOINT;
466 *strp += strlen(sys_name) + evt_length + 1; /* + 1 for the ':' */
467
468 attr->sample_type |= PERF_SAMPLE_RAW;
469 attr->sample_type |= PERF_SAMPLE_TIME;
470 attr->sample_type |= PERF_SAMPLE_CPU;
471 477
472 attr->sample_period = 1; 478 memset(&attr, 0, sizeof(attr));
479 attr.config = id;
480 attr.type = PERF_TYPE_TRACEPOINT;
481 attr.sample_type |= PERF_SAMPLE_RAW;
482 attr.sample_type |= PERF_SAMPLE_TIME;
483 attr.sample_type |= PERF_SAMPLE_CPU;
484 attr.sample_period = 1;
473 485
474 486 snprintf(name, MAX_NAME_LEN, "%s:%s", sys_name, evt_name);
475 return EVT_HANDLED; 487 return add_event(list, idx, &attr, name);
476} 488}
477 489
478/* sys + ':' + event + ':' + flags*/ 490static int add_tracepoint_multi(struct list_head *list, int *idx,
479#define MAX_EVOPT_LEN (MAX_EVENT_LENGTH * 2 + 2 + 128) 491 char *sys_name, char *evt_name)
480static enum event_result
481parse_multiple_tracepoint_event(struct perf_evlist *evlist, char *sys_name,
482 const char *evt_exp, char *flags)
483{ 492{
484 char evt_path[MAXPATHLEN]; 493 char evt_path[MAXPATHLEN];
485 struct dirent *evt_ent; 494 struct dirent *evt_ent;
486 DIR *evt_dir; 495 DIR *evt_dir;
496 int ret = 0;
487 497
488 snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name); 498 snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
489 evt_dir = opendir(evt_path); 499 evt_dir = opendir(evt_path);
490
491 if (!evt_dir) { 500 if (!evt_dir) {
492 perror("Can't open event dir"); 501 perror("Can't open event dir");
493 return EVT_FAILED; 502 return -1;
494 } 503 }
495 504
496 while ((evt_ent = readdir(evt_dir))) { 505 while (!ret && (evt_ent = readdir(evt_dir))) {
497 char event_opt[MAX_EVOPT_LEN + 1];
498 int len;
499
500 if (!strcmp(evt_ent->d_name, ".") 506 if (!strcmp(evt_ent->d_name, ".")
501 || !strcmp(evt_ent->d_name, "..") 507 || !strcmp(evt_ent->d_name, "..")
502 || !strcmp(evt_ent->d_name, "enable") 508 || !strcmp(evt_ent->d_name, "enable")
503 || !strcmp(evt_ent->d_name, "filter")) 509 || !strcmp(evt_ent->d_name, "filter"))
504 continue; 510 continue;
505 511
506 if (!strglobmatch(evt_ent->d_name, evt_exp)) 512 if (!strglobmatch(evt_ent->d_name, evt_name))
507 continue; 513 continue;
508 514
509 len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s%s%s", sys_name, 515 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name);
510 evt_ent->d_name, flags ? ":" : "",
511 flags ?: "");
512 if (len < 0)
513 return EVT_FAILED;
514
515 if (parse_events(evlist, event_opt, 0))
516 return EVT_FAILED;
517 } 516 }
518 517
519 return EVT_HANDLED_ALL; 518 return ret;
520} 519}
521 520
522static enum event_result 521int parse_events_add_tracepoint(struct list_head *list, int *idx,
523parse_tracepoint_event(struct perf_evlist *evlist, const char **strp, 522 char *sys, char *event)
524 struct perf_event_attr *attr)
525{ 523{
526 const char *evt_name; 524 int ret;
527 char *flags = NULL, *comma_loc;
528 char sys_name[MAX_EVENT_LENGTH];
529 unsigned int sys_length, evt_length;
530 525
531 if (debugfs_valid_mountpoint(tracing_events_path)) 526 ret = debugfs_valid_mountpoint(tracing_events_path);
532 return 0; 527 if (ret)
533 528 return ret;
534 evt_name = strchr(*strp, ':');
535 if (!evt_name)
536 return EVT_FAILED;
537
538 sys_length = evt_name - *strp;
539 if (sys_length >= MAX_EVENT_LENGTH)
540 return 0;
541 529
542 strncpy(sys_name, *strp, sys_length); 530 return strpbrk(event, "*?") ?
543 sys_name[sys_length] = '\0'; 531 add_tracepoint_multi(list, idx, sys, event) :
544 evt_name = evt_name + 1; 532 add_tracepoint(list, idx, sys, event);
545
546 comma_loc = strchr(evt_name, ',');
547 if (comma_loc) {
548 /* take the event name up to the comma */
549 evt_name = strndup(evt_name, comma_loc - evt_name);
550 }
551 flags = strchr(evt_name, ':');
552 if (flags) {
553 /* split it out: */
554 evt_name = strndup(evt_name, flags - evt_name);
555 flags++;
556 }
557
558 evt_length = strlen(evt_name);
559 if (evt_length >= MAX_EVENT_LENGTH)
560 return EVT_FAILED;
561 if (strpbrk(evt_name, "*?")) {
562 *strp += strlen(sys_name) + evt_length + 1; /* 1 == the ':' */
563 return parse_multiple_tracepoint_event(evlist, sys_name,
564 evt_name, flags);
565 } else {
566 return parse_single_tracepoint_event(sys_name, evt_name,
567 evt_length, attr, strp);
568 }
569} 533}
570 534
571static enum event_result 535static int
572parse_breakpoint_type(const char *type, const char **strp, 536parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
573 struct perf_event_attr *attr)
574{ 537{
575 int i; 538 int i;
576 539
577 for (i = 0; i < 3; i++) { 540 for (i = 0; i < 3; i++) {
578 if (!type[i]) 541 if (!type || !type[i])
579 break; 542 break;
580 543
581 switch (type[i]) { 544 switch (type[i]) {
@@ -589,164 +552,134 @@ parse_breakpoint_type(const char *type, const char **strp,
589 attr->bp_type |= HW_BREAKPOINT_X; 552 attr->bp_type |= HW_BREAKPOINT_X;
590 break; 553 break;
591 default: 554 default:
592 return EVT_FAILED; 555 return -EINVAL;
593 } 556 }
594 } 557 }
558
595 if (!attr->bp_type) /* Default */ 559 if (!attr->bp_type) /* Default */
596 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W; 560 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
597 561
598 *strp = type + i; 562 return 0;
599
600 return EVT_HANDLED;
601} 563}
602 564
603static enum event_result 565int parse_events_add_breakpoint(struct list_head *list, int *idx,
604parse_breakpoint_event(const char **strp, struct perf_event_attr *attr) 566 void *ptr, char *type)
605{ 567{
606 const char *target; 568 struct perf_event_attr attr;
607 const char *type; 569 char name[MAX_NAME_LEN];
608 char *endaddr;
609 u64 addr;
610 enum event_result err;
611
612 target = strchr(*strp, ':');
613 if (!target)
614 return EVT_FAILED;
615
616 if (strncmp(*strp, "mem", target - *strp) != 0)
617 return EVT_FAILED;
618
619 target++;
620
621 addr = strtoull(target, &endaddr, 0);
622 if (target == endaddr)
623 return EVT_FAILED;
624
625 attr->bp_addr = addr;
626 *strp = endaddr;
627 570
628 type = strchr(target, ':'); 571 memset(&attr, 0, sizeof(attr));
572 attr.bp_addr = (u64) ptr;
629 573
630 /* If no type is defined, just rw as default */ 574 if (parse_breakpoint_type(type, &attr))
631 if (!type) { 575 return -EINVAL;
632 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
633 } else {
634 err = parse_breakpoint_type(++type, strp, attr);
635 if (err == EVT_FAILED)
636 return EVT_FAILED;
637 }
638 576
639 /* 577 /*
640 * We should find a nice way to override the access length 578 * We should find a nice way to override the access length
641 * Provide some defaults for now 579 * Provide some defaults for now
642 */ 580 */
643 if (attr->bp_type == HW_BREAKPOINT_X) 581 if (attr.bp_type == HW_BREAKPOINT_X)
644 attr->bp_len = sizeof(long); 582 attr.bp_len = sizeof(long);
645 else 583 else
646 attr->bp_len = HW_BREAKPOINT_LEN_4; 584 attr.bp_len = HW_BREAKPOINT_LEN_4;
647 585
648 attr->type = PERF_TYPE_BREAKPOINT; 586 attr.type = PERF_TYPE_BREAKPOINT;
649 587
650 return EVT_HANDLED; 588 snprintf(name, MAX_NAME_LEN, "mem:%p:%s", ptr, type ? type : "rw");
589 return add_event(list, idx, &attr, name);
651} 590}
652 591
653static int check_events(const char *str, unsigned int i) 592static int config_term(struct perf_event_attr *attr,
593 struct parse_events__term *term)
654{ 594{
655 int n; 595 switch (term->type) {
656 596 case PARSE_EVENTS__TERM_TYPE_CONFIG:
657 n = strlen(event_symbols[i].symbol); 597 attr->config = term->val.num;
658 if (!strncasecmp(str, event_symbols[i].symbol, n)) 598 break;
659 return n; 599 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
660 600 attr->config1 = term->val.num;
661 n = strlen(event_symbols[i].alias); 601 break;
662 if (n) { 602 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
663 if (!strncasecmp(str, event_symbols[i].alias, n)) 603 attr->config2 = term->val.num;
664 return n; 604 break;
605 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
606 attr->sample_period = term->val.num;
607 break;
608 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
609 /*
610 * TODO uncomment when the field is available
611 * attr->branch_sample_type = term->val.num;
612 */
613 break;
614 default:
615 return -EINVAL;
665 } 616 }
666
667 return 0; 617 return 0;
668} 618}
669 619
670static enum event_result 620static int config_attr(struct perf_event_attr *attr,
671parse_symbolic_event(const char **strp, struct perf_event_attr *attr) 621 struct list_head *head, int fail)
672{ 622{
673 const char *str = *strp; 623 struct parse_events__term *term;
674 unsigned int i; 624
675 int n; 625 list_for_each_entry(term, head, list)
676 626 if (config_term(attr, term) && fail)
677 for (i = 0; i < ARRAY_SIZE(event_symbols); i++) { 627 return -EINVAL;
678 n = check_events(str, i); 628
679 if (n > 0) { 629 return 0;
680 attr->type = event_symbols[i].type;
681 attr->config = event_symbols[i].config;
682 *strp = str + n;
683 return EVT_HANDLED;
684 }
685 }
686 return EVT_FAILED;
687} 630}
688 631
689static enum event_result 632int parse_events_add_numeric(struct list_head *list, int *idx,
690parse_raw_event(const char **strp, struct perf_event_attr *attr) 633 unsigned long type, unsigned long config,
634 struct list_head *head_config)
691{ 635{
692 const char *str = *strp; 636 struct perf_event_attr attr;
693 u64 config; 637
694 int n; 638 memset(&attr, 0, sizeof(attr));
695 639 attr.type = type;
696 if (*str != 'r') 640 attr.config = config;
697 return EVT_FAILED; 641
698 n = hex2u64(str + 1, &config); 642 if (head_config &&
699 if (n > 0) { 643 config_attr(&attr, head_config, 1))
700 const char *end = str + n + 1; 644 return -EINVAL;
701 if (*end != '\0' && *end != ',' && *end != ':') 645
702 return EVT_FAILED; 646 return add_event(list, idx, &attr,
703 647 (char *) __event_name(type, config));
704 *strp = end;
705 attr->type = PERF_TYPE_RAW;
706 attr->config = config;
707 return EVT_HANDLED;
708 }
709 return EVT_FAILED;
710} 648}
711 649
712static enum event_result 650int parse_events_add_pmu(struct list_head *list, int *idx,
713parse_numeric_event(const char **strp, struct perf_event_attr *attr) 651 char *name, struct list_head *head_config)
714{ 652{
715 const char *str = *strp; 653 struct perf_event_attr attr;
716 char *endp; 654 struct perf_pmu *pmu;
717 unsigned long type; 655
718 u64 config; 656 pmu = perf_pmu__find(name);
719 657 if (!pmu)
720 type = strtoul(str, &endp, 0); 658 return -EINVAL;
721 if (endp > str && type < PERF_TYPE_MAX && *endp == ':') { 659
722 str = endp + 1; 660 memset(&attr, 0, sizeof(attr));
723 config = strtoul(str, &endp, 0); 661
724 if (endp > str) { 662 /*
725 attr->type = type; 663 * Configure hardcoded terms first, no need to check
726 attr->config = config; 664 * return value when called with fail == 0 ;)
727 *strp = endp; 665 */
728 return EVT_HANDLED; 666 config_attr(&attr, head_config, 0);
729 } 667
730 } 668 if (perf_pmu__config(pmu, &attr, head_config))
731 return EVT_FAILED; 669 return -EINVAL;
670
671 return add_event(list, idx, &attr, (char *) "pmu");
732} 672}
733 673
734static int 674int parse_events_modifier(struct list_head *list, char *str)
735parse_event_modifier(const char **strp, struct perf_event_attr *attr)
736{ 675{
737 const char *str = *strp; 676 struct perf_evsel *evsel;
738 int exclude = 0, exclude_GH = 0; 677 int exclude = 0, exclude_GH = 0;
739 int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0; 678 int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0;
740 679
741 if (!*str) 680 if (str == NULL)
742 return 0; 681 return 0;
743 682
744 if (*str == ',')
745 return 0;
746
747 if (*str++ != ':')
748 return -1;
749
750 while (*str) { 683 while (*str) {
751 if (*str == 'u') { 684 if (*str == 'u') {
752 if (!exclude) 685 if (!exclude)
@@ -775,111 +708,60 @@ parse_event_modifier(const char **strp, struct perf_event_attr *attr)
775 708
776 ++str; 709 ++str;
777 } 710 }
778 if (str < *strp + 2)
779 return -1;
780 711
781 *strp = str; 712 /*
713 * precise ip:
714 *
715 * 0 - SAMPLE_IP can have arbitrary skid
716 * 1 - SAMPLE_IP must have constant skid
717 * 2 - SAMPLE_IP requested to have 0 skid
718 * 3 - SAMPLE_IP must have 0 skid
719 *
720 * See also PERF_RECORD_MISC_EXACT_IP
721 */
722 if (precise > 3)
723 return -EINVAL;
782 724
783 attr->exclude_user = eu; 725 list_for_each_entry(evsel, list, node) {
784 attr->exclude_kernel = ek; 726 evsel->attr.exclude_user = eu;
785 attr->exclude_hv = eh; 727 evsel->attr.exclude_kernel = ek;
786 attr->precise_ip = precise; 728 evsel->attr.exclude_hv = eh;
787 attr->exclude_host = eH; 729 evsel->attr.precise_ip = precise;
788 attr->exclude_guest = eG; 730 evsel->attr.exclude_host = eH;
731 evsel->attr.exclude_guest = eG;
732 }
789 733
790 return 0; 734 return 0;
791} 735}
792 736
793/* 737int parse_events(struct perf_evlist *evlist, const char *str, int unset __used)
794 * Each event can have multiple symbolic names.
795 * Symbolic names are (almost) exactly matched.
796 */
797static enum event_result
798parse_event_symbols(struct perf_evlist *evlist, const char **str,
799 struct perf_event_attr *attr)
800{ 738{
801 enum event_result ret; 739 struct perf_evsel *evsel, *h;
740 LIST_HEAD(list);
741 YY_BUFFER_STATE buffer;
742 int ret, idx = evlist->nr_entries;
802 743
803 ret = parse_tracepoint_event(evlist, str, attr); 744 buffer = parse_events__scan_string(str);
804 if (ret != EVT_FAILED)
805 goto modifier;
806 745
807 ret = parse_raw_event(str, attr); 746 ret = parse_events_parse(&list, &idx);
808 if (ret != EVT_FAILED)
809 goto modifier;
810 747
811 ret = parse_numeric_event(str, attr); 748 parse_events__flush_buffer(buffer);
812 if (ret != EVT_FAILED) 749 parse_events__delete_buffer(buffer);
813 goto modifier;
814 750
815 ret = parse_symbolic_event(str, attr); 751 if (!ret) {
816 if (ret != EVT_FAILED) 752 int entries = idx - evlist->nr_entries;
817 goto modifier; 753 perf_evlist__splice_list_tail(evlist, &list, entries);
818 754 return 0;
819 ret = parse_generic_hw_event(str, attr); 755 }
820 if (ret != EVT_FAILED)
821 goto modifier;
822 756
823 ret = parse_breakpoint_event(str, attr); 757 list_for_each_entry_safe(evsel, h, &list, node)
824 if (ret != EVT_FAILED) 758 perf_evsel__delete(evsel);
825 goto modifier;
826 759
827 fprintf(stderr, "invalid or unsupported event: '%s'\n", *str); 760 fprintf(stderr, "invalid or unsupported event: '%s'\n", str);
828 fprintf(stderr, "Run 'perf list' for a list of valid events\n"); 761 fprintf(stderr, "Run 'perf list' for a list of valid events\n");
829 return EVT_FAILED;
830
831modifier:
832 if (parse_event_modifier(str, attr) < 0) {
833 fprintf(stderr, "invalid event modifier: '%s'\n", *str);
834 fprintf(stderr, "Run 'perf list' for a list of valid events and modifiers\n");
835
836 return EVT_FAILED;
837 }
838
839 return ret; 762 return ret;
840} 763}
841 764
842int parse_events(struct perf_evlist *evlist , const char *str, int unset __used)
843{
844 struct perf_event_attr attr;
845 enum event_result ret;
846 const char *ostr;
847
848 for (;;) {
849 ostr = str;
850 memset(&attr, 0, sizeof(attr));
851 event_attr_init(&attr);
852 ret = parse_event_symbols(evlist, &str, &attr);
853 if (ret == EVT_FAILED)
854 return -1;
855
856 if (!(*str == 0 || *str == ',' || isspace(*str)))
857 return -1;
858
859 if (ret != EVT_HANDLED_ALL) {
860 struct perf_evsel *evsel;
861 evsel = perf_evsel__new(&attr, evlist->nr_entries);
862 if (evsel == NULL)
863 return -1;
864 perf_evlist__add(evlist, evsel);
865
866 evsel->name = calloc(str - ostr + 1, 1);
867 if (!evsel->name)
868 return -1;
869 strncpy(evsel->name, ostr, str - ostr);
870 }
871
872 if (*str == 0)
873 break;
874 if (*str == ',')
875 ++str;
876 while (isspace(*str))
877 ++str;
878 }
879
880 return 0;
881}
882
883int parse_events_option(const struct option *opt, const char *str, 765int parse_events_option(const struct option *opt, const char *str,
884 int unset __used) 766 int unset __used)
885{ 767{
@@ -1052,8 +934,6 @@ int print_hwcache_events(const char *event_glob)
1052 return printed; 934 return printed;
1053} 935}
1054 936
1055#define MAX_NAME_LEN 100
1056
1057/* 937/*
1058 * Print the help text for the event symbols: 938 * Print the help text for the event symbols:
1059 */ 939 */
@@ -1102,8 +982,12 @@ void print_events(const char *event_glob)
1102 982
1103 printf("\n"); 983 printf("\n");
1104 printf(" %-50s [%s]\n", 984 printf(" %-50s [%s]\n",
1105 "rNNN (see 'perf list --help' on how to encode it)", 985 "rNNN",
986 event_type_descriptors[PERF_TYPE_RAW]);
987 printf(" %-50s [%s]\n",
988 "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
1106 event_type_descriptors[PERF_TYPE_RAW]); 989 event_type_descriptors[PERF_TYPE_RAW]);
990 printf(" (see 'perf list --help' on how to encode it)\n");
1107 printf("\n"); 991 printf("\n");
1108 992
1109 printf(" %-50s [%s]\n", 993 printf(" %-50s [%s]\n",
@@ -1113,3 +997,51 @@ void print_events(const char *event_glob)
1113 997
1114 print_tracepoint_events(NULL, NULL); 998 print_tracepoint_events(NULL, NULL);
1115} 999}
1000
1001int parse_events__is_hardcoded_term(struct parse_events__term *term)
1002{
1003 return term->type <= PARSE_EVENTS__TERM_TYPE_HARDCODED_MAX;
1004}
1005
1006int parse_events__new_term(struct parse_events__term **_term, int type,
1007 char *config, char *str, long num)
1008{
1009 struct parse_events__term *term;
1010
1011 term = zalloc(sizeof(*term));
1012 if (!term)
1013 return -ENOMEM;
1014
1015 INIT_LIST_HEAD(&term->list);
1016 term->type = type;
1017 term->config = config;
1018
1019 switch (type) {
1020 case PARSE_EVENTS__TERM_TYPE_CONFIG:
1021 case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1022 case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1023 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1024 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1025 case PARSE_EVENTS__TERM_TYPE_NUM:
1026 term->val.num = num;
1027 break;
1028 case PARSE_EVENTS__TERM_TYPE_STR:
1029 term->val.str = str;
1030 break;
1031 default:
1032 return -EINVAL;
1033 }
1034
1035 *_term = term;
1036 return 0;
1037}
1038
1039void parse_events__free_terms(struct list_head *terms)
1040{
1041 struct parse_events__term *term, *h;
1042
1043 list_for_each_entry_safe(term, h, terms, list)
1044 free(term);
1045
1046 free(terms);
1047}
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 7e0cbe75d5f1..6d7c74b77c24 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -33,6 +33,52 @@ extern int parse_filter(const struct option *opt, const char *str, int unset);
33 33
34#define EVENTS_HELP_MAX (128*1024) 34#define EVENTS_HELP_MAX (128*1024)
35 35
36enum {
37 PARSE_EVENTS__TERM_TYPE_CONFIG,
38 PARSE_EVENTS__TERM_TYPE_CONFIG1,
39 PARSE_EVENTS__TERM_TYPE_CONFIG2,
40 PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD,
41 PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
42 PARSE_EVENTS__TERM_TYPE_NUM,
43 PARSE_EVENTS__TERM_TYPE_STR,
44
45 PARSE_EVENTS__TERM_TYPE_HARDCODED_MAX =
46 PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
47};
48
49struct parse_events__term {
50 char *config;
51 union {
52 char *str;
53 long num;
54 } val;
55 int type;
56
57 struct list_head list;
58};
59
60int parse_events__is_hardcoded_term(struct parse_events__term *term);
61int parse_events__new_term(struct parse_events__term **term, int type,
62 char *config, char *str, long num);
63void parse_events__free_terms(struct list_head *terms);
64int parse_events_modifier(struct list_head *list __used, char *str __used);
65int parse_events_add_tracepoint(struct list_head *list, int *idx,
66 char *sys, char *event);
67int parse_events_add_raw(struct perf_evlist *evlist, unsigned long config,
68 unsigned long config1, unsigned long config2,
69 char *mod);
70int parse_events_add_numeric(struct list_head *list, int *idx,
71 unsigned long type, unsigned long config,
72 struct list_head *head_config);
73int parse_events_add_cache(struct list_head *list, int *idx,
74 char *type, char *op_result1, char *op_result2);
75int parse_events_add_breakpoint(struct list_head *list, int *idx,
76 void *ptr, char *type);
77int parse_events_add_pmu(struct list_head *list, int *idx,
78 char *pmu , struct list_head *head_config);
79void parse_events_error(struct list_head *list, int *idx,
80 char const *msg);
81
36void print_events(const char *event_glob); 82void print_events(const char *event_glob);
37void print_events_type(u8 type); 83void print_events_type(u8 type);
38void print_tracepoint_events(const char *subsys_glob, const char *event_glob); 84void print_tracepoint_events(const char *subsys_glob, const char *event_glob);
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
new file mode 100644
index 000000000000..ab9eca120feb
--- /dev/null
+++ b/tools/perf/util/parse-events.l
@@ -0,0 +1,126 @@
1
2%option prefix="parse_events_"
3
4%{
5#include <errno.h>
6#include "../perf.h"
7#include "parse-events-bison.h"
8#include "parse-events.h"
9
10static int __value(char *str, int base, int token)
11{
12 long num;
13
14 errno = 0;
15 num = strtoul(str, NULL, base);
16 if (errno)
17 return PE_ERROR;
18
19 parse_events_lval.num = num;
20 return token;
21}
22
23static int value(int base)
24{
25 return __value(parse_events_text, base, PE_VALUE);
26}
27
28static int raw(void)
29{
30 return __value(parse_events_text + 1, 16, PE_RAW);
31}
32
33static int str(int token)
34{
35 parse_events_lval.str = strdup(parse_events_text);
36 return token;
37}
38
39static int sym(int type, int config)
40{
41 parse_events_lval.num = (type << 16) + config;
42 return PE_VALUE_SYM;
43}
44
45static int term(int type)
46{
47 parse_events_lval.num = type;
48 return PE_TERM;
49}
50
51%}
52
53num_dec [0-9]+
54num_hex 0x[a-fA-F0-9]+
55num_raw_hex [a-fA-F0-9]+
56name [a-zA-Z_*?][a-zA-Z0-9_*?]*
57modifier_event [ukhp]{1,5}
58modifier_bp [rwx]
59
60%%
61cpu-cycles|cycles { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); }
62stalled-cycles-frontend|idle-cycles-frontend { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
63stalled-cycles-backend|idle-cycles-backend { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
64instructions { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); }
65cache-references { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); }
66cache-misses { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); }
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); }
69bus-cycles { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); }
70cpu-clock { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); }
71task-clock { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); }
72page-faults|faults { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); }
73minor-faults { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); }
74major-faults { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); }
75context-switches|cs { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); }
76cpu-migrations|migrations { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); }
77alignment-faults { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); }
78emulation-faults { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); }
79
80L1-dcache|l1-d|l1d|L1-data |
81L1-icache|l1-i|l1i|L1-instruction |
82LLC|L2 |
83dTLB|d-tlb|Data-TLB |
84iTLB|i-tlb|Instruction-TLB |
85branch|branches|bpu|btb|bpc |
86node { return str(PE_NAME_CACHE_TYPE); }
87
88load|loads|read |
89store|stores|write |
90prefetch|prefetches |
91speculative-read|speculative-load |
92refs|Reference|ops|access |
93misses|miss { return str(PE_NAME_CACHE_OP_RESULT); }
94
95 /*
96 * These are event config hardcoded term names to be specified
97 * within xxx/.../ syntax. So far we dont clash with other names,
98 * so we can put them here directly. In case the we have a conflict
99 * in future, this needs to go into '//' condition block.
100 */
101config { return term(PARSE_EVENTS__TERM_TYPE_CONFIG); }
102config1 { return term(PARSE_EVENTS__TERM_TYPE_CONFIG1); }
103config2 { return term(PARSE_EVENTS__TERM_TYPE_CONFIG2); }
104period { return term(PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); }
105branch_type { return term(PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); }
106
107mem: { return PE_PREFIX_MEM; }
108r{num_raw_hex} { return raw(); }
109{num_dec} { return value(10); }
110{num_hex} { return value(16); }
111
112{modifier_event} { return str(PE_MODIFIER_EVENT); }
113{modifier_bp} { return str(PE_MODIFIER_BP); }
114{name} { return str(PE_NAME); }
115"/" { return '/'; }
116- { return '-'; }
117, { return ','; }
118: { return ':'; }
119= { return '='; }
120
121%%
122
123int parse_events_wrap(void)
124{
125 return 1;
126}
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
new file mode 100644
index 000000000000..3a530193f5a8
--- /dev/null
+++ b/tools/perf/util/parse-events.y
@@ -0,0 +1,217 @@
1
2%name-prefix "parse_events_"
3%parse-param {struct list_head *list}
4%parse-param {int *idx}
5
6%{
7
8#define YYDEBUG 1
9
10#include <linux/compiler.h>
11#include <linux/list.h>
12#include "types.h"
13#include "util.h"
14#include "parse-events.h"
15
16extern int parse_events_lex (void);
17
18#define ABORT_ON(val) \
19do { \
20 if (val) \
21 YYABORT; \
22} while (0)
23
24%}
25
26%token PE_VALUE PE_VALUE_SYM PE_RAW PE_TERM
27%token PE_NAME
28%token PE_MODIFIER_EVENT PE_MODIFIER_BP
29%token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
30%token PE_PREFIX_MEM PE_PREFIX_RAW
31%token PE_ERROR
32%type <num> PE_VALUE
33%type <num> PE_VALUE_SYM
34%type <num> PE_RAW
35%type <num> PE_TERM
36%type <str> PE_NAME
37%type <str> PE_NAME_CACHE_TYPE
38%type <str> PE_NAME_CACHE_OP_RESULT
39%type <str> PE_MODIFIER_EVENT
40%type <str> PE_MODIFIER_BP
41%type <head> event_config
42%type <term> event_term
43
44%union
45{
46 char *str;
47 unsigned long num;
48 struct list_head *head;
49 struct parse_events__term *term;
50}
51%%
52
53events:
54events ',' event | event
55
56event:
57event_def PE_MODIFIER_EVENT
58{
59 ABORT_ON(parse_events_modifier(list, $2));
60}
61|
62event_def
63
64event_def: event_pmu |
65 event_legacy_symbol |
66 event_legacy_cache sep_dc |
67 event_legacy_mem |
68 event_legacy_tracepoint sep_dc |
69 event_legacy_numeric sep_dc |
70 event_legacy_raw sep_dc
71
72event_pmu:
73PE_NAME '/' event_config '/'
74{
75 ABORT_ON(parse_events_add_pmu(list, idx, $1, $3));
76 parse_events__free_terms($3);
77}
78
79event_legacy_symbol:
80PE_VALUE_SYM '/' event_config '/'
81{
82 int type = $1 >> 16;
83 int config = $1 & 255;
84
85 ABORT_ON(parse_events_add_numeric(list, idx, type, config, $3));
86 parse_events__free_terms($3);
87}
88|
89PE_VALUE_SYM sep_slash_dc
90{
91 int type = $1 >> 16;
92 int config = $1 & 255;
93
94 ABORT_ON(parse_events_add_numeric(list, idx, type, config, NULL));
95}
96
97event_legacy_cache:
98PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
99{
100 ABORT_ON(parse_events_add_cache(list, idx, $1, $3, $5));
101}
102|
103PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
104{
105 ABORT_ON(parse_events_add_cache(list, idx, $1, $3, NULL));
106}
107|
108PE_NAME_CACHE_TYPE
109{
110 ABORT_ON(parse_events_add_cache(list, idx, $1, NULL, NULL));
111}
112
113event_legacy_mem:
114PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
115{
116 ABORT_ON(parse_events_add_breakpoint(list, idx, (void *) $2, $4));
117}
118|
119PE_PREFIX_MEM PE_VALUE sep_dc
120{
121 ABORT_ON(parse_events_add_breakpoint(list, idx, (void *) $2, NULL));
122}
123
124event_legacy_tracepoint:
125PE_NAME ':' PE_NAME
126{
127 ABORT_ON(parse_events_add_tracepoint(list, idx, $1, $3));
128}
129
130event_legacy_numeric:
131PE_VALUE ':' PE_VALUE
132{
133 ABORT_ON(parse_events_add_numeric(list, idx, $1, $3, NULL));
134}
135
136event_legacy_raw:
137PE_RAW
138{
139 ABORT_ON(parse_events_add_numeric(list, idx, PERF_TYPE_RAW, $1, NULL));
140}
141
142event_config:
143event_config ',' event_term
144{
145 struct list_head *head = $1;
146 struct parse_events__term *term = $3;
147
148 ABORT_ON(!head);
149 list_add_tail(&term->list, head);
150 $$ = $1;
151}
152|
153event_term
154{
155 struct list_head *head = malloc(sizeof(*head));
156 struct parse_events__term *term = $1;
157
158 ABORT_ON(!head);
159 INIT_LIST_HEAD(head);
160 list_add_tail(&term->list, head);
161 $$ = head;
162}
163
164event_term:
165PE_NAME '=' PE_NAME
166{
167 struct parse_events__term *term;
168
169 ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_STR,
170 $1, $3, 0));
171 $$ = term;
172}
173|
174PE_NAME '=' PE_VALUE
175{
176 struct parse_events__term *term;
177
178 ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
179 $1, NULL, $3));
180 $$ = term;
181}
182|
183PE_NAME
184{
185 struct parse_events__term *term;
186
187 ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
188 $1, NULL, 1));
189 $$ = term;
190}
191|
192PE_TERM '=' PE_VALUE
193{
194 struct parse_events__term *term;
195
196 ABORT_ON(parse_events__new_term(&term, $1, NULL, NULL, $3));
197 $$ = term;
198}
199|
200PE_TERM
201{
202 struct parse_events__term *term;
203
204 ABORT_ON(parse_events__new_term(&term, $1, NULL, NULL, 1));
205 $$ = term;
206}
207
208sep_dc: ':' |
209
210sep_slash_dc: '/' | ':' |
211
212%%
213
214void parse_events_error(struct list_head *list __used, int *idx __used,
215 char const *msg __used)
216{
217}
diff --git a/tools/perf/util/pmu-bison.c b/tools/perf/util/pmu-bison.c
new file mode 100644
index 000000000000..343521ec589f
--- /dev/null
+++ b/tools/perf/util/pmu-bison.c
@@ -0,0 +1,1663 @@
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
new file mode 100644
index 000000000000..54f4a0d7829b
--- /dev/null
+++ b/tools/perf/util/pmu-bison.h
@@ -0,0 +1,73 @@
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
new file mode 100644
index 000000000000..5a8c15966d5c
--- /dev/null
+++ b/tools/perf/util/pmu-flex.c
@@ -0,0 +1,1821 @@
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
new file mode 100644
index 000000000000..0a29c8a0da4e
--- /dev/null
+++ b/tools/perf/util/pmu-flex.h
@@ -0,0 +1,316 @@
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/pmu.c b/tools/perf/util/pmu.c
new file mode 100644
index 000000000000..cb08a118e811
--- /dev/null
+++ b/tools/perf/util/pmu.c
@@ -0,0 +1,469 @@
1
2#include <linux/list.h>
3#include <sys/types.h>
4#include <sys/stat.h>
5#include <unistd.h>
6#include <stdio.h>
7#include <dirent.h>
8#include "sysfs.h"
9#include "util.h"
10#include "pmu.h"
11#include "parse-events.h"
12
13int perf_pmu_parse(struct list_head *list, char *name);
14extern FILE *perf_pmu_in;
15
16static LIST_HEAD(pmus);
17
18/*
19 * Parse & process all the sysfs attributes located under
20 * the directory specified in 'dir' parameter.
21 */
22static int pmu_format_parse(char *dir, struct list_head *head)
23{
24 struct dirent *evt_ent;
25 DIR *format_dir;
26 int ret = 0;
27
28 format_dir = opendir(dir);
29 if (!format_dir)
30 return -EINVAL;
31
32 while (!ret && (evt_ent = readdir(format_dir))) {
33 char path[PATH_MAX];
34 char *name = evt_ent->d_name;
35 FILE *file;
36
37 if (!strcmp(name, ".") || !strcmp(name, ".."))
38 continue;
39
40 snprintf(path, PATH_MAX, "%s/%s", dir, name);
41
42 ret = -EINVAL;
43 file = fopen(path, "r");
44 if (!file)
45 break;
46
47 perf_pmu_in = file;
48 ret = perf_pmu_parse(head, name);
49 fclose(file);
50 }
51
52 closedir(format_dir);
53 return ret;
54}
55
56/*
57 * Reading/parsing the default pmu format definition, which should be
58 * located at:
59 * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes.
60 */
61static int pmu_format(char *name, struct list_head *format)
62{
63 struct stat st;
64 char path[PATH_MAX];
65 const char *sysfs;
66
67 sysfs = sysfs_find_mountpoint();
68 if (!sysfs)
69 return -1;
70
71 snprintf(path, PATH_MAX,
72 "%s/bus/event_source/devices/%s/format", sysfs, name);
73
74 if (stat(path, &st) < 0)
75 return -1;
76
77 if (pmu_format_parse(path, format))
78 return -1;
79
80 return 0;
81}
82
83/*
84 * Reading/parsing the default pmu type value, which should be
85 * located at:
86 * /sys/bus/event_source/devices/<dev>/type as sysfs attribute.
87 */
88static int pmu_type(char *name, __u32 *type)
89{
90 struct stat st;
91 char path[PATH_MAX];
92 const char *sysfs;
93 FILE *file;
94 int ret = 0;
95
96 sysfs = sysfs_find_mountpoint();
97 if (!sysfs)
98 return -1;
99
100 snprintf(path, PATH_MAX,
101 "%s/bus/event_source/devices/%s/type", sysfs, name);
102
103 if (stat(path, &st) < 0)
104 return -1;
105
106 file = fopen(path, "r");
107 if (!file)
108 return -EINVAL;
109
110 if (1 != fscanf(file, "%u", type))
111 ret = -1;
112
113 fclose(file);
114 return ret;
115}
116
117static struct perf_pmu *pmu_lookup(char *name)
118{
119 struct perf_pmu *pmu;
120 LIST_HEAD(format);
121 __u32 type;
122
123 /*
124 * The pmu data we store & need consists of the pmu
125 * type value and format definitions. Load both right
126 * now.
127 */
128 if (pmu_format(name, &format))
129 return NULL;
130
131 if (pmu_type(name, &type))
132 return NULL;
133
134 pmu = zalloc(sizeof(*pmu));
135 if (!pmu)
136 return NULL;
137
138 INIT_LIST_HEAD(&pmu->format);
139 list_splice(&format, &pmu->format);
140 pmu->name = strdup(name);
141 pmu->type = type;
142 return pmu;
143}
144
145static struct perf_pmu *pmu_find(char *name)
146{
147 struct perf_pmu *pmu;
148
149 list_for_each_entry(pmu, &pmus, list)
150 if (!strcmp(pmu->name, name))
151 return pmu;
152
153 return NULL;
154}
155
156struct perf_pmu *perf_pmu__find(char *name)
157{
158 struct perf_pmu *pmu;
159
160 /*
161 * Once PMU is loaded it stays in the list,
162 * so we keep us from multiple reading/parsing
163 * the pmu format definitions.
164 */
165 pmu = pmu_find(name);
166 if (pmu)
167 return pmu;
168
169 return pmu_lookup(name);
170}
171
172static struct perf_pmu__format*
173pmu_find_format(struct list_head *formats, char *name)
174{
175 struct perf_pmu__format *format;
176
177 list_for_each_entry(format, formats, list)
178 if (!strcmp(format->name, name))
179 return format;
180
181 return NULL;
182}
183
184/*
185 * Returns value based on the format definition (format parameter)
186 * and unformated value (value parameter).
187 *
188 * TODO maybe optimize a little ;)
189 */
190static __u64 pmu_format_value(unsigned long *format, __u64 value)
191{
192 unsigned long fbit, vbit;
193 __u64 v = 0;
194
195 for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
196
197 if (!test_bit(fbit, format))
198 continue;
199
200 if (!(value & (1llu << vbit++)))
201 continue;
202
203 v |= (1llu << fbit);
204 }
205
206 return v;
207}
208
209/*
210 * Setup one of config[12] attr members based on the
211 * user input data - temr parameter.
212 */
213static int pmu_config_term(struct list_head *formats,
214 struct perf_event_attr *attr,
215 struct parse_events__term *term)
216{
217 struct perf_pmu__format *format;
218 __u64 *vp;
219
220 /*
221 * Support only for hardcoded and numnerial terms.
222 * Hardcoded terms should be already in, so nothing
223 * to be done for them.
224 */
225 if (parse_events__is_hardcoded_term(term))
226 return 0;
227
228 if (term->type != PARSE_EVENTS__TERM_TYPE_NUM)
229 return -EINVAL;
230
231 format = pmu_find_format(formats, term->config);
232 if (!format)
233 return -EINVAL;
234
235 switch (format->value) {
236 case PERF_PMU_FORMAT_VALUE_CONFIG:
237 vp = &attr->config;
238 break;
239 case PERF_PMU_FORMAT_VALUE_CONFIG1:
240 vp = &attr->config1;
241 break;
242 case PERF_PMU_FORMAT_VALUE_CONFIG2:
243 vp = &attr->config2;
244 break;
245 default:
246 return -EINVAL;
247 }
248
249 *vp |= pmu_format_value(format->bits, term->val.num);
250 return 0;
251}
252
253static int pmu_config(struct list_head *formats, struct perf_event_attr *attr,
254 struct list_head *head_terms)
255{
256 struct parse_events__term *term, *h;
257
258 list_for_each_entry_safe(term, h, head_terms, list)
259 if (pmu_config_term(formats, attr, term))
260 return -EINVAL;
261
262 return 0;
263}
264
265/*
266 * Configures event's 'attr' parameter based on the:
267 * 1) users input - specified in terms parameter
268 * 2) pmu format definitions - specified by pmu parameter
269 */
270int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
271 struct list_head *head_terms)
272{
273 attr->type = pmu->type;
274 return pmu_config(&pmu->format, attr, head_terms);
275}
276
277int perf_pmu__new_format(struct list_head *list, char *name,
278 int config, unsigned long *bits)
279{
280 struct perf_pmu__format *format;
281
282 format = zalloc(sizeof(*format));
283 if (!format)
284 return -ENOMEM;
285
286 format->name = strdup(name);
287 format->value = config;
288 memcpy(format->bits, bits, sizeof(format->bits));
289
290 list_add_tail(&format->list, list);
291 return 0;
292}
293
294void perf_pmu__set_format(unsigned long *bits, long from, long to)
295{
296 long b;
297
298 if (!to)
299 to = from;
300
301 memset(bits, 0, BITS_TO_LONGS(PERF_PMU_FORMAT_BITS));
302 for (b = from; b <= to; b++)
303 set_bit(b, bits);
304}
305
306/* Simulated format definitions. */
307static struct test_format {
308 const char *name;
309 const char *value;
310} test_formats[] = {
311 { "krava01", "config:0-1,62-63\n", },
312 { "krava02", "config:10-17\n", },
313 { "krava03", "config:5\n", },
314 { "krava11", "config1:0,2,4,6,8,20-28\n", },
315 { "krava12", "config1:63\n", },
316 { "krava13", "config1:45-47\n", },
317 { "krava21", "config2:0-3,10-13,20-23,30-33,40-43,50-53,60-63\n", },
318 { "krava22", "config2:8,18,48,58\n", },
319 { "krava23", "config2:28-29,38\n", },
320};
321
322#define TEST_FORMATS_CNT (sizeof(test_formats) / sizeof(struct test_format))
323
324/* Simulated users input. */
325static struct parse_events__term test_terms[] = {
326 {
327 .config = (char *) "krava01",
328 .val.num = 15,
329 .type = PARSE_EVENTS__TERM_TYPE_NUM,
330 },
331 {
332 .config = (char *) "krava02",
333 .val.num = 170,
334 .type = PARSE_EVENTS__TERM_TYPE_NUM,
335 },
336 {
337 .config = (char *) "krava03",
338 .val.num = 1,
339 .type = PARSE_EVENTS__TERM_TYPE_NUM,
340 },
341 {
342 .config = (char *) "krava11",
343 .val.num = 27,
344 .type = PARSE_EVENTS__TERM_TYPE_NUM,
345 },
346 {
347 .config = (char *) "krava12",
348 .val.num = 1,
349 .type = PARSE_EVENTS__TERM_TYPE_NUM,
350 },
351 {
352 .config = (char *) "krava13",
353 .val.num = 2,
354 .type = PARSE_EVENTS__TERM_TYPE_NUM,
355 },
356 {
357 .config = (char *) "krava21",
358 .val.num = 119,
359 .type = PARSE_EVENTS__TERM_TYPE_NUM,
360 },
361 {
362 .config = (char *) "krava22",
363 .val.num = 11,
364 .type = PARSE_EVENTS__TERM_TYPE_NUM,
365 },
366 {
367 .config = (char *) "krava23",
368 .val.num = 2,
369 .type = PARSE_EVENTS__TERM_TYPE_NUM,
370 },
371};
372#define TERMS_CNT (sizeof(test_terms) / sizeof(struct parse_events__term))
373
374/*
375 * Prepare format directory data, exported by kernel
376 * at /sys/bus/event_source/devices/<dev>/format.
377 */
378static char *test_format_dir_get(void)
379{
380 static char dir[PATH_MAX];
381 unsigned int i;
382
383 snprintf(dir, PATH_MAX, "/tmp/perf-pmu-test-format-XXXXXX");
384 if (!mkdtemp(dir))
385 return NULL;
386
387 for (i = 0; i < TEST_FORMATS_CNT; i++) {
388 static char name[PATH_MAX];
389 struct test_format *format = &test_formats[i];
390 FILE *file;
391
392 snprintf(name, PATH_MAX, "%s/%s", dir, format->name);
393
394 file = fopen(name, "w");
395 if (!file)
396 return NULL;
397
398 if (1 != fwrite(format->value, strlen(format->value), 1, file))
399 break;
400
401 fclose(file);
402 }
403
404 return dir;
405}
406
407/* Cleanup format directory. */
408static int test_format_dir_put(char *dir)
409{
410 char buf[PATH_MAX];
411 snprintf(buf, PATH_MAX, "rm -f %s/*\n", dir);
412 if (system(buf))
413 return -1;
414
415 snprintf(buf, PATH_MAX, "rmdir %s\n", dir);
416 return system(buf);
417}
418
419static struct list_head *test_terms_list(void)
420{
421 static LIST_HEAD(terms);
422 unsigned int i;
423
424 for (i = 0; i < TERMS_CNT; i++)
425 list_add_tail(&test_terms[i].list, &terms);
426
427 return &terms;
428}
429
430#undef TERMS_CNT
431
432int perf_pmu__test(void)
433{
434 char *format = test_format_dir_get();
435 LIST_HEAD(formats);
436 struct list_head *terms = test_terms_list();
437 int ret;
438
439 if (!format)
440 return -EINVAL;
441
442 do {
443 struct perf_event_attr attr;
444
445 memset(&attr, 0, sizeof(attr));
446
447 ret = pmu_format_parse(format, &formats);
448 if (ret)
449 break;
450
451 ret = pmu_config(&formats, &attr, terms);
452 if (ret)
453 break;
454
455 ret = -EINVAL;
456
457 if (attr.config != 0xc00000000002a823)
458 break;
459 if (attr.config1 != 0x8000400000000145)
460 break;
461 if (attr.config2 != 0x0400000020041d07)
462 break;
463
464 ret = 0;
465 } while (0);
466
467 test_format_dir_put(format);
468 return ret;
469}
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
new file mode 100644
index 000000000000..68c0db965e1f
--- /dev/null
+++ b/tools/perf/util/pmu.h
@@ -0,0 +1,41 @@
1#ifndef __PMU_H
2#define __PMU_H
3
4#include <linux/bitops.h>
5#include "../../../include/linux/perf_event.h"
6
7enum {
8 PERF_PMU_FORMAT_VALUE_CONFIG,
9 PERF_PMU_FORMAT_VALUE_CONFIG1,
10 PERF_PMU_FORMAT_VALUE_CONFIG2,
11};
12
13#define PERF_PMU_FORMAT_BITS 64
14
15struct perf_pmu__format {
16 char *name;
17 int value;
18 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
19 struct list_head list;
20};
21
22struct perf_pmu {
23 char *name;
24 __u32 type;
25 struct list_head format;
26 struct list_head list;
27};
28
29struct perf_pmu *perf_pmu__find(char *name);
30int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
31 struct list_head *head_terms);
32
33int perf_pmu_wrap(void);
34void perf_pmu_error(struct list_head *list, char *name, char const *msg);
35
36int perf_pmu__new_format(struct list_head *list, char *name,
37 int config, unsigned long *bits);
38void perf_pmu__set_format(unsigned long *bits, long from, long to);
39
40int perf_pmu__test(void);
41#endif /* __PMU_H */
diff --git a/tools/perf/util/pmu.l b/tools/perf/util/pmu.l
new file mode 100644
index 000000000000..a15d9fbd7c0e
--- /dev/null
+++ b/tools/perf/util/pmu.l
@@ -0,0 +1,43 @@
1%option prefix="perf_pmu_"
2
3%{
4#include <stdlib.h>
5#include <linux/bitops.h>
6#include "pmu.h"
7#include "pmu-bison.h"
8
9static int value(int base)
10{
11 long num;
12
13 errno = 0;
14 num = strtoul(perf_pmu_text, NULL, base);
15 if (errno)
16 return PP_ERROR;
17
18 perf_pmu_lval.num = num;
19 return PP_VALUE;
20}
21
22%}
23
24num_dec [0-9]+
25
26%%
27
28{num_dec} { return value(10); }
29config { return PP_CONFIG; }
30config1 { return PP_CONFIG1; }
31config2 { return PP_CONFIG2; }
32- { return '-'; }
33: { return ':'; }
34, { return ','; }
35. { ; }
36\n { ; }
37
38%%
39
40int perf_pmu_wrap(void)
41{
42 return 1;
43}
diff --git a/tools/perf/util/pmu.y b/tools/perf/util/pmu.y
new file mode 100644
index 000000000000..20ea77e93169
--- /dev/null
+++ b/tools/perf/util/pmu.y
@@ -0,0 +1,93 @@
1
2%name-prefix "perf_pmu_"
3%parse-param {struct list_head *format}
4%parse-param {char *name}
5
6%{
7
8#include <linux/compiler.h>
9#include <linux/list.h>
10#include <linux/bitmap.h>
11#include <string.h>
12#include "pmu.h"
13
14extern int perf_pmu_lex (void);
15
16#define ABORT_ON(val) \
17do { \
18 if (val) \
19 YYABORT; \
20} while (0)
21
22%}
23
24%token PP_CONFIG PP_CONFIG1 PP_CONFIG2
25%token PP_VALUE PP_ERROR
26%type <num> PP_VALUE
27%type <bits> bit_term
28%type <bits> bits
29
30%union
31{
32 unsigned long num;
33 DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
34}
35
36%%
37
38format:
39format format_term
40|
41format_term
42
43format_term:
44PP_CONFIG ':' bits
45{
46 ABORT_ON(perf_pmu__new_format(format, name,
47 PERF_PMU_FORMAT_VALUE_CONFIG,
48 $3));
49}
50|
51PP_CONFIG1 ':' bits
52{
53 ABORT_ON(perf_pmu__new_format(format, name,
54 PERF_PMU_FORMAT_VALUE_CONFIG1,
55 $3));
56}
57|
58PP_CONFIG2 ':' bits
59{
60 ABORT_ON(perf_pmu__new_format(format, name,
61 PERF_PMU_FORMAT_VALUE_CONFIG2,
62 $3));
63}
64
65bits:
66bits ',' bit_term
67{
68 bitmap_or($$, $1, $3, 64);
69}
70|
71bit_term
72{
73 memcpy($$, $1, sizeof($1));
74}
75
76bit_term:
77PP_VALUE '-' PP_VALUE
78{
79 perf_pmu__set_format($$, $1, $3);
80}
81|
82PP_VALUE
83{
84 perf_pmu__set_format($$, $1, 0);
85}
86
87%%
88
89void perf_pmu_error(struct list_head *list __used,
90 char *name __used,
91 char const *msg __used)
92{
93}
diff --git a/tools/perf/util/ui/browser.h b/tools/perf/util/ui/browser.h
index 84d761b730c1..6ee82f60feaf 100644
--- a/tools/perf/util/ui/browser.h
+++ b/tools/perf/util/ui/browser.h
@@ -49,6 +49,8 @@ int ui_browser__warning(struct ui_browser *browser, int timeout,
49 const char *format, ...); 49 const char *format, ...);
50int ui_browser__help_window(struct ui_browser *browser, const char *text); 50int ui_browser__help_window(struct ui_browser *browser, const char *text);
51bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text); 51bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text);
52int ui_browser__input_window(const char *title, const char *text, char *input,
53 const char *exit_msg, int delay_sec);
52 54
53void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence); 55void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence);
54unsigned int ui_browser__argv_refresh(struct ui_browser *browser); 56unsigned int ui_browser__argv_refresh(struct ui_browser *browser);
diff --git a/tools/perf/util/ui/browsers/hists.c b/tools/perf/util/ui/browsers/hists.c
index de8ece8bcce3..c4173c9733bb 100644
--- a/tools/perf/util/ui/browsers/hists.c
+++ b/tools/perf/util/ui/browsers/hists.c
@@ -879,6 +879,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
879 char *options[16]; 879 char *options[16];
880 int nr_options = 0; 880 int nr_options = 0;
881 int key = -1; 881 int key = -1;
882 char buf[64];
882 883
883 if (browser == NULL) 884 if (browser == NULL)
884 return -1; 885 return -1;
@@ -933,6 +934,16 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
933 goto zoom_dso; 934 goto zoom_dso;
934 case 't': 935 case 't':
935 goto zoom_thread; 936 goto zoom_thread;
937 case 's':
938 if (ui_browser__input_window("Symbol to show",
939 "Please enter the name of symbol you want to see",
940 buf, "ENTER: OK, ESC: Cancel",
941 delay_secs * 2) == K_ENTER) {
942 self->symbol_filter_str = *buf ? buf : NULL;
943 hists__filter_by_symbol(self);
944 hist_browser__reset(browser);
945 }
946 continue;
936 case K_F1: 947 case K_F1:
937 case 'h': 948 case 'h':
938 case '?': 949 case '?':
@@ -950,7 +961,8 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
950 "C Collapse all callchains\n" 961 "C Collapse all callchains\n"
951 "E Expand all callchains\n" 962 "E Expand all callchains\n"
952 "d Zoom into current DSO\n" 963 "d Zoom into current DSO\n"
953 "t Zoom into current Thread"); 964 "t Zoom into current Thread\n"
965 "s Filter symbol by name");
954 continue; 966 continue;
955 case K_ENTER: 967 case K_ENTER:
956 case K_RIGHT: 968 case K_RIGHT:
diff --git a/tools/perf/util/ui/keysyms.h b/tools/perf/util/ui/keysyms.h
index 3458b1985761..809eca5707fa 100644
--- a/tools/perf/util/ui/keysyms.h
+++ b/tools/perf/util/ui/keysyms.h
@@ -16,6 +16,8 @@
16#define K_TAB '\t' 16#define K_TAB '\t'
17#define K_UNTAB SL_KEY_UNTAB 17#define K_UNTAB SL_KEY_UNTAB
18#define K_UP SL_KEY_UP 18#define K_UP SL_KEY_UP
19#define K_BKSPC 0x7f
20#define K_DEL SL_KEY_DELETE
19 21
20/* Not really keys */ 22/* Not really keys */
21#define K_TIMER -1 23#define K_TIMER -1
diff --git a/tools/perf/util/ui/util.c b/tools/perf/util/ui/util.c
index 45daa7c41dad..ad4374a16bb0 100644
--- a/tools/perf/util/ui/util.c
+++ b/tools/perf/util/ui/util.c
@@ -69,6 +69,88 @@ int ui__popup_menu(int argc, char * const argv[])
69 return popup_menu__run(&menu); 69 return popup_menu__run(&menu);
70} 70}
71 71
72int ui_browser__input_window(const char *title, const char *text, char *input,
73 const char *exit_msg, int delay_secs)
74{
75 int x, y, len, key;
76 int max_len = 60, nr_lines = 0;
77 static char buf[50];
78 const char *t;
79
80 t = text;
81 while (1) {
82 const char *sep = strchr(t, '\n');
83
84 if (sep == NULL)
85 sep = strchr(t, '\0');
86 len = sep - t;
87 if (max_len < len)
88 max_len = len;
89 ++nr_lines;
90 if (*sep == '\0')
91 break;
92 t = sep + 1;
93 }
94
95 max_len += 2;
96 nr_lines += 8;
97 y = SLtt_Screen_Rows / 2 - nr_lines / 2;
98 x = SLtt_Screen_Cols / 2 - max_len / 2;
99
100 SLsmg_set_color(0);
101 SLsmg_draw_box(y, x++, nr_lines, max_len);
102 if (title) {
103 SLsmg_gotorc(y, x + 1);
104 SLsmg_write_string((char *)title);
105 }
106 SLsmg_gotorc(++y, x);
107 nr_lines -= 7;
108 max_len -= 2;
109 SLsmg_write_wrapped_string((unsigned char *)text, y, x,
110 nr_lines, max_len, 1);
111 y += nr_lines;
112 len = 5;
113 while (len--) {
114 SLsmg_gotorc(y + len - 1, x);
115 SLsmg_write_nstring((char *)" ", max_len);
116 }
117 SLsmg_draw_box(y++, x + 1, 3, max_len - 2);
118
119 SLsmg_gotorc(y + 3, x);
120 SLsmg_write_nstring((char *)exit_msg, max_len);
121 SLsmg_refresh();
122
123 x += 2;
124 len = 0;
125 key = ui__getch(delay_secs);
126 while (key != K_TIMER && key != K_ENTER && key != K_ESC) {
127 if (key == K_BKSPC) {
128 if (len == 0)
129 goto next_key;
130 SLsmg_gotorc(y, x + --len);
131 SLsmg_write_char(' ');
132 } else {
133 buf[len] = key;
134 SLsmg_gotorc(y, x + len++);
135 SLsmg_write_char(key);
136 }
137 SLsmg_refresh();
138
139 /* XXX more graceful overflow handling needed */
140 if (len == sizeof(buf) - 1) {
141 ui_helpline__push("maximum size of symbol name reached!");
142 key = K_ENTER;
143 break;
144 }
145next_key:
146 key = ui__getch(delay_secs);
147 }
148
149 buf[len] = '\0';
150 strncpy(input, buf, len+1);
151 return key;
152}
153
72int ui__question_window(const char *title, const char *text, 154int ui__question_window(const char *title, const char *text,
73 const char *exit_msg, int delay_secs) 155 const char *exit_msg, int delay_secs)
74{ 156{
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-11 04:14:34 -0500