STRLCPY/LoggerPlusPlus

Filter parser improvements, error message improvements
Corey-Dean Arthur committed 5 years ago

d28daf75

1 parent 4fc55941

Revision indexing in progress... (symbol navigation in revisions will be accurate after indexed)

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/logfilter/LogFilterController.java

		skipped 3 lines
4	4		import com.coreyd97.BurpExtenderUtilities.HistoryField;
5	5		import com.coreyd97.BurpExtenderUtilities.Preferences;
6	6		import com.nccgroup.loggerplusplus.LoggerPlusPlus;
7		-	import com.nccgroup.loggerplusplus.logentry.FieldGroup;
8		-	import com.nccgroup.loggerplusplus.util.Globals;
9	7		import com.nccgroup.loggerplusplus.filter.parser.ParseException;
	8	+	import com.nccgroup.loggerplusplus.logentry.FieldGroup;
10	9		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
	10	+	import com.nccgroup.loggerplusplus.util.Globals;
11	11
12	12		import javax.swing.*;
13	13		import java.awt.*;
		skipped 8 lines
22	22		private final ArrayList<LogFilterListener> logFilterListeners;
23	23		private String currentFilterString;
24	24
25		-	public LogFilterController(Preferences preferences){
	25	+	public LogFilterController(Preferences preferences) {
26	26		this.logFilterListeners = new ArrayList<>();
27	27		this.filterField = buildFilterField(preferences);
28	28		this.fieldMenu = buildFieldMenu();
29	29		}
30	30
31		-	private HistoryField buildFilterField(Preferences preferences){
	31	+	private HistoryField buildFilterField(Preferences preferences) {
32	32		HistoryField filterField = new HistoryField(preferences, Globals.PREF_FILTER_HISTORY, 15);
33	33
34	34		filterField.getEditor().getEditorComponent().addKeyListener(new KeyAdapter() {
35	35		@Override
36	36		public void keyPressed(KeyEvent e) {
37		-	if(e.getKeyChar() == KeyEvent.VK_ENTER){
	37	+	if (e.getKeyChar() == KeyEvent.VK_ENTER) {
38	38		//Update only when pressing enter after typing
39	39		setFilter((String) filterField.getEditor().getItem());
40	40		filterField.getRootPane().requestFocus(true);
		skipped 4 lines
45	45		filterField.getEditor().getEditorComponent().addMouseListener(new MouseAdapter() {
46	46		@Override
47	47		public void mouseClicked(MouseEvent e) {
48		-	if(SwingUtilities.isRightMouseButton(e)){
	48	+	if (SwingUtilities.isRightMouseButton(e)) {
49	49		fieldMenu.show(filterField, e.getX(), e.getY());
50	50		}
51	51		}
		skipped 2 lines
54	54		//Update when clicking an item in the list, but not when using arrow keys to move
55	55		filterField.addActionListener(e -> {
56	56		//Only update from clicking the mouse
57		-	if((e.getModifiers() & (ActionEvent.MOUSE_EVENT_MASK \| ActionEvent.FOCUS_EVENT_MASK)) != 0) {
	57	+	if ((e.getModifiers() & (ActionEvent.MOUSE_EVENT_MASK \| ActionEvent.FOCUS_EVENT_MASK)) != 0) {
58	58		setFilter((String) filterField.getSelectedItem());
59	59		}
60	60		});
		skipped 1 lines
62	62		return filterField;
63	63		}
64	64
65		-	private JPopupMenu buildFieldMenu(){
	65	+	private JPopupMenu buildFieldMenu() {
66	66		JTextField editor = (JTextField) filterField.getEditor().getEditorComponent();
67	67
68	68		JPopupMenu autoComplete = new JPopupMenu();
		skipped 10 lines
79	79		String end = editor.getText().substring(pos);
80	80		String fieldLabel = field.getFullLabel();
81	81		editor.setText(start + fieldLabel + end);
82		-	editor.setCaretPosition(pos+fieldLabel.length());
	82	+	editor.setCaretPosition(pos + fieldLabel.length());
83	83		});
84	84		groupMenus.get(field.getFieldGroup()).add(fieldItem);
85	85		}
		skipped 5 lines
91	91		return autoComplete;
92	92		}
93	93
94		-	public void addFilterListener(LogFilterListener logFilterListener){
	94	+	public void addFilterListener(LogFilterListener logFilterListener) {
95	95		this.logFilterListeners.add(logFilterListener);
96	96		}
97	97
98		-	public void removeFilterListener(LogFilterListener logFilterListener){
	98	+	public void removeFilterListener(LogFilterListener logFilterListener) {
99	99		this.logFilterListeners.remove(logFilterListener);
100	100		}
101	101
102		-	public void setFilter(final String filterString){
103		-	SwingUtilities.invokeLater(() -> {
	102	+	public void setFilter(final String filterString) {
	103	+	SwingUtilities.invokeLater(() -> {
104	104		if (filterString == null \|\| filterString.length() == 0 \|\| filterString.matches(" +")) {
105	105		setFilter((LogFilter) null);
106		-	}else{
	106	+	} else {
107	107		currentFilterString = filterString;
108	108		try {
109	109		LogFilter filter = new LogFilter(LoggerPlusPlus.instance.getLibraryController(), filterString);
		skipped 2 lines
112	112		for (LogFilterListener logFilterListener : logFilterListeners) {
113	113		try {
114	114		logFilterListener.onFilterError(filterString, e);
115		-	}catch (Exception e1){
	115	+	} catch (Exception e1) {
116	116		e1.printStackTrace();
117	117		}
118	118		}
	119	+
	120	+	JLabel header = new JLabel("Could not parse filter:");
	121	+	JTextArea errorArea = new JTextArea(e.getMessage());
	122	+	errorArea.setEditable(false);
	123	+
	124	+	JScrollPane errorScroller = new JScrollPane(errorArea);
	125	+	errorScroller.setBorder(BorderFactory.createEmptyBorder());
	126	+	JPanel wrapper = new JPanel(new BorderLayout());
	127	+	wrapper.add(errorScroller, BorderLayout.CENTER);
	128	+	wrapper.setPreferredSize(new Dimension(600, 300));
	129	+
119	130		JOptionPane.showMessageDialog(JOptionPane.getFrameForComponent(BurpExtender.instance.getUiComponent()),
120		-	"<html><body style='width: 400px; overflow-wrap: break-word;'>Could not parse filter:\n" + e.getMessage(), "Parse Error", JOptionPane.ERROR_MESSAGE);
	131	+	new Component[]{header, wrapper}, "Parse Error", JOptionPane.ERROR_MESSAGE);
	132	+
121	133		formatFilter(filterString, Color.WHITE, new Color(221, 70, 57));
122	134		}
123	135		}
124	136		});
125	137		}
126	138
127		-	public void clearFilter(){
	139	+	public void clearFilter() {
128	140		for (LogFilterListener logFilterListener : this.logFilterListeners) {
129	141		logFilterListener.onFilterCleared();
130	142		}
		skipped 1 lines
132	144		formatFilter("", null, null);
133	145		}
134	146
135		-	private void setFilter(LogFilter filter){
	147	+	private void setFilter(LogFilter filter) {
136	148		if (filter == null) {
137	149		clearFilter();
138	150		} else {
139	151		String filterString = filter.toString();
140		-	formatFilter(filterString, Color.BLACK, new Color(76,255, 155));
	152	+	formatFilter(filterString, Color.BLACK, new Color(76, 255, 155));
141	153
142		-	new Thread(()->{
	154	+	new Thread(() -> {
143	155		for (LogFilterListener logFilterListener : logFilterListeners) {
144	156		logFilterListener.onFilterSet(filter);
145	157		}
		skipped 1 lines
147	159		}
148	160		}
149	161
150		-	public void formatFilter(String string, Color foregroundColor, Color backgroundColor){
	162	+	public void formatFilter(String string, Color foregroundColor, Color backgroundColor) {
151	163		SwingUtilities.invokeLater(() -> {
152		-	if(!string.equalsIgnoreCase("")) {
	164	+	if (!string.equalsIgnoreCase("")) {
153	165		((HistoryField.HistoryComboModel) filterField.getModel()).addToHistory(string);
154	166		filterField.setSelectedItem(string);
155		-	}else{
	167	+	} else {
156	168		filterField.setSelectedItem(null);
157	169		}
158	170		filterField.setForegroundColor(foregroundColor);
		skipped 1 lines
160	172		});
161	173		}
162	174
163		-	public HistoryField getFilterField(){
	175	+	public HistoryField getFilterField() {
164	176		return this.filterField;
165	177		}
166	178		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/ASTComparison.java

		skipped 3 lines
4	4
5	5		import com.nccgroup.loggerplusplus.filter.Operator;
6	6		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
	7	+	import org.apache.commons.text.StringEscapeUtils;
7	8
8	9		import java.util.Set;
9	10		import java.util.regex.Pattern;
		skipped 37 lines
47	48		if(operator == Operator.MATCHES) return "\"" + String.valueOf(obj) + "\"";
48	49		else return "/" + String.valueOf(obj) + "/";
49	50		}else if(obj instanceof String){
50		-	return "\"" + obj + "\"";
	51	+	return "\"" + StringEscapeUtils.escapeJava((String) obj) + "\"";
51	52		}else if(obj instanceof Set){
52	53		StringBuilder sb = new StringBuilder();
53	54		sb.append("[");
		skipped 13 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/Filter.jj

		skipped 5 lines
6	6
7	7
8	8
9		-	// DEBUG_PARSER = true;
	9	+	DEBUG_PARSER = true;
10	10		}
11	11
12	12		PARSER_BEGIN(FilterParser)
13	13		package com.nccgroup.loggerplusplus.filter.parser;
14	14		import com.nccgroup.loggerplusplus.filter.BooleanOperator;
15	15		import com.nccgroup.loggerplusplus.filter.Operator;import com.nccgroup.loggerplusplus.filterlibrary.FilterLibraryController;
16		-	import java.io.IOException;
17	16		import java.io.StringReader;
18	17		import java.math.BigDecimal;
19	18		import java.util.Arrays;
20	19		import java.util.LinkedHashSet;
21	20		import java.util.Set;
	21	+	import java.util.ArrayList;
22	22		import java.util.regex.Pattern;
23	23		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
24	24		import com.nccgroup.loggerplusplus.logentry.FieldGroup;
	25	+	import static com.nccgroup.loggerplusplus.logentry.LogEntryField.getFieldsInGroup;
25	26
26	27		public class FilterParser/@bgen(jjtree)/implements FilterParserTreeConstants/@egen/ {/@bgen(jjtree)/
27	28		protected JJTFilterParserState jjtree = new JJTFilterParserState();
		skipped 39 lines
67	68		\| <CONTAINS: "CONTAINS" >
68	69		\| <IN: "IN" >
69	70		\| <BOOLEAN: "TRUE" \| "FALSE">
70		-	\| <SINGLEQUOTEDSTRING: "'" ("\\" ~[] \| ~["\'", "\\"])* "'" >
71		-	\| <DOUBLEQUOTEDSTRING: "\"" ("\\" ~[] \| ~["\"", "\\"])* "\"" >
72	71		\| <NUMBER: ("-"\|"+")?(<DIGIT>)+("."(<DIGIT>)+)?>
73	72		\| <DIGIT: ["0"-"9"] >
74	73		\| <REGEXLITERAL_IN_FORWARD_SLASHES: "/\\Q" ("\\" ~["E"] \| ~["\\"])* "\\E/" >
		skipped 8 lines
83	82		\| <ARRAY_END: "]" >
84	83		\| <ARRAY_SEPARATOR: ",">
85	84		\| <ALIAS_SYMBOL: "#">
	85	+	\| <OPEN_SINGLE_QUOTE_STRING: "'" >: SINGLE_QUOTED_STRING
	86	+	\| <OPEN_DOUBLE_QUOTE_STRING: "\"" >: DOUBLE_QUOTED_STRING
86	87		}
	88	+
	89	+	<SINGLE_QUOTED_STRING> TOKEN: {
	90	+	<SINGLE_STRING_BODY: ("\\" ~[] \| ~["\'", "\\"])+>
	91	+	\| <CLOSE_SINGLE_QUOTE_STRING: "'">: DEFAULT
	92	+	}
	93	+
	94	+	<DOUBLE_QUOTED_STRING> TOKEN: {
	95	+	<DOUBLE_STRING_BODY: ("\\" ~[] \| ~["\"", "\\"])+>
	96	+	\| <CLOSE_DOUBLE_QUOTE_STRING: "\"">: DEFAULT
	97	+	}
	98	+
	99	+	<*> TOKEN : { <UNKNOWN: ~[]> }
87	100
88	101		ASTExpression Filter() :
89	102		{
		skipped 104 lines
194	207		{/@bgen(jjtree) Comparison /
195	208		try {
196	209		/@egen/
197		-	(LOOKAHEAD(3) left = Identifier() \| {throw new ParseException("The left side of a comparison must be a field identifier.");})
	210	+	(left = Identifier() \| {throw new ParseException("The left side of a comparison must be a field identifier.");})
198	211
199	212		(
200	213		op = EqualityOperator() (
		skipped 1 lines
202	215		\|
203	216		{throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
204	217		)
	218	+
	219	+	{
	220	+	if(right instanceof Pattern && !String.class.isAssignableFrom(((LogEntryField) left).getType())){
	221	+	throw new ParseException(String.format("Regex patterns can only be used on fields which can be converted to a string. Field \"%s\" of type \"%s\" cannot be converted.", left, ((LogEntryField) left).getType()));
	222	+	}
	223	+	}
	224	+
205	225		\|
206	226		op = NumericOperator()
207	227		{
		skipped 118 lines
326	346		\|
327	347		v = Boolean()
328	348		\|
329		-	LOOKAHEAD(2) v = String()
	349	+	v = String()
330	350		\|
331	351		v = RegexInForwardSlashes()
332		-	\|
333		-	v = RegexInString()
334	352		)
335	353		{return v;}
336	354		}
		skipped 32 lines
369	387		{
370	388		fieldGroup = FieldGroup.findByLabel(group.image);
371	389		if(fieldGroup == null)
372		-	throw new ParseException(String.format("Invalid field group \"%s\". Valid groups are: %s", group.image, Arrays.toString(FieldGroup.values())));
	390	+	throw new ParseException(String.format("Invalid field group \"%s\". Valid groups are:\n%s", group.image, Arrays.toString(FieldGroup.values())));
373	391		}
374	392		<DOT>
375	393		identifier=<IDENTIFIER>
376	394		{
377	395		field = LogEntryField.getByLabel(fieldGroup, identifier.image);
378		-	if(field == null)
379		-	throw new ParseException(String.format("Invalid field \"%s\". Valid fields for group \"%s\" are: %s", identifier.image, fieldGroup, LogEntryField.getFieldsInGroup(fieldGroup).values()));
	396	+	if(field == null){
	397	+	StringBuilder fieldMessage = new StringBuilder();
	398	+	ArrayList<LogEntryField> fields = new ArrayList<LogEntryField>(getFieldsInGroup(FieldGroup.REQUEST));
	399	+	for (int i = 0; i < fields.size(); i++) {
	400	+	fieldMessage.append(fields.get(i).getDescriptiveMessage());
	401	+	if(i != fields.size()-1)
	402	+	fieldMessage.append("\n\n");
	403	+	}
	404	+	throw new ParseException(String.format("Invalid field \"%s\". Valid fields for group \"%s\" are:\n%s", identifier.image, fieldGroup, fieldMessage));
	405	+	}
380	406		if(field == LogEntryField.NUMBER)
381	407		throw new ParseException("Field " + LogEntryField.NUMBER + " is ephemeral and cannot be used in filters.");
382	408		return field;
		skipped 13 lines
396	422		}
397	423
398	424		String String() :
399		-	{Token t;}
	425	+	{Token t = null;}
400	426		{
401		-	( t=<SINGLEQUOTEDSTRING> \| t=<DOUBLEQUOTEDSTRING> )
	427	+
	428	+	(
	429	+	<OPEN_SINGLE_QUOTE_STRING>
	430	+	[t=<SINGLE_STRING_BODY>]
	431	+	(
	432	+	<CLOSE_SINGLE_QUOTE_STRING>
	433	+	\|
	434	+	{throw new ParseException("Missing closing quote for string.");}
	435	+	)
	436	+	\|
	437	+	<OPEN_DOUBLE_QUOTE_STRING>
	438	+	[t=<DOUBLE_STRING_BODY>]
	439	+	(
	440	+	<CLOSE_DOUBLE_QUOTE_STRING>
	441	+	\|
	442	+	{throw new ParseException("Missing closing quote for string.");}
	443	+	)
	444	+	)
402	445
403	446		{
404		-	String s = t.image.substring(1,t.image.length()-1);
405		-	return org.apache.commons.text.StringEscapeUtils.unescapeJava(s);
	447	+	if(t == null) return "";
	448	+	else return org.apache.commons.text.StringEscapeUtils.unescapeJava(t.image);
406	449		}
407	450		}
408	451
409	452		Pattern RegexInString() :
410	453		{Token t;}
411	454		{
412		-	( t=<DOUBLEQUOTEDSTRING> \| t=<SINGLEQUOTEDSTRING> )
	455	+	(
	456	+	<OPEN_SINGLE_QUOTE_STRING>
	457	+	t=<SINGLE_STRING_BODY>
	458	+	(
	459	+	<CLOSE_SINGLE_QUOTE_STRING>
	460	+	\|
	461	+	{throw new ParseException("Missing closing quote for regex string.");}
	462	+	)
	463	+	\|
	464	+	<OPEN_DOUBLE_QUOTE_STRING>
	465	+	t=<DOUBLE_STRING_BODY>
	466	+	(
	467	+	<CLOSE_DOUBLE_QUOTE_STRING>
	468	+	\|
	469	+	{throw new ParseException("Missing closing quote for regex string.");}
	470	+	)
	471	+	)
413	472		{
414		-	return Pattern.compile(t.image.substring(1,t.image.length()-1), Pattern.CASE_INSENSITIVE);
	473	+	return Pattern.compile(t.image, Pattern.CASE_INSENSITIVE);
415	474		}
416	475		}
417	476
		skipped 81 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/Filter.jjt

		skipped 4 lines
5	5		// VISITOR_RETURN_TYPE="VisitorData";
6	6		VISITOR_DATA_TYPE="VisitorData";
7	7		NODE_DEFAULT_VOID=true;
8		-	// DEBUG_PARSER = true;
	8	+	DEBUG_PARSER = true;
9	9		}
10	10
11	11		PARSER_BEGIN(FilterParser)
12	12		package com.nccgroup.loggerplusplus.filter.parser;
13	13		import com.nccgroup.loggerplusplus.filter.BooleanOperator;
14	14		import com.nccgroup.loggerplusplus.filter.Operator;import com.nccgroup.loggerplusplus.filterlibrary.FilterLibraryController;
15		-	import java.io.IOException;
16	15		import java.io.StringReader;
17	16		import java.math.BigDecimal;
18	17		import java.util.Arrays;
19	18		import java.util.LinkedHashSet;
20	19		import java.util.Set;
	20	+	import java.util.ArrayList;
21	21		import java.util.regex.Pattern;
22	22		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
23	23		import com.nccgroup.loggerplusplus.logentry.FieldGroup;
	24	+	import static com.nccgroup.loggerplusplus.logentry.LogEntryField.getFieldsInGroup;
24	25
25	26		public class FilterParser {
26	27
		skipped 36 lines
63	64		\| <CONTAINS: "CONTAINS" >
64	65		\| <IN: "IN" >
65	66		\| <BOOLEAN: "TRUE" \| "FALSE">
66		-	\| <SINGLEQUOTEDSTRING: "'" ("\\" ~[] \| ~["\'", "\\"])* "'" >
67		-	\| <DOUBLEQUOTEDSTRING: "\"" ("\\" ~[] \| ~["\"", "\\"])* "\"" >
68	67		\| <NUMBER: ("-"\|"+")?(<DIGIT>)+("."(<DIGIT>)+)?>
69	68		\| <DIGIT: ["0"-"9"] >
70	69		\| <REGEXLITERAL_IN_FORWARD_SLASHES: "/\\Q" ("\\" ~["E"] \| ~["\\"])* "\\E/" >
		skipped 8 lines
79	78		\| <ARRAY_END: "]" >
80	79		\| <ARRAY_SEPARATOR: ",">
81	80		\| <ALIAS_SYMBOL: "#">
	81	+	\| <OPEN_SINGLE_QUOTE_STRING: "'" >: SINGLE_QUOTED_STRING
	82	+	\| <OPEN_DOUBLE_QUOTE_STRING: "\"" >: DOUBLE_QUOTED_STRING
82	83		}
83	84
	85	+	<SINGLE_QUOTED_STRING> TOKEN: {
	86	+	<SINGLE_STRING_BODY: ("\\" ~[] \| ~["\'", "\\"])+>
	87	+	\| <CLOSE_SINGLE_QUOTE_STRING: "'">: DEFAULT
	88	+	}
	89	+
	90	+	<DOUBLE_QUOTED_STRING> TOKEN: {
	91	+	<DOUBLE_STRING_BODY: ("\\" ~[] \| ~["\"", "\\"])+>
	92	+	\| <CLOSE_DOUBLE_QUOTE_STRING: "\"">: DEFAULT
	93	+	}
	94	+
	95	+	<*> TOKEN : { <UNKNOWN: ~[]> }
	96	+
84	97		ASTExpression Filter() #void :
85	98		{
86	99		ASTExpression ex;
		skipped 66 lines
153	166		Object left, right = true;
154	167		}
155	168		{
156		-	(LOOKAHEAD(3) left = Identifier() \| {throw new ParseException("The left side of a comparison must be a field identifier.");})
	169	+	(left = Identifier() \| {throw new ParseException("The left side of a comparison must be a field identifier.");})
157	170
158	171		(
159	172		op = EqualityOperator() (
		skipped 1 lines
161	174		\|
162	175		{throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
163	176		)
	177	+
	178	+	{
	179	+	if(right instanceof Pattern && !String.class.isAssignableFrom(((LogEntryField) left).getType())){
	180	+	throw new ParseException(String.format("Regex patterns can only be used on fields which can be converted to a string. Field \"%s\" of type \"%s\" cannot be converted.", left, ((LogEntryField) left).getType()));
	181	+	}
	182	+	}
	183	+
164	184		\|
165	185		op = NumericOperator()
166	186		{
		skipped 76 lines
243	263		\|
244	264		v = Boolean()
245	265		\|
246		-	LOOKAHEAD(2) v = String()
	266	+	v = String()
247	267		\|
248	268		v = RegexInForwardSlashes()
249		-	\|
250		-	v = RegexInString()
251	269		)
252	270		{return v;}
253	271		}
		skipped 32 lines
286	304		{
287	305		fieldGroup = FieldGroup.findByLabel(group.image);
288	306		if(fieldGroup == null)
289		-	throw new ParseException(String.format("Invalid field group \"%s\". Valid groups are: %s", group.image, Arrays.toString(FieldGroup.values())));
	307	+	throw new ParseException(String.format("Invalid field group \"%s\". Valid groups are:\n%s", group.image, Arrays.toString(FieldGroup.values())));
290	308		}
291	309		<DOT>
292	310		identifier=<IDENTIFIER>
293	311		{
294	312		field = LogEntryField.getByLabel(fieldGroup, identifier.image);
295		-	if(field == null)
296		-	throw new ParseException(String.format("Invalid field \"%s\". Valid fields for group \"%s\" are: %s", identifier.image, fieldGroup, LogEntryField.getFieldsInGroup(fieldGroup).values()));
	313	+	if(field == null){
	314	+	StringBuilder fieldMessage = new StringBuilder();
	315	+	ArrayList<LogEntryField> fields = new ArrayList<LogEntryField>(getFieldsInGroup(FieldGroup.REQUEST));
	316	+	for (int i = 0; i < fields.size(); i++) {
	317	+	fieldMessage.append(fields.get(i).getDescriptiveMessage());
	318	+	if(i != fields.size()-1)
	319	+	fieldMessage.append("\n\n");
	320	+	}
	321	+	throw new ParseException(String.format("Invalid field \"%s\". Valid fields for group \"%s\" are:\n%s", identifier.image, fieldGroup, fieldMessage));
	322	+	}
297	323		if(field == LogEntryField.NUMBER)
298	324		throw new ParseException("Field " + LogEntryField.NUMBER + " is ephemeral and cannot be used in filters.");
299	325		return field;
		skipped 13 lines
313	339		}
314	340
315	341		String String() #void :
316		-	{Token t;}
	342	+	{Token t = null;}
317	343		{
318		-	( t=<SINGLEQUOTEDSTRING> \| t=<DOUBLEQUOTEDSTRING> )
	344	+
	345	+	(
	346	+	<OPEN_SINGLE_QUOTE_STRING>
	347	+	[t=<SINGLE_STRING_BODY>]
	348	+	(
	349	+	<CLOSE_SINGLE_QUOTE_STRING>
	350	+	\|
	351	+	{throw new ParseException("Missing closing quote for string.");}
	352	+	)
	353	+	\|
	354	+	<OPEN_DOUBLE_QUOTE_STRING>
	355	+	[t=<DOUBLE_STRING_BODY>]
	356	+	(
	357	+	<CLOSE_DOUBLE_QUOTE_STRING>
	358	+	\|
	359	+	{throw new ParseException("Missing closing quote for string.");}
	360	+	)
	361	+	)
319	362
320	363		{
321		-	String s = t.image.substring(1,t.image.length()-1);
322		-	return org.apache.commons.text.StringEscapeUtils.unescapeJava(s);
	364	+	if(t == null) return "";
	365	+	else return org.apache.commons.text.StringEscapeUtils.unescapeJava(t.image);
323	366		}
324	367		}
325	368
326	369		Pattern RegexInString() #void :
327	370		{Token t;}
328	371		{
329		-	( t=<DOUBLEQUOTEDSTRING> \| t=<SINGLEQUOTEDSTRING> )
	372	+	(
	373	+	<OPEN_SINGLE_QUOTE_STRING>
	374	+	t=<SINGLE_STRING_BODY>
	375	+	(
	376	+	<CLOSE_SINGLE_QUOTE_STRING>
	377	+	\|
	378	+	{throw new ParseException("Missing closing quote for regex string.");}
	379	+	)
	380	+	\|
	381	+	<OPEN_DOUBLE_QUOTE_STRING>
	382	+	t=<DOUBLE_STRING_BODY>
	383	+	(
	384	+	<CLOSE_DOUBLE_QUOTE_STRING>
	385	+	\|
	386	+	{throw new ParseException("Missing closing quote for regex string.");}
	387	+	)
	388	+	)
330	389		{
331		-	return Pattern.compile(t.image.substring(1,t.image.length()-1), Pattern.CASE_INSENSITIVE);
	390	+	return Pattern.compile(t.image, Pattern.CASE_INSENSITIVE);
332	391		}
333	392		}
334	393
		skipped 81 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/FilterParser.java

		skipped 2 lines
3	3		package com.nccgroup.loggerplusplus.filter.parser;
4	4		import com.nccgroup.loggerplusplus.filter.BooleanOperator;
5	5		import com.nccgroup.loggerplusplus.filter.Operator;import com.nccgroup.loggerplusplus.filterlibrary.FilterLibraryController;
6		-	import java.io.IOException;
7	6		import java.io.StringReader;
8	7		import java.math.BigDecimal;
9	8		import java.util.Arrays;
10	9		import java.util.LinkedHashSet;
11	10		import java.util.Set;
	11	+	import java.util.ArrayList;
12	12		import java.util.regex.Pattern;
13	13		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
14	14		import com.nccgroup.loggerplusplus.logentry.FieldGroup;
	15	+	import static com.nccgroup.loggerplusplus.logentry.LogEntryField.getFieldsInGroup;
15	16
16	17		public class FilterParser/@bgen(jjtree)/implements FilterParserTreeConstants, FilterParserConstants {/@bgen(jjtree)/
17	18		protected JJTFilterParserState jjtree = new JJTFilterParserState();
		skipped 19 lines
37	38		throw new ParseException(String.format("Cannot mix operators %s, %s. Please use parenthesis to remove ambiguity.", op.getLabel(), other.getLabel()));
38	39		}
39	40
40		-	final public ASTExpression Filter() throws ParseException {ASTExpression ex;
41		-	ex = Expression(false);
42		-	jj_consume_token(0);
	41	+	final public ASTExpression Filter() throws ParseException { try {
	42	+	ASTExpression ex;
	43	+	ex = Expression(false);
	44	+	jj_consume_token(0);
43	45		{if ("" != null) return ex;}
44	46		throw new Error("Missing return statement in function");
	47	+	} finally {
	48	+	trace_return("Filter");
	49	+	}
45	50		}
46	51
47		-	final public ASTExpression Expression(boolean inverse) throws ParseException {/@bgen(jjtree) Expression /
	52	+	final public ASTExpression Expression(boolean inverse) throws ParseException { try {
	53	+	/@bgen(jjtree) Expression /
48	54		ASTExpression jjtn000 = new ASTExpression(JJTEXPRESSION);
49	55		boolean jjtc000 = true;
50	56		jjtree.openNodeScope(jjtn000);BooleanOperator op = null;
51		-	try {
52		-	ExpressionInner();
53		-	if (jj_2_1(2)) {
54		-	op = ExpressionCompounding();
55		-	} else {
56		-	;
57		-	}
	57	+	try {
	58	+	ExpressionInner();
	59	+	if (jj_2_1(2)) {
	60	+	op = ExpressionCompounding();
	61	+	} else {
	62	+	;
	63	+	}
58	64		jjtree.closeNodeScope(jjtn000, true);
59	65		jjtc000 = false;
60	66		jjtn000.op = op;
61	67		jjtn000.inverse = inverse;
62	68		{if ("" != null) return jjtn000;}
63		-	} catch (Throwable jjte000) {
	69	+	} catch (Throwable jjte000) {
64	70		if (jjtc000) {
65	71		jjtree.clearNodeScope(jjtn000);
66	72		jjtc000 = false;
		skipped 7 lines
74	80		{if (true) throw (ParseException)jjte000;}
75	81		}
76	82		{if (true) throw (Error)jjte000;}
77		-	} finally {
	83	+	} finally {
78	84		if (jjtc000) {
79	85		jjtree.closeNodeScope(jjtn000, true);
80	86		}
	87	+	}
	88	+	throw new Error("Missing return statement in function");
	89	+	} finally {
	90	+	trace_return("Expression");
81	91		}
82		-	throw new Error("Missing return statement in function");
83	92		}
84	93
85		-	final public void WrappedCompoundExpression() throws ParseException {boolean inverse=false;
86		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
87		-	case INVERSE:{
88		-	inverse = Inverse();
89		-	break;
	94	+	final public void WrappedCompoundExpression() throws ParseException { try {
	95	+	boolean inverse=false;
	96	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	97	+	case INVERSE:{
	98	+	inverse = Inverse();
	99	+	break;
	100	+	}
	101	+	default:
	102	+	jj_la1[0] = jj_gen;
	103	+	;
90	104		}
91		-	default:
92		-	jj_la1[0] = jj_gen;
93		-	;
94		-	}
95		-	jj_consume_token(LPAREN);
96		-	Expression(inverse);
97		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
98		-	case RPAREN:{
99		-	jj_consume_token(RPAREN);
100		-	break;
	105	+	jj_consume_token(LPAREN);
	106	+	Expression(inverse);
	107	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	108	+	case RPAREN:{
	109	+	jj_consume_token(RPAREN);
	110	+	break;
	111	+	}
	112	+	default:
	113	+	jj_la1[1] = jj_gen;
	114	+	{if (true) throw new ParseException("Unbalanced brackets.");}
101	115		}
102		-	default:
103		-	jj_la1[1] = jj_gen;
104		-	{if (true) throw new ParseException("Unbalanced brackets.");}
	116	+	} finally {
	117	+	trace_return("WrappedCompoundExpression");
105	118		}
106	119		}
107	120
108		-	final public void ExpressionInner() throws ParseException {
109		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
110		-	case LPAREN:
111		-	case INVERSE:{
112		-	WrappedCompoundExpression();
113		-	break;
	121	+	final public void ExpressionInner() throws ParseException { try {
	122	+
	123	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	124	+	case LPAREN:
	125	+	case INVERSE:{
	126	+	WrappedCompoundExpression();
	127	+	break;
	128	+	}
	129	+	default:
	130	+	jj_la1[2] = jj_gen;
	131	+	Statement();
114	132		}
115		-	default:
116		-	jj_la1[2] = jj_gen;
117		-	Statement();
	133	+	} finally {
	134	+	trace_return("ExpressionInner");
118	135		}
119	136		}
120	137
121		-	final public void Statement() throws ParseException {
122		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
123		-	case ALIAS_SYMBOL:{
124		-	Alias();
125		-	break;
	138	+	final public void Statement() throws ParseException { try {
	139	+
	140	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	141	+	case ALIAS_SYMBOL:{
	142	+	Alias();
	143	+	break;
	144	+	}
	145	+	default:
	146	+	jj_la1[3] = jj_gen;
	147	+	Comparison();
126	148		}
127		-	default:
128		-	jj_la1[3] = jj_gen;
129		-	Comparison();
	149	+	} finally {
	150	+	trace_return("Statement");
130	151		}
131	152		}
132	153
133		-	final public BooleanOperator ExpressionCompounding() throws ParseException {BooleanOperator op;
	154	+	final public BooleanOperator ExpressionCompounding() throws ParseException { try {
	155	+	BooleanOperator op;
134	156		BooleanOperator nextOp;
135		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
136		-	case AND:{
137		-	op = And();
138		-	break;
139		-	}
140		-	case OR:{
141		-	op = Or();
142		-	break;
143		-	}
144		-	case XOR:{
145		-	op = Xor();
146		-	break;
147		-	}
148		-	default:
149		-	jj_la1[4] = jj_gen;
150		-	jj_consume_token(-1);
151		-	throw new ParseException();
152		-	}
153		-	ExpressionInner();
154		-	label_1:
155		-	while (true) {
156		-	if (jj_2_2(2)) {
157		-	;
158		-	} else {
159		-	break label_1;
160		-	}
161	157		switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
162	158		case AND:{
163		-	nextOp = And();
	159	+	op = And();
164	160		break;
165	161		}
166	162		case OR:{
167		-	nextOp = Or();
	163	+	op = Or();
168	164		break;
169	165		}
170	166		case XOR:{
171		-	nextOp = Xor();
	167	+	op = Xor();
172	168		break;
173	169		}
174	170		default:
175		-	jj_la1[5] = jj_gen;
	171	+	jj_la1[4] = jj_gen;
176	172		jj_consume_token(-1);
177	173		throw new ParseException();
178	174		}
	175	+	ExpressionInner();
	176	+	label_1:
	177	+	while (true) {
	178	+	if (jj_2_2(2)) {
	179	+	;
	180	+	} else {
	181	+	break label_1;
	182	+	}
	183	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	184	+	case AND:{
	185	+	nextOp = And();
	186	+	break;
	187	+	}
	188	+	case OR:{
	189	+	nextOp = Or();
	190	+	break;
	191	+	}
	192	+	case XOR:{
	193	+	nextOp = Xor();
	194	+	break;
	195	+	}
	196	+	default:
	197	+	jj_la1[5] = jj_gen;
	198	+	jj_consume_token(-1);
	199	+	throw new ParseException();
	200	+	}
179	201		//Subsequent compoundings must be same operator. Otherwise, throw exception.
180	202		if(op != nextOp) throwOperatorAmbiguityException(op,nextOp);
181		-	ExpressionInner();
182		-	}
	203	+	ExpressionInner();
	204	+	}
183	205		{if ("" != null) return op;}
184	206		throw new Error("Missing return statement in function");
	207	+	} finally {
	208	+	trace_return("ExpressionCompounding");
	209	+	}
185	210		}
186	211
187	212		//Comparisons can take two forms (Value) or (value operation value).
188	213		//To make interpretation easier, we convert (Value) to (Value operation value) by means of (Value EQUALS TRUE)
189		-	final public void Comparison() throws ParseException {/@bgen(jjtree) Comparison /
	214	+	final public void Comparison() throws ParseException { try {
	215	+	/@bgen(jjtree) Comparison /
190	216		ASTComparison jjtn000 = new ASTComparison(JJTCOMPARISON);
191	217		boolean jjtc000 = true;
192	218		jjtree.openNodeScope(jjtn000);Operator op = Operator.EQUAL;
193	219		Object left, right = true;
194		-	try {
195		-	if (jj_2_3(3)) {
196		-	left = Identifier();
197		-	} else {
198		-	{if (true) throw new ParseException("The left side of a comparison must be a field identifier.");}
199		-	}
200		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
201		-	case EQ:
202		-	case NEQ:{
203		-	op = EqualityOperator();
	220	+	try {
204	221		switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
205		-	case BOOLEAN:
206		-	case SINGLEQUOTEDSTRING:
207		-	case DOUBLEQUOTEDSTRING:
208		-	case NUMBER:
209		-	case REGEXLITERAL_IN_FORWARD_SLASHES:
210		-	case REGEX_IN_FORWARD_SLASHES:
211		-	case INVERSE:
212	222		case IDENTIFIER:{
213		-	right = Value();
	223	+	left = Identifier();
214	224		break;
215	225		}
216	226		default:
217	227		jj_la1[6] = jj_gen;
218		-	{if (true) throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
	228	+	{if (true) throw new ParseException("The left side of a comparison must be a field identifier.");}
219	229		}
220		-	break;
221		-	}
222		-	case GT:
223		-	case LT:
224		-	case GEQ:
225		-	case LEQ:{
226		-	op = NumericOperator();
227		-	if(!Number.class.isAssignableFrom(((LogEntryField) left).getType())){
228		-	{if (true) throw new ParseException(String.format("Numeric operators cannot be used for field \"%s\" of type \"%s\"", left, ((LogEntryField) left).getType()));}
229		-	}
230	230		switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
231		-	case NUMBER:{
232		-	right = Number();
	231	+	case EQ:
	232	+	case NEQ:{
	233	+	op = EqualityOperator();
	234	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	235	+	case BOOLEAN:
	236	+	case NUMBER:
	237	+	case REGEXLITERAL_IN_FORWARD_SLASHES:
	238	+	case REGEX_IN_FORWARD_SLASHES:
	239	+	case INVERSE:
	240	+	case IDENTIFIER:
	241	+	case OPEN_SINGLE_QUOTE_STRING:
	242	+	case OPEN_DOUBLE_QUOTE_STRING:{
	243	+	right = Value();
	244	+	break;
	245	+	}
	246	+	default:
	247	+	jj_la1[7] = jj_gen;
	248	+	{if (true) throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
	249	+	}
	250	+	if(right instanceof Pattern && !String.class.isAssignableFrom(((LogEntryField) left).getType())){
	251	+	{if (true) throw new ParseException(String.format("Regex patterns can only be used on fields which can be converted to a string. Field \"%s\" of type \"%s\" cannot be converted.", left, ((LogEntryField) left).getType()));}
	252	+	}
233	253		break;
234	254		}
235		-	case IDENTIFIER:{
236		-	right = Identifier();
	255	+	case GT:
	256	+	case LT:
	257	+	case GEQ:
	258	+	case LEQ:{
	259	+	op = NumericOperator();
	260	+	if(!Number.class.isAssignableFrom(((LogEntryField) left).getType())){
	261	+	{if (true) throw new ParseException(String.format("Numeric operators cannot be used for field \"%s\" of type \"%s\"", left, ((LogEntryField) left).getType()));}
	262	+	}
	263	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	264	+	case NUMBER:{
	265	+	right = Number();
	266	+	break;
	267	+	}
	268	+	case IDENTIFIER:{
	269	+	right = Identifier();
237	270		if(!Number.class.isAssignableFrom(((LogEntryField) right).getType())){
238	271		{if (true) throw new ParseException(String.format("Numeric operators cannot be used for field \"%s\" of type \"%s\"", right, ((LogEntryField) right).getType()));}
239	272		}
240		-	break;
241		-	}
242		-	default:
243		-	jj_la1[7] = jj_gen;
	273	+	break;
	274	+	}
	275	+	default:
	276	+	jj_la1[8] = jj_gen;
244	277		{if (true) throw new ParseException("Invalid right hand value for comparison \"" + op + "\"");}
245		-	}
246		-	break;
247		-	}
248		-	case CONTAINS:{
249		-	op = ContainsOperator();
250		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
251		-	case SINGLEQUOTEDSTRING:
252		-	case DOUBLEQUOTEDSTRING:{
253		-	right = String();
254		-	break;
255	278		}
256		-	case NUMBER:{
257		-	right = Number();
258	279		break;
259	280		}
260		-	case IDENTIFIER:{
261		-	right = Identifier();
262		-	break;
	281	+	case CONTAINS:{
	282	+	op = ContainsOperator();
	283	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	284	+	case OPEN_SINGLE_QUOTE_STRING:
	285	+	case OPEN_DOUBLE_QUOTE_STRING:{
	286	+	right = String();
	287	+	break;
	288	+	}
	289	+	case NUMBER:{
	290	+	right = Number();
	291	+	break;
	292	+	}
	293	+	case IDENTIFIER:{
	294	+	right = Identifier();
	295	+	break;
	296	+	}
	297	+	default:
	298	+	jj_la1[9] = jj_gen;
	299	+	{if (true) throw new ParseException("The contains operator can only be used on string and numeric values and identifiers.");}
263	300		}
264		-	default:
265		-	jj_la1[8] = jj_gen;
266		-	{if (true) throw new ParseException("The contains operator can only be used on string and numeric values and identifiers.");}
267		-	}
268		-	break;
269		-	}
270		-	case IN:{
271		-	op = InOperator();
272		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
273		-	case ARRAY_START:{
274		-	right = Array();
275	301		break;
276	302		}
277		-	default:
278		-	jj_la1[9] = jj_gen;
	303	+	case IN:{
	304	+	op = InOperator();
	305	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	306	+	case ARRAY_START:{
	307	+	right = Array();
	308	+	break;
	309	+	}
	310	+	default:
	311	+	jj_la1[10] = jj_gen;
279	312		{if (true) throw new ParseException("The in operator must be used on an array. E.g. \"Response.status IN [200, 302, 500]\"");}
280		-	}
281		-	break;
282		-	}
283		-	case MATCHES:{
284		-	op = MatchesOperator();
285		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
286		-	case SINGLEQUOTEDSTRING:
287		-	case DOUBLEQUOTEDSTRING:{
288		-	right = RegexInString();
	313	+	}
289	314		break;
290	315		}
291		-	case REGEXLITERAL_IN_FORWARD_SLASHES:
292		-	case REGEX_IN_FORWARD_SLASHES:{
293		-	right = RegexInForwardSlashes();
	316	+	case MATCHES:{
	317	+	op = MatchesOperator();
	318	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	319	+	case OPEN_SINGLE_QUOTE_STRING:
	320	+	case OPEN_DOUBLE_QUOTE_STRING:{
	321	+	right = RegexInString();
	322	+	break;
	323	+	}
	324	+	case REGEXLITERAL_IN_FORWARD_SLASHES:
	325	+	case REGEX_IN_FORWARD_SLASHES:{
	326	+	right = RegexInForwardSlashes();
	327	+	break;
	328	+	}
	329	+	default:
	330	+	jj_la1[11] = jj_gen;
	331	+	{if (true) throw new ParseException("The matches operator must have a pattern as its right hand value.");}
	332	+	}
294	333		break;
295	334		}
296	335		default:
297		-	jj_la1[10] = jj_gen;
298		-	{if (true) throw new ParseException("The matches operator must have a pattern as its right hand value.");}
299		-	}
300		-	break;
301		-	}
302		-	default:
303		-	jj_la1[11] = jj_gen;
	336	+	jj_la1[12] = jj_gen;
304	337		if(!(left instanceof Boolean \|\| (left instanceof LogEntryField && ((LogEntryField) left).getType().isAssignableFrom(Boolean.class)))){
305	338		//If left isn't a boolean value or field with boolean type
306	339		{if (true) throw new ParseException(left + " cannot be evaluated as a boolean.");}
307	340		}
308		-	}
	341	+	}
309	342		jjtree.closeNodeScope(jjtn000, true);
310	343		jjtc000 = false;
311	344		jjtn000.left = left;
312	345		jjtn000.right = right;
313	346		jjtn000.operator = op;
314		-	} catch (Throwable jjte000) {
	347	+	} catch (Throwable jjte000) {
315	348		if (jjtc000) {
316	349		jjtree.clearNodeScope(jjtn000);
317	350		jjtc000 = false;
		skipped 7 lines
325	358		{if (true) throw (ParseException)jjte000;}
326	359		}
327	360		{if (true) throw (Error)jjte000;}
328		-	} finally {
	361	+	} finally {
329	362		if (jjtc000) {
330	363		jjtree.closeNodeScope(jjtn000, true);
331	364		}
	365	+	}
	366	+	} finally {
	367	+	trace_return("Comparison");
332	368		}
333	369		}
334	370
335		-	final public void Alias() throws ParseException {/@bgen(jjtree) Alias /
	371	+	final public void Alias() throws ParseException { try {
	372	+	/@bgen(jjtree) Alias /
336	373		ASTAlias jjtn000 = new ASTAlias(JJTALIAS);
337	374		boolean jjtc000 = true;
338	375		jjtree.openNodeScope(jjtn000);Token identifier;
339		-	try {
340		-	jj_consume_token(ALIAS_SYMBOL);
341		-	identifier = jj_consume_token(IDENTIFIER);
	376	+	try {
	377	+	jj_consume_token(ALIAS_SYMBOL);
	378	+	identifier = jj_consume_token(IDENTIFIER);
342	379		jjtree.closeNodeScope(jjtn000, true);
343	380		jjtc000 = false;
344	381		jjtn000.identifier = identifier.image;
345		-	} finally {
	382	+	} finally {
346	383		if (jjtc000) {
347	384		jjtree.closeNodeScope(jjtn000, true);
348	385		}
	386	+	}
	387	+	} finally {
	388	+	trace_return("Alias");
349	389		}
350	390		}
351	391
352		-	final public Object Value() throws ParseException {Object v;
353		-	if (jj_2_4(2)) {
354		-	v = Identifier();
355		-	} else {
356		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
357		-	case NUMBER:{
358		-	v = Number();
359		-	break;
360		-	}
361		-	case BOOLEAN:
362		-	case INVERSE:{
363		-	v = Boolean();
364		-	break;
365		-	}
366		-	default:
367		-	jj_la1[12] = jj_gen;
368		-	if (jj_2_5(2)) {
	392	+	final public Object Value() throws ParseException { try {
	393	+	Object v;
	394	+	if (jj_2_3(2)) {
	395	+	v = Identifier();
	396	+	} else {
	397	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	398	+	case NUMBER:{
	399	+	v = Number();
	400	+	break;
	401	+	}
	402	+	case BOOLEAN:
	403	+	case INVERSE:{
	404	+	v = Boolean();
	405	+	break;
	406	+	}
	407	+	case OPEN_SINGLE_QUOTE_STRING:
	408	+	case OPEN_DOUBLE_QUOTE_STRING:{
369	409		v = String();
370		-	} else {
371		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
372		-	case REGEXLITERAL_IN_FORWARD_SLASHES:
373		-	case REGEX_IN_FORWARD_SLASHES:{
374		-	v = RegexInForwardSlashes();
375		-	break;
376		-	}
377		-	case SINGLEQUOTEDSTRING:
378		-	case DOUBLEQUOTEDSTRING:{
379		-	v = RegexInString();
380		-	break;
381		-	}
382		-	default:
383		-	jj_la1[13] = jj_gen;
384		-	jj_consume_token(-1);
385		-	throw new ParseException();
	410	+	break;
386	411		}
	412	+	case REGEXLITERAL_IN_FORWARD_SLASHES:
	413	+	case REGEX_IN_FORWARD_SLASHES:{
	414	+	v = RegexInForwardSlashes();
	415	+	break;
	416	+	}
	417	+	default:
	418	+	jj_la1[13] = jj_gen;
	419	+	jj_consume_token(-1);
	420	+	throw new ParseException();
387	421		}
388	422		}
389		-	}
390	423		{if ("" != null) return v;}
391	424		throw new Error("Missing return statement in function");
	425	+	} finally {
	426	+	trace_return("Value");
	427	+	}
392	428		}
393	429
394		-	final public Set Array() throws ParseException {Set<Object> items = new LinkedHashSet();
	430	+	final public Set Array() throws ParseException { try {
	431	+	Set<Object> items = new LinkedHashSet();
395	432		Object initial, subsequent;
396		-	jj_consume_token(ARRAY_START);
397		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
398		-	case SINGLEQUOTEDSTRING:
399		-	case DOUBLEQUOTEDSTRING:{
400		-	initial = String();
401		-	break;
402		-	}
403		-	case NUMBER:{
404		-	initial = Number();
405		-	break;
406		-	}
407		-	default:
408		-	jj_la1[14] = jj_gen;
409		-	jj_consume_token(-1);
410		-	throw new ParseException();
411		-	}
412		-	items.add(initial);
413		-	label_2:
414		-	while (true) {
	433	+	jj_consume_token(ARRAY_START);
415	434		switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
416		-	case ARRAY_SEPARATOR:{
417		-	;
418		-	break;
419		-	}
420		-	default:
421		-	jj_la1[15] = jj_gen;
422		-	break label_2;
423		-	}
424		-	jj_consume_token(ARRAY_SEPARATOR);
425		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
426		-	case SINGLEQUOTEDSTRING:
427		-	case DOUBLEQUOTEDSTRING:{
428		-	subsequent = String();
	435	+	case OPEN_SINGLE_QUOTE_STRING:
	436	+	case OPEN_DOUBLE_QUOTE_STRING:{
	437	+	initial = String();
429	438		break;
430	439		}
431	440		case NUMBER:{
432		-	subsequent = Number();
	441	+	initial = Number();
433	442		break;
434	443		}
435	444		default:
436		-	jj_la1[16] = jj_gen;
	445	+	jj_la1[14] = jj_gen;
437	446		jj_consume_token(-1);
438	447		throw new ParseException();
439	448		}
	449	+	items.add(initial);
	450	+	label_2:
	451	+	while (true) {
	452	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	453	+	case ARRAY_SEPARATOR:{
	454	+	;
	455	+	break;
	456	+	}
	457	+	default:
	458	+	jj_la1[15] = jj_gen;
	459	+	break label_2;
	460	+	}
	461	+	jj_consume_token(ARRAY_SEPARATOR);
	462	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	463	+	case OPEN_SINGLE_QUOTE_STRING:
	464	+	case OPEN_DOUBLE_QUOTE_STRING:{
	465	+	subsequent = String();
	466	+	break;
	467	+	}
	468	+	case NUMBER:{
	469	+	subsequent = Number();
	470	+	break;
	471	+	}
	472	+	default:
	473	+	jj_la1[16] = jj_gen;
	474	+	jj_consume_token(-1);
	475	+	throw new ParseException();
	476	+	}
440	477		if(!initial.getClass().isAssignableFrom(subsequent.getClass())){
441	478		{if (true) throw new ParseException("Array elements must all be of the same type.");}
442	479		}
443	480		items.add(subsequent);
444		-	}
445		-	jj_consume_token(ARRAY_END);
	481	+	}
	482	+	jj_consume_token(ARRAY_END);
446	483		{if ("" != null) return items;}
447	484		throw new Error("Missing return statement in function");
	485	+	} finally {
	486	+	trace_return("Array");
	487	+	}
448	488		}
449	489
450	490		//IDENTIFIERS
451		-	final public LogEntryField Identifier() throws ParseException {Token group, identifier;
	491	+	final public LogEntryField Identifier() throws ParseException { try {
	492	+	Token group, identifier;
452	493		FieldGroup fieldGroup;
453	494		LogEntryField field;
454		-	group = jj_consume_token(IDENTIFIER);
	495	+	group = jj_consume_token(IDENTIFIER);
455	496		fieldGroup = FieldGroup.findByLabel(group.image);
456	497		if(fieldGroup == null)
457		-	{if (true) throw new ParseException(String.format("Invalid field group \"%s\". Valid groups are: %s", group.image, Arrays.toString(FieldGroup.values())));}
458		-	jj_consume_token(DOT);
459		-	identifier = jj_consume_token(IDENTIFIER);
	498	+	{if (true) throw new ParseException(String.format("Invalid field group \"%s\". Valid groups are:\n%s", group.image, Arrays.toString(FieldGroup.values())));}
	499	+	jj_consume_token(DOT);
	500	+	identifier = jj_consume_token(IDENTIFIER);
460	501		field = LogEntryField.getByLabel(fieldGroup, identifier.image);
461		-	if(field == null)
462		-	{if (true) throw new ParseException(String.format("Invalid field \"%s\". Valid fields for group \"%s\" are: %s", identifier.image, fieldGroup, LogEntryField.getFieldsInGroup(fieldGroup).values()));}
	502	+	if(field == null){
	503	+	StringBuilder fieldMessage = new StringBuilder();
	504	+	ArrayList<LogEntryField> fields = new ArrayList<LogEntryField>(getFieldsInGroup(FieldGroup.REQUEST));
	505	+	for (int i = 0; i < fields.size(); i++) {
	506	+	fieldMessage.append(fields.get(i).getDescriptiveMessage());
	507	+	if(i != fields.size()-1)
	508	+	fieldMessage.append("\n\n");
	509	+	}
	510	+	{if (true) throw new ParseException(String.format("Invalid field \"%s\". Valid fields for group \"%s\" are:\n%s", identifier.image, fieldGroup, fieldMessage));}
	511	+	}
463	512		if(field == LogEntryField.NUMBER)
464	513		{if (true) throw new ParseException("Field " + LogEntryField.NUMBER + " is ephemeral and cannot be used in filters.");}
465	514		{if ("" != null) return field;}
466	515		throw new Error("Missing return statement in function");
	516	+	} finally {
	517	+	trace_return("Identifier");
	518	+	}
467	519		}
468	520
469	521		//END IDENTIFIERS
		skipped 1 lines
471	523
472	524		//TYPES
473	525		final public
474		-	BigDecimal Number() throws ParseException {Token t;
475		-	t = jj_consume_token(NUMBER);
	526	+	BigDecimal Number() throws ParseException { try {
	527	+	Token t;
	528	+	t = jj_consume_token(NUMBER);
476	529		{if ("" != null) return new BigDecimal(t.image);}
477	530		throw new Error("Missing return statement in function");
	531	+	} finally {
	532	+	trace_return("Number");
	533	+	}
478	534		}
479	535
480		-	final public String String() throws ParseException {Token t;
481		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
482		-	case SINGLEQUOTEDSTRING:{
483		-	t = jj_consume_token(SINGLEQUOTEDSTRING);
484		-	break;
	536	+	final public String String() throws ParseException { try {
	537	+	Token t = null;
	538	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	539	+	case OPEN_SINGLE_QUOTE_STRING:{
	540	+	jj_consume_token(OPEN_SINGLE_QUOTE_STRING);
	541	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	542	+	case SINGLE_STRING_BODY:{
	543	+	t = jj_consume_token(SINGLE_STRING_BODY);
	544	+	break;
	545	+	}
	546	+	default:
	547	+	jj_la1[17] = jj_gen;
	548	+	;
	549	+	}
	550	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	551	+	case CLOSE_SINGLE_QUOTE_STRING:{
	552	+	jj_consume_token(CLOSE_SINGLE_QUOTE_STRING);
	553	+	break;
	554	+	}
	555	+	default:
	556	+	jj_la1[18] = jj_gen;
	557	+	{if (true) throw new ParseException("Missing closing quote for string.");}
	558	+	}
	559	+	break;
	560	+	}
	561	+	case OPEN_DOUBLE_QUOTE_STRING:{
	562	+	jj_consume_token(OPEN_DOUBLE_QUOTE_STRING);
	563	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	564	+	case DOUBLE_STRING_BODY:{
	565	+	t = jj_consume_token(DOUBLE_STRING_BODY);
	566	+	break;
	567	+	}
	568	+	default:
	569	+	jj_la1[19] = jj_gen;
	570	+	;
	571	+	}
	572	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	573	+	case CLOSE_DOUBLE_QUOTE_STRING:{
	574	+	jj_consume_token(CLOSE_DOUBLE_QUOTE_STRING);
	575	+	break;
	576	+	}
	577	+	default:
	578	+	jj_la1[20] = jj_gen;
	579	+	{if (true) throw new ParseException("Missing closing quote for string.");}
	580	+	}
	581	+	break;
	582	+	}
	583	+	default:
	584	+	jj_la1[21] = jj_gen;
	585	+	jj_consume_token(-1);
	586	+	throw new ParseException();
485	587		}
486		-	case DOUBLEQUOTEDSTRING:{
487		-	t = jj_consume_token(DOUBLEQUOTEDSTRING);
488		-	break;
489		-	}
490		-	default:
491		-	jj_la1[17] = jj_gen;
492		-	jj_consume_token(-1);
493		-	throw new ParseException();
494		-	}
495		-	String s = t.image.substring(1,t.image.length()-1);
496		-	{if ("" != null) return org.apache.commons.text.StringEscapeUtils.unescapeJava(s);}
	588	+	if(t == null) {if ("" != null) return "";}
	589	+	else {if ("" != null) return org.apache.commons.text.StringEscapeUtils.unescapeJava(t.image);}
497	590		throw new Error("Missing return statement in function");
	591	+	} finally {
	592	+	trace_return("String");
	593	+	}
498	594		}
499	595
500		-	final public Pattern RegexInString() throws ParseException {Token t;
501		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
502		-	case DOUBLEQUOTEDSTRING:{
503		-	t = jj_consume_token(DOUBLEQUOTEDSTRING);
504		-	break;
505		-	}
506		-	case SINGLEQUOTEDSTRING:{
507		-	t = jj_consume_token(SINGLEQUOTEDSTRING);
508		-	break;
	596	+	final public Pattern RegexInString() throws ParseException { try {
	597	+	Token t;
	598	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	599	+	case OPEN_SINGLE_QUOTE_STRING:{
	600	+	jj_consume_token(OPEN_SINGLE_QUOTE_STRING);
	601	+	t = jj_consume_token(SINGLE_STRING_BODY);
	602	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	603	+	case CLOSE_SINGLE_QUOTE_STRING:{
	604	+	jj_consume_token(CLOSE_SINGLE_QUOTE_STRING);
	605	+	break;
	606	+	}
	607	+	default:
	608	+	jj_la1[22] = jj_gen;
	609	+	{if (true) throw new ParseException("Missing closing quote for regex string.");}
	610	+	}
	611	+	break;
	612	+	}
	613	+	case OPEN_DOUBLE_QUOTE_STRING:{
	614	+	jj_consume_token(OPEN_DOUBLE_QUOTE_STRING);
	615	+	t = jj_consume_token(DOUBLE_STRING_BODY);
	616	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	617	+	case CLOSE_DOUBLE_QUOTE_STRING:{
	618	+	jj_consume_token(CLOSE_DOUBLE_QUOTE_STRING);
	619	+	break;
	620	+	}
	621	+	default:
	622	+	jj_la1[23] = jj_gen;
	623	+	{if (true) throw new ParseException("Missing closing quote for regex string.");}
	624	+	}
	625	+	break;
	626	+	}
	627	+	default:
	628	+	jj_la1[24] = jj_gen;
	629	+	jj_consume_token(-1);
	630	+	throw new ParseException();
509	631		}
510		-	default:
511		-	jj_la1[18] = jj_gen;
512		-	jj_consume_token(-1);
513		-	throw new ParseException();
	632	+	{if ("" != null) return Pattern.compile(t.image, Pattern.CASE_INSENSITIVE);}
	633	+	throw new Error("Missing return statement in function");
	634	+	} finally {
	635	+	trace_return("RegexInString");
514	636		}
515		-	{if ("" != null) return Pattern.compile(t.image.substring(1,t.image.length()-1), Pattern.CASE_INSENSITIVE);}
516		-	throw new Error("Missing return statement in function");
517	637		}
518	638
519		-	final public Pattern RegexInForwardSlashes() throws ParseException {Token t;
520		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
521		-	case REGEXLITERAL_IN_FORWARD_SLASHES:{
522		-	t = jj_consume_token(REGEXLITERAL_IN_FORWARD_SLASHES);
523		-	break;
524		-	}
525		-	case REGEX_IN_FORWARD_SLASHES:{
526		-	t = jj_consume_token(REGEX_IN_FORWARD_SLASHES);
527		-	break;
	639	+	final public Pattern RegexInForwardSlashes() throws ParseException { try {
	640	+	Token t;
	641	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	642	+	case REGEXLITERAL_IN_FORWARD_SLASHES:{
	643	+	t = jj_consume_token(REGEXLITERAL_IN_FORWARD_SLASHES);
	644	+	break;
	645	+	}
	646	+	case REGEX_IN_FORWARD_SLASHES:{
	647	+	t = jj_consume_token(REGEX_IN_FORWARD_SLASHES);
	648	+	break;
	649	+	}
	650	+	default:
	651	+	jj_la1[25] = jj_gen;
	652	+	jj_consume_token(-1);
	653	+	throw new ParseException();
528	654		}
529		-	default:
530		-	jj_la1[19] = jj_gen;
531		-	jj_consume_token(-1);
532		-	throw new ParseException();
533		-	}
534	655		{if ("" != null) return Pattern.compile(t.image.substring(1,t.image.length()-1), Pattern.CASE_INSENSITIVE);}
535	656		throw new Error("Missing return statement in function");
	657	+	} finally {
	658	+	trace_return("RegexInForwardSlashes");
	659	+	}
536	660		}
537	661
538		-	final public Boolean Boolean() throws ParseException {Token t, inverse=null;
539		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
540		-	case INVERSE:{
541		-	inverse = jj_consume_token(INVERSE);
542		-	break;
	662	+	final public Boolean Boolean() throws ParseException { try {
	663	+	Token t, inverse=null;
	664	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	665	+	case INVERSE:{
	666	+	inverse = jj_consume_token(INVERSE);
	667	+	break;
	668	+	}
	669	+	default:
	670	+	jj_la1[26] = jj_gen;
	671	+	;
543	672		}
544		-	default:
545		-	jj_la1[20] = jj_gen;
546		-	;
547		-	}
548		-	t = jj_consume_token(BOOLEAN);
	673	+	t = jj_consume_token(BOOLEAN);
549	674		{if ("" != null) return (inverse != null ^ Boolean.parseBoolean(t.image));}
550	675		throw new Error("Missing return statement in function");
	676	+	} finally {
	677	+	trace_return("Boolean");
	678	+	}
551	679		}
552	680
553	681		//END TYPES
		skipped 1 lines
555	683
556	684		//BASIC OPERATORS
557	685		final public
558		-	Operator EqualityOperator() throws ParseException {
559		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
560		-	case EQ:{
561		-	jj_consume_token(EQ);
	686	+	Operator EqualityOperator() throws ParseException { try {
	687	+
	688	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	689	+	case EQ:{
	690	+	jj_consume_token(EQ);
562	691		{if ("" != null) return Operator.EQUAL;}
563		-	break;
564		-	}
565		-	case NEQ:{
566		-	jj_consume_token(NEQ);
	692	+	break;
	693	+	}
	694	+	case NEQ:{
	695	+	jj_consume_token(NEQ);
567	696		{if ("" != null) return Operator.NOT_EQUAL;}
568		-	break;
	697	+	break;
	698	+	}
	699	+	default:
	700	+	jj_la1[27] = jj_gen;
	701	+	jj_consume_token(-1);
	702	+	throw new ParseException();
569	703		}
570		-	default:
571		-	jj_la1[21] = jj_gen;
572		-	jj_consume_token(-1);
573		-	throw new ParseException();
	704	+	throw new Error("Missing return statement in function");
	705	+	} finally {
	706	+	trace_return("EqualityOperator");
574	707		}
575		-	throw new Error("Missing return statement in function");
576	708		}
577	709
578		-	final public Operator NumericOperator() throws ParseException {
579		-	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
580		-	case GT:{
581		-	jj_consume_token(GT);
	710	+	final public Operator NumericOperator() throws ParseException { try {
	711	+
	712	+	switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
	713	+	case GT:{
	714	+	jj_consume_token(GT);
582	715		{if ("" != null) return Operator.GREATER_THAN;}
583		-	break;
584		-	}
585		-	case LT:{
586		-	jj_consume_token(LT);
	716	+	break;
	717	+	}
	718	+	case LT:{
	719	+	jj_consume_token(LT);
587	720		{if ("" != null) return Operator.LESS_THAN;}
588		-	break;
589		-	}
590		-	case GEQ:{
591		-	jj_consume_token(GEQ);
	721	+	break;
	722	+	}
	723	+	case GEQ:{
	724	+	jj_consume_token(GEQ);
592	725		{if ("" != null) return Operator.GREATER_THAN_EQUAL;}
593		-	break;
594		-	}
595		-	case LEQ:{
596		-	jj_consume_token(LEQ);
	726	+	break;
	727	+	}
	728	+	case LEQ:{
	729	+	jj_consume_token(LEQ);
597	730		{if ("" != null) return Operator.LESS_THAN_EQUAL;}
598		-	break;
	731	+	break;
	732	+	}
	733	+	default:
	734	+	jj_la1[28] = jj_gen;
	735	+	jj_consume_token(-1);
	736	+	throw new ParseException();
599	737		}
600		-	default:
601		-	jj_la1[22] = jj_gen;
602		-	jj_consume_token(-1);
603		-	throw new ParseException();
604		-	}
605	738		throw new Error("Missing return statement in function");
	739	+	} finally {
	740	+	trace_return("NumericOperator");
	741	+	}
606	742		}
607	743
608		-	final public Operator ContainsOperator() throws ParseException {
609		-	jj_consume_token(CONTAINS);
	744	+	final public Operator ContainsOperator() throws ParseException { try {
	745	+
	746	+	jj_consume_token(CONTAINS);
610	747		{if ("" != null) return Operator.CONTAINS;}
611	748		throw new Error("Missing return statement in function");
	749	+	} finally {
	750	+	trace_return("ContainsOperator");
	751	+	}
612	752		}
613	753
614		-	final public Operator MatchesOperator() throws ParseException {
615		-	jj_consume_token(MATCHES);
	754	+	final public Operator MatchesOperator() throws ParseException { try {
	755	+
	756	+	jj_consume_token(MATCHES);
616	757		{if ("" != null) return Operator.MATCHES;}
617	758		throw new Error("Missing return statement in function");
	759	+	} finally {
	760	+	trace_return("MatchesOperator");
	761	+	}
618	762		}
619	763
620		-	final public Operator InOperator() throws ParseException {
621		-	jj_consume_token(IN);
	764	+	final public Operator InOperator() throws ParseException { try {
	765	+
	766	+	jj_consume_token(IN);
622	767		{if ("" != null) return Operator.IN;}
623	768		throw new Error("Missing return statement in function");
	769	+	} finally {
	770	+	trace_return("InOperator");
	771	+	}
624	772		}
625	773
626		-	final public boolean Inverse() throws ParseException {
627		-	jj_consume_token(INVERSE);
	774	+	final public boolean Inverse() throws ParseException { try {
	775	+
	776	+	jj_consume_token(INVERSE);
628	777		{if ("" != null) return true;}
629	778		throw new Error("Missing return statement in function");
	779	+	} finally {
	780	+	trace_return("Inverse");
	781	+	}
630	782		}
631	783
632		-	final public BooleanOperator And() throws ParseException {
633		-	jj_consume_token(AND);
	784	+	final public BooleanOperator And() throws ParseException { try {
	785	+
	786	+	jj_consume_token(AND);
634	787		{if ("" != null) return BooleanOperator.AND;}
635	788		throw new Error("Missing return statement in function");
	789	+	} finally {
	790	+	trace_return("And");
	791	+	}
636	792		}
637	793
638		-	final public BooleanOperator Or() throws ParseException {
639		-	jj_consume_token(OR);
	794	+	final public BooleanOperator Or() throws ParseException { try {
	795	+
	796	+	jj_consume_token(OR);
640	797		{if ("" != null) return BooleanOperator.OR;}
641	798		throw new Error("Missing return statement in function");
	799	+	} finally {
	800	+	trace_return("Or");
	801	+	}
642	802		}
643	803
644		-	final public BooleanOperator Xor() throws ParseException {
645		-	jj_consume_token(XOR);
	804	+	final public BooleanOperator Xor() throws ParseException { try {
	805	+
	806	+	jj_consume_token(XOR);
646	807		{if ("" != null) return BooleanOperator.XOR;}
647	808		throw new Error("Missing return statement in function");
	809	+	} finally {
	810	+	trace_return("Xor");
	811	+	}
648	812		}
649	813
650	814		private boolean jj_2_1(int xla)
		skipped 20 lines
671	835		finally { jj_save(2, xla); }
672	836		}
673	837
674		-	private boolean jj_2_4(int xla)
675		-	{
676		-	jj_la = xla; jj_lastpos = jj_scanpos = token;
677		-	try { return (!jj_3_4()); }
678		-	catch(LookaheadSuccess ls) { return true; }
679		-	finally { jj_save(3, xla); }
680		-	}
681		-
682		-	private boolean jj_2_5(int xla)
683		-	{
684		-	jj_la = xla; jj_lastpos = jj_scanpos = token;
685		-	try { return (!jj_3_5()); }
686		-	catch(LookaheadSuccess ls) { return true; }
687		-	finally { jj_save(4, xla); }
688		-	}
689		-
690		-	private boolean jj_3R_43()
691		-	{
692		-	if (jj_scan_token(LEQ)) return true;
693		-	return false;
694		-	}
695		-
696		-	private boolean jj_3R_42()
697		-	{
698		-	if (jj_scan_token(GEQ)) return true;
699		-	return false;
700		-	}
701		-
702		-	private boolean jj_3R_41()
703		-	{
704		-	if (jj_scan_token(LT)) return true;
705		-	return false;
706		-	}
707		-
708		-	private boolean jj_3R_40()
709		-	{
710		-	if (jj_scan_token(GT)) return true;
711		-	return false;
712		-	}
713		-
714		-	private boolean jj_3R_34()
715		-	{
716		-	Token xsp;
717		-	xsp = jj_scanpos;
718		-	if (jj_3R_40()) {
719		-	jj_scanpos = xsp;
720		-	if (jj_3R_41()) {
721		-	jj_scanpos = xsp;
722		-	if (jj_3R_42()) {
723		-	jj_scanpos = xsp;
724		-	if (jj_3R_43()) return true;
725		-	}
726		-	}
727		-	}
728		-	return false;
729		-	}
730		-
731		-	private boolean jj_3R_6()
	838	+	private boolean jj_3R_13()
732	839		{
733		-	if (jj_3R_15()) return true;
	840	+	if (jj_scan_token(OR)) return true;
734	841		return false;
735	842		}
736	843
737		-	private boolean jj_3R_39()
	844	+	private boolean jj_3R_27()
738	845		{
739		-	if (jj_scan_token(NEQ)) return true;
	846	+	if (jj_3R_33()) return true;
740	847		return false;
741	848		}
742	849
743		-	private boolean jj_3R_38()
	850	+	private boolean jj_3R_12()
744	851		{
745		-	if (jj_scan_token(EQ)) return true;
	852	+	if (jj_scan_token(AND)) return true;
746	853		return false;
747	854		}
748	855
749		-	private boolean jj_3R_33()
750		-	{
751		-	Token xsp;
752		-	xsp = jj_scanpos;
753		-	if (jj_3R_38()) {
754		-	jj_scanpos = xsp;
755		-	if (jj_3R_39()) return true;
756		-	}
757		-	return false;
758		-	}
759		-
760		-	private boolean jj_3R_28()
761		-	{
762		-	if (jj_3R_34()) return true;
763		-	return false;
764		-	}
765		-
766		-	private boolean jj_3R_27()
	856	+	private boolean jj_3R_11()
767	857		{
768		-	if (jj_3R_33()) return true;
	858	+	if (jj_3R_14()) return true;
769	859		return false;
770	860		}
771	861
772		-	private boolean jj_3R_12()
	862	+	private boolean jj_3R_5()
773	863		{
774		-	if (jj_3R_15()) return true;
	864	+	if (jj_3R_13()) return true;
775	865		return false;
776	866		}
777	867
778		-	private boolean jj_3R_5()
	868	+	private boolean jj_3R_25()
779	869		{
780		-	if (jj_3R_14()) return true;
	870	+	if (jj_3R_8()) return true;
781	871		return false;
782	872		}
783	873
784		-	private boolean jj_3_3()
	874	+	private boolean jj_3R_22()
785	875		{
786		-	if (jj_3R_8()) return true;
	876	+	if (jj_scan_token(INVERSE)) return true;
787	877		return false;
788	878		}
789	879
790		-	private boolean jj_3R_25()
	880	+	private boolean jj_3R_24()
791	881		{
792	882		Token xsp;
793	883		xsp = jj_scanpos;
794		-	if (jj_3_3()) {
	884	+	if (jj_3R_25()) {
795	885		jj_scanpos = xsp;
796	886		if (jj_3R_26()) return true;
797	887		}
		skipped 17 lines
815	905		return false;
816	906		}
817	907
818		-	private boolean jj_3_5()
	908	+	private boolean jj_3_3()
819	909		{
820		-	if (jj_3R_9()) return true;
	910	+	if (jj_3R_8()) return true;
821	911		return false;
822	912		}
823	913
824		-	private boolean jj_3R_11()
	914	+	private boolean jj_3R_36()
825	915		{
826		-	if (jj_3R_14()) return true;
	916	+	if (jj_scan_token(IN)) return true;
827	917		return false;
828	918		}
829	919
830		-	private boolean jj_3R_17()
	920	+	private boolean jj_3R_16()
831	921		{
832		-	if (jj_3R_19()) return true;
	922	+	if (jj_3R_18()) return true;
833	923		return false;
834	924		}
835	925
836		-	private boolean jj_3_4()
	926	+	private boolean jj_3R_10()
837	927		{
838		-	if (jj_3R_8()) return true;
	928	+	if (jj_3R_13()) return true;
	929	+	return false;
	930	+	}
	931	+
	932	+	private boolean jj_3R_37()
	933	+	{
	934	+	if (jj_scan_token(MATCHES)) return true;
839	935		return false;
840	936		}
841	937
842	938		private boolean jj_3R_4()
843	939		{
844		-	if (jj_3R_13()) return true;
	940	+	if (jj_3R_12()) return true;
	941	+	return false;
	942	+	}
	943	+
	944	+	private boolean jj_3R_23()
	945	+	{
	946	+	if (jj_scan_token(ALIAS_SYMBOL)) return true;
	947	+	return false;
	948	+	}
	949	+
	950	+	private boolean jj_3R_35()
	951	+	{
	952	+	if (jj_scan_token(CONTAINS)) return true;
845	953		return false;
846	954		}
847	955
		skipped 12 lines
860	968		return false;
861	969		}
862	970
863		-	private boolean jj_3R_10()
	971	+	private boolean jj_3R_9()
864	972		{
865		-	if (jj_3R_13()) return true;
	973	+	if (jj_3R_12()) return true;
866	974		return false;
867	975		}
868	976
869		-	private boolean jj_3R_22()
	977	+	private boolean jj_3R_21()
870	978		{
871		-	if (jj_3R_25()) return true;
	979	+	if (jj_3R_24()) return true;
872	980		return false;
873	981		}
874	982
		skipped 1 lines
876	984		{
877	985		Token xsp;
878	986		xsp = jj_scanpos;
879		-	if (jj_3R_10()) {
	987	+	if (jj_3R_9()) {
880	988		jj_scanpos = xsp;
881		-	if (jj_3R_11()) {
	989	+	if (jj_3R_10()) {
882	990		jj_scanpos = xsp;
883		-	if (jj_3R_12()) return true;
	991	+	if (jj_3R_11()) return true;
884	992		}
885	993		}
886	994		if (jj_3R_7()) return true;
887	995		return false;
888	996		}
889	997
890		-	private boolean jj_3R_24()
	998	+	private boolean jj_3R_43()
891	999		{
892		-	if (jj_scan_token(ALIAS_SYMBOL)) return true;
	1000	+	if (jj_scan_token(LEQ)) return true;
893	1001		return false;
894	1002		}
895	1003
896		-	private boolean jj_3R_15()
	1004	+	private boolean jj_3R_42()
897	1005		{
898		-	if (jj_scan_token(XOR)) return true;
	1006	+	if (jj_scan_token(GEQ)) return true;
899	1007		return false;
900	1008		}
901	1009
902		-	private boolean jj_3R_9()
	1010	+	private boolean jj_3R_41()
	1011	+	{
	1012	+	if (jj_scan_token(LT)) return true;
	1013	+	return false;
	1014	+	}
	1015	+
	1016	+	private boolean jj_3R_40()
	1017	+	{
	1018	+	if (jj_scan_token(GT)) return true;
	1019	+	return false;
	1020	+	}
	1021	+
	1022	+	private boolean jj_3R_34()
903	1023		{
904	1024		Token xsp;
905	1025		xsp = jj_scanpos;
906		-	if (jj_scan_token(14)) {
	1026	+	if (jj_3R_40()) {
907	1027		jj_scanpos = xsp;
908		-	if (jj_scan_token(15)) return true;
	1028	+	if (jj_3R_41()) {
	1029	+	jj_scanpos = xsp;
	1030	+	if (jj_3R_42()) {
	1031	+	jj_scanpos = xsp;
	1032	+	if (jj_3R_43()) return true;
	1033	+	}
	1034	+	}
909	1035		}
910	1036		return false;
911	1037		}
912	1038
913		-	private boolean jj_3R_19()
	1039	+	private boolean jj_3R_18()
914	1040		{
915	1041		Token xsp;
916	1042		xsp = jj_scanpos;
917		-	if (jj_3R_21()) {
	1043	+	if (jj_3R_20()) {
918	1044		jj_scanpos = xsp;
919		-	if (jj_3R_22()) return true;
	1045	+	if (jj_3R_21()) return true;
920	1046		}
921	1047		return false;
922	1048		}
923	1049
924		-	private boolean jj_3R_21()
	1050	+	private boolean jj_3R_20()
	1051	+	{
	1052	+	if (jj_3R_23()) return true;
	1053	+	return false;
	1054	+	}
	1055	+
	1056	+	private boolean jj_3R_39()
925	1057		{
926		-	if (jj_3R_24()) return true;
	1058	+	if (jj_scan_token(NEQ)) return true;
927	1059		return false;
928	1060		}
929	1061
930		-	private boolean jj_3R_14()
	1062	+	private boolean jj_3R_38()
931	1063		{
932		-	if (jj_scan_token(OR)) return true;
	1064	+	if (jj_scan_token(EQ)) return true;
933	1065		return false;
934	1066		}
935	1067
936		-	private boolean jj_3R_7()
	1068	+	private boolean jj_3R_33()
937	1069		{
938	1070		Token xsp;
939	1071		xsp = jj_scanpos;
940		-	if (jj_3R_16()) {
	1072	+	if (jj_3R_38()) {
941	1073		jj_scanpos = xsp;
942		-	if (jj_3R_17()) return true;
	1074	+	if (jj_3R_39()) return true;
943	1075		}
944	1076		return false;
945	1077		}
946	1078
947		-	private boolean jj_3R_16()
	1079	+	private boolean jj_3R_32()
948	1080		{
949		-	if (jj_3R_18()) return true;
950	1081		return false;
951	1082		}
952	1083
953		-	private boolean jj_3_1()
	1084	+	private boolean jj_3R_15()
954	1085		{
955		-	if (jj_3R_3()) return true;
	1086	+	if (jj_3R_17()) return true;
956	1087		return false;
957	1088		}
958	1089
959		-	private boolean jj_3R_32()
	1090	+	private boolean jj_3R_7()
960	1091		{
	1092	+	Token xsp;
	1093	+	xsp = jj_scanpos;
	1094	+	if (jj_3R_15()) {
	1095	+	jj_scanpos = xsp;
	1096	+	if (jj_3R_16()) return true;
	1097	+	}
961	1098		return false;
962	1099		}
963	1100
964		-	private boolean jj_3R_13()
	1101	+	private boolean jj_3_1()
965	1102		{
966		-	if (jj_scan_token(AND)) return true;
	1103	+	if (jj_3R_3()) return true;
967	1104		return false;
968	1105		}
969	1106
970		-	private boolean jj_3R_20()
	1107	+	private boolean jj_3R_19()
971	1108		{
972		-	if (jj_3R_23()) return true;
	1109	+	if (jj_3R_22()) return true;
973	1110		return false;
974	1111		}
975	1112
976		-	private boolean jj_3R_18()
	1113	+	private boolean jj_3R_17()
977	1114		{
978	1115		Token xsp;
979	1116		xsp = jj_scanpos;
980		-	if (jj_3R_20()) jj_scanpos = xsp;
	1117	+	if (jj_3R_19()) jj_scanpos = xsp;
981	1118		if (jj_scan_token(LPAREN)) return true;
982	1119		return false;
983	1120		}
984	1121
985		-	private boolean jj_3R_23()
986		-	{
987		-	if (jj_scan_token(INVERSE)) return true;
988		-	return false;
989		-	}
990		-
991	1122		private boolean jj_3R_31()
992	1123		{
993	1124		if (jj_3R_37()) return true;
994	1125		return false;
995	1126		}
996	1127
997		-	private boolean jj_3R_36()
	1128	+	private boolean jj_3R_30()
998	1129		{
999		-	if (jj_scan_token(IN)) return true;
	1130	+	if (jj_3R_36()) return true;
1000	1131		return false;
1001	1132		}
1002	1133
1003		-	private boolean jj_3R_30()
	1134	+	private boolean jj_3R_29()
1004	1135		{
1005		-	if (jj_3R_36()) return true;
	1136	+	if (jj_3R_35()) return true;
1006	1137		return false;
1007	1138		}
1008	1139
1009		-	private boolean jj_3R_37()
	1140	+	private boolean jj_3R_8()
1010	1141		{
1011		-	if (jj_scan_token(MATCHES)) return true;
	1142	+	if (jj_scan_token(IDENTIFIER)) return true;
	1143	+	if (jj_scan_token(DOT)) return true;
1012	1144		return false;
1013	1145		}
1014	1146
		skipped 2 lines
1017	1149		return false;
1018	1150		}
1019	1151
1020		-	private boolean jj_3R_8()
	1152	+	private boolean jj_3R_6()
1021	1153		{
1022		-	if (jj_scan_token(IDENTIFIER)) return true;
1023		-	if (jj_scan_token(DOT)) return true;
1024		-	if (jj_scan_token(IDENTIFIER)) return true;
	1154	+	if (jj_3R_14()) return true;
1025	1155		return false;
1026	1156		}
1027	1157
1028		-	private boolean jj_3R_35()
	1158	+	private boolean jj_3R_28()
1029	1159		{
1030		-	if (jj_scan_token(CONTAINS)) return true;
	1160	+	if (jj_3R_34()) return true;
1031	1161		return false;
1032	1162		}
1033	1163
1034		-	private boolean jj_3R_29()
	1164	+	private boolean jj_3R_14()
1035	1165		{
1036		-	if (jj_3R_35()) return true;
	1166	+	if (jj_scan_token(XOR)) return true;
1037	1167		return false;
1038	1168		}
1039	1169
		skipped 8 lines
1048	1178		private Token jj_scanpos, jj_lastpos;
1049	1179		private int jj_la;
1050	1180		private int jj_gen;
1051		-	final private int[] jj_la1 = new int[23];
	1181	+	final private int[] jj_la1 = new int[29];
1052	1182		static private int[] jj_la1_0;
	1183	+	static private int[] jj_la1_1;
1053	1184		static {
1054	1185		jj_la1_init_0();
	1186	+	jj_la1_init_1();
1055	1187		}
1056	1188		private static void jj_la1_init_0() {
1057		-	jj_la1_0 = new int[] {0x800000,0x400000,0xa00000,0x20000000,0x700,0x700,0x28de000,0x2010000,0x201c000,0x4000000,0xcc000,0x1018fc,0x812000,0xcc000,0x1c000,0x10000000,0x1c000,0xc000,0xc000,0xc0000,0x800000,0xc,0xf0,};
	1189	+	jj_la1_0 = new int[] {0x200000,0x100000,0x280000,0x8000000,0x700,0x700,0x800000,0x30a36000,0x804000,0x30804000,0x1000000,0x30030000,0x418fc,0x30236000,0x30004000,0x4000000,0x30004000,0x40000000,0x80000000,0x0,0x0,0x30000000,0x80000000,0x0,0x30000000,0x30000,0x200000,0xc,0xf0,};
	1190	+	}
	1191	+	private static void jj_la1_init_1() {
	1192	+	jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x2,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,};
1058	1193		}
1059		-	final private JJCalls[] jj_2_rtns = new JJCalls[5];
	1194	+	final private JJCalls[] jj_2_rtns = new JJCalls[3];
1060	1195		private boolean jj_rescan = false;
1061	1196		private int jj_gc = 0;
1062	1197
	1198	+	{
	1199	+	enable_tracing();
	1200	+	}
1063	1201		/** Constructor with InputStream. */
1064	1202		public FilterParser(java.io.InputStream stream) {
1065	1203		this(stream, null);
		skipped 5 lines
1071	1209		token = new Token();
1072	1210		jj_ntk = -1;
1073	1211		jj_gen = 0;
1074		-	for (int i = 0; i < 23; i++) jj_la1[i] = -1;
	1212	+	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
1075	1213		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1076	1214		}
1077	1215
		skipped 9 lines
1087	1225		jj_ntk = -1;
1088	1226		jjtree.reset();
1089	1227		jj_gen = 0;
1090		-	for (int i = 0; i < 23; i++) jj_la1[i] = -1;
	1228	+	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
1091	1229		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1092	1230		}
1093	1231
		skipped 4 lines
1098	1236		token = new Token();
1099	1237		jj_ntk = -1;
1100	1238		jj_gen = 0;
1101		-	for (int i = 0; i < 23; i++) jj_la1[i] = -1;
	1239	+	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
1102	1240		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1103	1241		}
1104	1242
		skipped 13 lines
1118	1256		jj_ntk = -1;
1119	1257		jjtree.reset();
1120	1258		jj_gen = 0;
1121		-	for (int i = 0; i < 23; i++) jj_la1[i] = -1;
	1259	+	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
1122	1260		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1123	1261		}
1124	1262
		skipped 3 lines
1128	1266		token = new Token();
1129	1267		jj_ntk = -1;
1130	1268		jj_gen = 0;
1131		-	for (int i = 0; i < 23; i++) jj_la1[i] = -1;
	1269	+	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
1132	1270		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1133	1271		}
1134	1272
		skipped 4 lines
1139	1277		jj_ntk = -1;
1140	1278		jjtree.reset();
1141	1279		jj_gen = 0;
1142		-	for (int i = 0; i < 23; i++) jj_la1[i] = -1;
	1280	+	for (int i = 0; i < 29; i++) jj_la1[i] = -1;
1143	1281		for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1144	1282		}
1145	1283
		skipped 14 lines
1160	1298		}
1161	1299		}
1162	1300		}
	1301	+	trace_token(token, "");
1163	1302		return token;
1164	1303		}
1165	1304		token = oldToken;
		skipped 32 lines
1198	1337		else token = token.next = token_source.getNextToken();
1199	1338		jj_ntk = -1;
1200	1339		jj_gen++;
	1340	+	trace_token(token, " (in getNextToken)");
1201	1341		return token;
1202	1342		}
1203	1343
		skipped 61 lines
1265	1405		/** Generate ParseException. */
1266	1406		public ParseException generateParseException() {
1267	1407		jj_expentries.clear();
1268		-	boolean[] la1tokens = new boolean[30];
	1408	+	boolean[] la1tokens = new boolean[35];
1269	1409		if (jj_kind >= 0) {
1270	1410		la1tokens[jj_kind] = true;
1271	1411		jj_kind = -1;
1272	1412		}
1273		-	for (int i = 0; i < 23; i++) {
	1413	+	for (int i = 0; i < 29; i++) {
1274	1414		if (jj_la1[i] == jj_gen) {
1275	1415		for (int j = 0; j < 32; j++) {
1276	1416		if ((jj_la1_0[i] & (1<<j)) != 0) {
1277	1417		la1tokens[j] = true;
1278	1418		}
	1419	+	if ((jj_la1_1[i] & (1<<j)) != 0) {
	1420	+	la1tokens[32+j] = true;
	1421	+	}
1279	1422		}
1280	1423		}
1281	1424		}
1282		-	for (int i = 0; i < 30; i++) {
	1425	+	for (int i = 0; i < 35; i++) {
1283	1426		if (la1tokens[i]) {
1284	1427		jj_expentry = new int[1];
1285	1428		jj_expentry[0] = i;
		skipped 18 lines
1304	1447		return trace_enabled;
1305	1448		}
1306	1449
1307		-	/** Enable tracing. */
	1450	+	/** Enable tracing. */
1308	1451		final public void enable_tracing() {
	1452	+	trace_enabled = true;
1309	1453		}
1310	1454
1311		-	/** Disable tracing. */
	1455	+	/** Disable tracing. */
1312	1456		final public void disable_tracing() {
	1457	+	trace_enabled = false;
	1458	+	}
	1459	+
	1460	+	protected void trace_call(String s) {
	1461	+	if (trace_enabled) {
	1462	+	for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
	1463	+	System.out.println("Call: " + s);
	1464	+	}
	1465	+	trace_indent = trace_indent + 2;
	1466	+	}
	1467	+
	1468	+	protected void trace_return(String s) {
	1469	+	trace_indent = trace_indent - 2;
	1470	+	if (trace_enabled) {
	1471	+	for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
	1472	+	System.out.println("Return: " + s);
	1473	+	}
	1474	+	}
	1475	+
	1476	+	protected void trace_token(Token t, String where) {
	1477	+	if (trace_enabled) {
	1478	+	for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
	1479	+	System.out.print("Consumed token: <" + tokenImage[t.kind]);
	1480	+	if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
	1481	+	System.out.print(": \"" + TokenMgrError.addEscapes(t.image) + "\"");
	1482	+	}
	1483	+	System.out.println(" at line " + t.beginLine + " column " + t.beginColumn + ">" + where);
	1484	+	}
	1485	+	}
	1486	+
	1487	+	protected void trace_scan(Token t1, int t2) {
	1488	+	if (trace_enabled) {
	1489	+	for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
	1490	+	System.out.print("Visited token: <" + tokenImage[t1.kind]);
	1491	+	if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
	1492	+	System.out.print(": \"" + TokenMgrError.addEscapes(t1.image) + "\"");
	1493	+	}
	1494	+	System.out.println(" at line " + t1.beginLine + " column " + t1.beginColumn + ">; Expected token: <" + tokenImage[t2] + ">");
	1495	+	}
1313	1496		}
1314	1497
1315	1498		private void jj_rescan_token() {
1316	1499		jj_rescan = true;
1317		-	for (int i = 0; i < 5; i++) {
	1500	+	for (int i = 0; i < 3; i++) {
1318	1501		try {
1319	1502		JJCalls p = jj_2_rtns[i];
1320	1503
		skipped 4 lines
1325	1508		case 0: jj_3_1(); break;
1326	1509		case 1: jj_3_2(); break;
1327	1510		case 2: jj_3_3(); break;
1328		-	case 3: jj_3_4(); break;
1329		-	case 4: jj_3_5(); break;
1330	1511		}
1331	1512		}
1332	1513		p = p.next;
		skipped 28 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/FilterParserConstants.java

		skipped 34 lines
35	35		/** RegularExpression Id. */
36	36		int BOOLEAN = 13;
37	37		/** RegularExpression Id. */
38		-	int SINGLEQUOTEDSTRING = 14;
	38	+	int NUMBER = 14;
39	39		/** RegularExpression Id. */
40		-	int DOUBLEQUOTEDSTRING = 15;
	40	+	int DIGIT = 15;
41	41		/** RegularExpression Id. */
42		-	int NUMBER = 16;
	42	+	int REGEXLITERAL_IN_FORWARD_SLASHES = 16;
43	43		/** RegularExpression Id. */
44		-	int DIGIT = 17;
	44	+	int REGEX_IN_FORWARD_SLASHES = 17;
45	45		/** RegularExpression Id. */
46		-	int REGEXLITERAL_IN_FORWARD_SLASHES = 18;
	46	+	int MATCHES = 18;
47	47		/** RegularExpression Id. */
48		-	int REGEX_IN_FORWARD_SLASHES = 19;
	48	+	int LPAREN = 19;
49	49		/** RegularExpression Id. */
50		-	int MATCHES = 20;
	50	+	int RPAREN = 20;
51	51		/** RegularExpression Id. */
52		-	int LPAREN = 21;
	52	+	int INVERSE = 21;
	53	+	/** RegularExpression Id. */
	54	+	int DOT = 22;
	55	+	/** RegularExpression Id. */
	56	+	int IDENTIFIER = 23;
53	57		/** RegularExpression Id. */
54		-	int RPAREN = 22;
	58	+	int ARRAY_START = 24;
	59	+	/** RegularExpression Id. */
	60	+	int ARRAY_END = 25;
	61	+	/** RegularExpression Id. */
	62	+	int ARRAY_SEPARATOR = 26;
	63	+	/** RegularExpression Id. */
	64	+	int ALIAS_SYMBOL = 27;
55	65		/** RegularExpression Id. */
56		-	int INVERSE = 23;
	66	+	int OPEN_SINGLE_QUOTE_STRING = 28;
57	67		/** RegularExpression Id. */
58		-	int DOT = 24;
	68	+	int OPEN_DOUBLE_QUOTE_STRING = 29;
59	69		/** RegularExpression Id. */
60		-	int IDENTIFIER = 25;
	70	+	int SINGLE_STRING_BODY = 30;
61	71		/** RegularExpression Id. */
62		-	int ARRAY_START = 26;
	72	+	int CLOSE_SINGLE_QUOTE_STRING = 31;
63	73		/** RegularExpression Id. */
64		-	int ARRAY_END = 27;
	74	+	int DOUBLE_STRING_BODY = 32;
65	75		/** RegularExpression Id. */
66		-	int ARRAY_SEPARATOR = 28;
	76	+	int CLOSE_DOUBLE_QUOTE_STRING = 33;
67	77		/** RegularExpression Id. */
68		-	int ALIAS_SYMBOL = 29;
	78	+	int UNKNOWN = 34;
69	79
70	80		/** Lexical state. */
71	81		int DEFAULT = 0;
	82	+	/** Lexical state. */
	83	+	int SINGLE_QUOTED_STRING = 1;
	84	+	/** Lexical state. */
	85	+	int DOUBLE_QUOTED_STRING = 2;
72	86
73	87		/** Literal token values. */
74	88		String[] tokenImage = {
		skipped 11 lines
86	100		"\"CONTAINS\"",
87	101		"\"IN\"",
88	102		"<BOOLEAN>",
89		-	"<SINGLEQUOTEDSTRING>",
90		-	"<DOUBLEQUOTEDSTRING>",
91	103		"<NUMBER>",
92	104		"<DIGIT>",
93	105		"<REGEXLITERAL_IN_FORWARD_SLASHES>",
		skipped 8 lines
102	114		"\"]\"",
103	115		"\",\"",
104	116		"\"#\"",
	117	+	"\"\\\'\"",
	118	+	"\"\\\"\"",
	119	+	"<SINGLE_STRING_BODY>",
	120	+	"\"\\\'\"",
	121	+	"<DOUBLE_STRING_BODY>",
	122	+	"\"\\\"\"",
	123	+	"<UNKNOWN>",
105	124		};
106	125
107	126		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/parser/FilterParserTokenManager.java

		skipped 3 lines
4	4		import com.nccgroup.loggerplusplus.filter.BooleanOperator;
5	5		import com.nccgroup.loggerplusplus.filter.Operator;
6	6		import com.nccgroup.loggerplusplus.filterlibrary.FilterLibraryController;
7		-	import java.io.IOException;
8	7		import java.io.StringReader;
9	8		import java.math.BigDecimal;
10	9		import java.util.Arrays;
11	10		import java.util.LinkedHashSet;
12	11		import java.util.Set;
	12	+	import java.util.ArrayList;
13	13		import java.util.regex.Pattern;
14	14		import com.nccgroup.loggerplusplus.logentry.LogEntryField;
15	15		import com.nccgroup.loggerplusplus.logentry.FieldGroup;
	16	+	import static com.nccgroup.loggerplusplus.logentry.LogEntryField.getFieldsInGroup;
16	17
17	18		/** Token Manager. */
18	19		public class FilterParserTokenManager implements FilterParserConstants {
		skipped 16 lines
35	36		return jjMoveNfa_0(0, 0);
36	37		case 33:
37	38		return jjMoveStringLiteralDfa1_0(0x8L);
38		-	case 35:
	39	+	case 34:
39	40		jjmatchedKind = 29;
	41	+	return jjMoveNfa_0(0, 0);
	42	+	case 35:
	43	+	jjmatchedKind = 27;
	44	+	return jjMoveNfa_0(0, 0);
	45	+	case 39:
	46	+	jjmatchedKind = 28;
40	47		return jjMoveNfa_0(0, 0);
41	48		case 40:
42		-	jjmatchedKind = 21;
	49	+	jjmatchedKind = 19;
43	50		return jjMoveNfa_0(0, 0);
44	51		case 41:
45		-	jjmatchedKind = 22;
	52	+	jjmatchedKind = 20;
46	53		return jjMoveNfa_0(0, 0);
47	54		case 44:
48		-	jjmatchedKind = 28;
	55	+	jjmatchedKind = 26;
49	56		return jjMoveNfa_0(0, 0);
50	57		case 46:
51		-	jjmatchedKind = 24;
	58	+	jjmatchedKind = 22;
52	59		return jjMoveNfa_0(0, 0);
53	60		case 60:
54	61		jjmatchedKind = 5;
		skipped 6 lines
61	68		case 73:
62	69		return jjMoveStringLiteralDfa1_0(0x1000L);
63	70		case 77:
64		-	return jjMoveStringLiteralDfa1_0(0x100000L);
	71	+	return jjMoveStringLiteralDfa1_0(0x40000L);
65	72		case 91:
66		-	jjmatchedKind = 26;
	73	+	jjmatchedKind = 24;
67	74		return jjMoveNfa_0(0, 0);
68	75		case 93:
69		-	jjmatchedKind = 27;
	76	+	jjmatchedKind = 25;
70	77		return jjMoveNfa_0(0, 0);
71	78		case 99:
72	79		return jjMoveStringLiteralDfa1_0(0x800L);
73	80		case 105:
74	81		return jjMoveStringLiteralDfa1_0(0x1000L);
75	82		case 109:
76		-	return jjMoveStringLiteralDfa1_0(0x100000L);
	83	+	return jjMoveStringLiteralDfa1_0(0x40000L);
77	84		default :
78	85		return jjMoveNfa_0(0, 0);
79	86		}
		skipped 23 lines
103	110		}
104	111		break;
105	112		case 65:
106		-	return jjMoveStringLiteralDfa2_0(active0, 0x100000L);
	113	+	return jjMoveStringLiteralDfa2_0(active0, 0x40000L);
107	114		case 78:
108	115		if ((active0 & 0x1000L) != 0L)
109	116		{
		skipped 4 lines
114	121		case 79:
115	122		return jjMoveStringLiteralDfa2_0(active0, 0x800L);
116	123		case 97:
117		-	return jjMoveStringLiteralDfa2_0(active0, 0x100000L);
	124	+	return jjMoveStringLiteralDfa2_0(active0, 0x40000L);
118	125		case 110:
119	126		if ((active0 & 0x1000L) != 0L)
120	127		{
		skipped 20 lines
141	148		case 78:
142	149		return jjMoveStringLiteralDfa3_0(active0, 0x800L);
143	150		case 84:
144		-	return jjMoveStringLiteralDfa3_0(active0, 0x100000L);
	151	+	return jjMoveStringLiteralDfa3_0(active0, 0x40000L);
145	152		case 110:
146	153		return jjMoveStringLiteralDfa3_0(active0, 0x800L);
147	154		case 116:
148		-	return jjMoveStringLiteralDfa3_0(active0, 0x100000L);
	155	+	return jjMoveStringLiteralDfa3_0(active0, 0x40000L);
149	156		default :
150	157		break;
151	158		}
		skipped 9 lines
161	168		switch(curChar)
162	169		{
163	170		case 67:
164		-	return jjMoveStringLiteralDfa4_0(active0, 0x100000L);
	171	+	return jjMoveStringLiteralDfa4_0(active0, 0x40000L);
165	172		case 84:
166	173		return jjMoveStringLiteralDfa4_0(active0, 0x800L);
167	174		case 99:
168		-	return jjMoveStringLiteralDfa4_0(active0, 0x100000L);
	175	+	return jjMoveStringLiteralDfa4_0(active0, 0x40000L);
169	176		case 116:
170	177		return jjMoveStringLiteralDfa4_0(active0, 0x800L);
171	178		default :
		skipped 13 lines
185	192		case 65:
186	193		return jjMoveStringLiteralDfa5_0(active0, 0x800L);
187	194		case 72:
188		-	return jjMoveStringLiteralDfa5_0(active0, 0x100000L);
	195	+	return jjMoveStringLiteralDfa5_0(active0, 0x40000L);
189	196		case 97:
190	197		return jjMoveStringLiteralDfa5_0(active0, 0x800L);
191	198		case 104:
192		-	return jjMoveStringLiteralDfa5_0(active0, 0x100000L);
	199	+	return jjMoveStringLiteralDfa5_0(active0, 0x40000L);
193	200		default :
194	201		break;
195	202		}
		skipped 9 lines
205	212		switch(curChar)
206	213		{
207	214		case 69:
208		-	return jjMoveStringLiteralDfa6_0(active0, 0x100000L);
	215	+	return jjMoveStringLiteralDfa6_0(active0, 0x40000L);
209	216		case 73:
210	217		return jjMoveStringLiteralDfa6_0(active0, 0x800L);
211	218		case 101:
212		-	return jjMoveStringLiteralDfa6_0(active0, 0x100000L);
	219	+	return jjMoveStringLiteralDfa6_0(active0, 0x40000L);
213	220		case 105:
214	221		return jjMoveStringLiteralDfa6_0(active0, 0x800L);
215	222		default :
		skipped 13 lines
229	236		case 78:
230	237		return jjMoveStringLiteralDfa7_0(active0, 0x800L);
231	238		case 83:
232		-	if ((active0 & 0x100000L) != 0L)
	239	+	if ((active0 & 0x40000L) != 0L)
233	240		{
234		-	jjmatchedKind = 20;
	241	+	jjmatchedKind = 18;
235	242		jjmatchedPos = 6;
236	243		}
237	244		break;
238	245		case 110:
239	246		return jjMoveStringLiteralDfa7_0(active0, 0x800L);
240	247		case 115:
241		-	if ((active0 & 0x100000L) != 0L)
	248	+	if ((active0 & 0x40000L) != 0L)
242	249		{
243		-	jjmatchedKind = 20;
	250	+	jjmatchedKind = 18;
244	251		jjmatchedPos = 6;
245	252		}
246	253		break;
		skipped 43 lines
290	297		catch(java.io.IOException e) { throw new Error("Internal Error"); }
291	298		curPos = 0;
292	299		int startsAt = 0;
293		-	jjnewStateCnt = 59;
	300	+	jjnewStateCnt = 49;
294	301		int i = 1;
295	302		jjstateSet[0] = startState;
296	303		int kind = 0x7fffffff;
		skipped 11 lines
308	315		case 0:
309	316		if ((0x3ff000000000000L & l) != 0L)
310	317		{
311		-	if (kind > 16)
312		-	kind = 16;
313		-	{ jjCheckNAddTwoStates(37, 38); }
	318	+	if (kind > 14)
	319	+	kind = 14;
	320	+	{ jjCheckNAddTwoStates(27, 28); }
314	321		}
315	322		else if ((0x280000000000L & l) != 0L)
316		-	{ jjCheckNAdd(37); }
	323	+	{ jjCheckNAdd(27); }
317	324		else if (curChar == 33)
318	325		{
319		-	if (kind > 23)
320		-	kind = 23;
	326	+	if (kind > 21)
	327	+	kind = 21;
321	328		}
322	329		else if (curChar == 47)
323		-	{ jjCheckNAddTwoStates(50, 52); }
324		-	else if (curChar == 34)
325		-	{ jjCheckNAddStates(0, 2); }
326		-	else if (curChar == 39)
327		-	{ jjCheckNAddStates(3, 5); }
	330	+	{ jjCheckNAddTwoStates(40, 42); }
328	331		else if (curChar == 38)
329	332		jjstateSet[jjnewStateCnt++] = 9;
330	333		else if (curChar == 61)
331	334		jjstateSet[jjnewStateCnt++] = 1;
332	335		if ((0x3ff000000000000L & l) != 0L)
333	336		{
334		-	if (kind > 25)
335		-	kind = 25;
336		-	{ jjCheckNAdd(58); }
	337	+	if (kind > 23)
	338	+	kind = 23;
	339	+	{ jjCheckNAdd(48); }
337	340		}
338	341		else if (curChar == 47)
339		-	jjstateSet[jjnewStateCnt++] = 47;
	342	+	jjstateSet[jjnewStateCnt++] = 37;
340	343		else if (curChar == 38)
341	344		{
342	345		if (kind > 9)
		skipped 23 lines
366	369		jjstateSet[jjnewStateCnt++] = 9;
367	370		break;
368	371		case 26:
369		-	if (curChar == 39)
370		-	{ jjCheckNAddStates(3, 5); }
	372	+	if ((0x280000000000L & l) != 0L)
	373	+	{ jjCheckNAdd(27); }
	374	+	break;
	375	+	case 27:
	376	+	if ((0x3ff000000000000L & l) == 0L)
	377	+	break;
	378	+	if (kind > 14)
	379	+	kind = 14;
	380	+	{ jjCheckNAddTwoStates(27, 28); }
371	381		break;
372	382		case 28:
373		-	{ jjCheckNAddStates(3, 5); }
	383	+	if (curChar == 46)
	384	+	{ jjCheckNAdd(29); }
374	385		break;
375	386		case 29:
376		-	if ((0xffffff7fffffffffL & l) != 0L)
377		-	{ jjCheckNAddStates(3, 5); }
378		-	break;
379		-	case 30:
380		-	if (curChar == 39 && kind > 14)
	387	+	if ((0x3ff000000000000L & l) == 0L)
	388	+	break;
	389	+	if (kind > 14)
381	390		kind = 14;
	391	+	{ jjCheckNAdd(29); }
382	392		break;
383		-	case 31:
384		-	if (curChar == 34)
385		-	{ jjCheckNAddStates(0, 2); }
386		-	break;
	393	+	case 32:
387	394		case 33:
388	395		{ jjCheckNAddStates(0, 2); }
389	396		break;
390	397		case 34:
391		-	if ((0xfffffffbffffffffL & l) != 0L)
392		-	{ jjCheckNAddStates(0, 2); }
393		-	break;
394		-	case 35:
395		-	if (curChar == 34 && kind > 15)
396		-	kind = 15;
397		-	break;
398		-	case 36:
399		-	if ((0x280000000000L & l) != 0L)
400		-	{ jjCheckNAdd(37); }
401		-	break;
402		-	case 37:
403		-	if ((0x3ff000000000000L & l) == 0L)
404		-	break;
405		-	if (kind > 16)
	398	+	if (curChar == 47 && kind > 16)
406	399		kind = 16;
407		-	{ jjCheckNAddTwoStates(37, 38); }
408	400		break;
409	401		case 38:
410		-	if (curChar == 46)
411		-	{ jjCheckNAdd(39); }
	402	+	if (curChar == 47)
	403	+	jjstateSet[jjnewStateCnt++] = 37;
412	404		break;
413	405		case 39:
414		-	if ((0x3ff000000000000L & l) == 0L)
415		-	break;
416		-	if (kind > 16)
417		-	kind = 16;
418		-	{ jjCheckNAdd(39); }
	406	+	if (curChar == 47)
	407	+	{ jjCheckNAddTwoStates(40, 42); }
	408	+	break;
	409	+	case 41:
	410	+	{ jjCheckNAddStates(3, 5); }
419	411		break;
420	412		case 42:
	413	+	if ((0xffff7fffffffffffL & l) != 0L)
	414	+	{ jjCheckNAddStates(3, 5); }
	415	+	break;
421	416		case 43:
422		-	{ jjCheckNAddStates(6, 8); }
	417	+	if (curChar == 47 && kind > 17)
	418	+	kind = 17;
423	419		break;
424	420		case 44:
425		-	if (curChar == 47 && kind > 18)
426		-	kind = 18;
	421	+	if (curChar == 33 && kind > 21)
	422	+	kind = 21;
427	423		break;
428	424		case 48:
429		-	if (curChar == 47)
430		-	jjstateSet[jjnewStateCnt++] = 47;
431		-	break;
432		-	case 49:
433		-	if (curChar == 47)
434		-	{ jjCheckNAddTwoStates(50, 52); }
435		-	break;
436		-	case 51:
437		-	{ jjCheckNAddStates(9, 11); }
438		-	break;
439		-	case 52:
440		-	if ((0xffff7fffffffffffL & l) != 0L)
441		-	{ jjCheckNAddStates(9, 11); }
442		-	break;
443		-	case 53:
444		-	if (curChar == 47 && kind > 19)
445		-	kind = 19;
446		-	break;
447		-	case 54:
448		-	if (curChar == 33 && kind > 23)
449		-	kind = 23;
450		-	break;
451		-	case 58:
452	425		if ((0x3ff000000000000L & l) == 0L)
453	426		break;
454		-	if (kind > 25)
455		-	kind = 25;
456		-	{ jjCheckNAdd(58); }
	427	+	if (kind > 23)
	428	+	kind = 23;
	429	+	{ jjCheckNAdd(48); }
457	430		break;
458	431		default : break;
459	432		}
		skipped 9 lines
469	442		case 0:
470	443		if ((0x7fffffe87fffffeL & l) != 0L)
471	444		{
472		-	if (kind > 25)
473		-	kind = 25;
474		-	{ jjCheckNAdd(58); }
	445	+	if (kind > 23)
	446	+	kind = 23;
	447	+	{ jjCheckNAdd(48); }
475	448		}
476	449		else if (curChar == 94)
477	450		{
		skipped 3 lines
481	454		else if (curChar == 124)
482	455		jjstateSet[jjnewStateCnt++] = 4;
483	456		if ((0x400000004000L & l) != 0L)
484		-	jjstateSet[jjnewStateCnt++] = 56;
	457	+	jjstateSet[jjnewStateCnt++] = 46;
485	458		else if ((0x4000000040L & l) != 0L)
486	459		jjstateSet[jjnewStateCnt++] = 24;
487	460		else if ((0x10000000100000L & l) != 0L)
		skipped 87 lines
575	548		if ((0x4000000040L & l) != 0L)
576	549		jjstateSet[jjnewStateCnt++] = 24;
577	550		break;
578		-	case 27:
	551	+	case 30:
	552	+	if ((0x2000000020000L & l) != 0L)
	553	+	{ jjCheckNAddStates(0, 2); }
	554	+	break;
	555	+	case 31:
579	556		if (curChar == 92)
580		-	jjstateSet[jjnewStateCnt++] = 28;
581		-	break;
582		-	case 28:
583		-	{ jjCheckNAddStates(3, 5); }
584		-	break;
585		-	case 29:
586		-	if ((0xffffffffefffffffL & l) != 0L)
587		-	{ jjCheckNAddStates(3, 5); }
	557	+	jjstateSet[jjnewStateCnt++] = 32;
588	558		break;
589	559		case 32:
590		-	if (curChar == 92)
591		-	jjstateSet[jjnewStateCnt++] = 33;
	560	+	if ((0xffffffdfffffffdfL & l) != 0L)
	561	+	{ jjCheckNAddStates(0, 2); }
592	562		break;
593	563		case 33:
594		-	{ jjCheckNAddStates(0, 2); }
595		-	break;
596		-	case 34:
597	564		if ((0xffffffffefffffffL & l) != 0L)
598	565		{ jjCheckNAddStates(0, 2); }
599	566		break;
600		-	case 40:
601		-	if ((0x2000000020000L & l) != 0L)
602		-	{ jjCheckNAddStates(6, 8); }
603		-	break;
604		-	case 41:
605		-	if (curChar == 92)
606		-	jjstateSet[jjnewStateCnt++] = 42;
607		-	break;
608		-	case 42:
609		-	if ((0xffffffdfffffffdfL & l) != 0L)
610		-	{ jjCheckNAddStates(6, 8); }
611		-	break;
612		-	case 43:
613		-	if ((0xffffffffefffffffL & l) != 0L)
614		-	{ jjCheckNAddStates(6, 8); }
615		-	break;
616		-	case 45:
	567	+	case 35:
617	568		if ((0x2000000020L & l) != 0L)
618		-	jjstateSet[jjnewStateCnt++] = 44;
	569	+	jjstateSet[jjnewStateCnt++] = 34;
619	570		break;
620		-	case 46:
	571	+	case 36:
621	572		if (curChar == 92)
622		-	jjstateSet[jjnewStateCnt++] = 45;
	573	+	jjstateSet[jjnewStateCnt++] = 35;
623	574		break;
624		-	case 47:
	575	+	case 37:
625	576		if (curChar == 92)
626		-	jjstateSet[jjnewStateCnt++] = 40;
	577	+	jjstateSet[jjnewStateCnt++] = 30;
627	578		break;
628		-	case 50:
	579	+	case 40:
629	580		if (curChar == 92)
630		-	jjstateSet[jjnewStateCnt++] = 51;
	581	+	jjstateSet[jjnewStateCnt++] = 41;
631	582		break;
632		-	case 51:
633		-	{ jjCheckNAddStates(9, 11); }
	583	+	case 41:
	584	+	{ jjCheckNAddStates(3, 5); }
634	585		break;
635		-	case 52:
	586	+	case 42:
636	587		if ((0xffffffffefffffffL & l) != 0L)
637		-	{ jjCheckNAddStates(9, 11); }
	588	+	{ jjCheckNAddStates(3, 5); }
638	589		break;
639		-	case 55:
640		-	if ((0x10000000100000L & l) != 0L && kind > 23)
641		-	kind = 23;
	590	+	case 45:
	591	+	if ((0x10000000100000L & l) != 0L && kind > 21)
	592	+	kind = 21;
642	593		break;
643		-	case 56:
	594	+	case 46:
644	595		if ((0x800000008000L & l) != 0L)
645		-	jjstateSet[jjnewStateCnt++] = 55;
	596	+	jjstateSet[jjnewStateCnt++] = 45;
646	597		break;
647		-	case 57:
	598	+	case 47:
648	599		if ((0x400000004000L & l) != 0L)
649		-	jjstateSet[jjnewStateCnt++] = 56;
	600	+	jjstateSet[jjnewStateCnt++] = 46;
650	601		break;
651		-	case 58:
	602	+	case 48:
652	603		if ((0x7fffffe87fffffeL & l) == 0L)
653	604		break;
654		-	if (kind > 25)
655		-	kind = 25;
656		-	{ jjCheckNAdd(58); }
	605	+	if (kind > 23)
	606	+	kind = 23;
	607	+	{ jjCheckNAdd(48); }
657	608		break;
658	609		default : break;
659	610		}
		skipped 7 lines
667	618		{
668	619		switch(jjstateSet[--i])
669	620		{
670		-	case 28:
671		-	case 29:
672		-	if ((jjbitVec0[i2] & l2) != 0L)
673		-	{ jjCheckNAddStates(3, 5); }
674		-	break;
	621	+	case 32:
675	622		case 33:
676		-	case 34:
677	623		if ((jjbitVec0[i2] & l2) != 0L)
678	624		{ jjCheckNAddStates(0, 2); }
679	625		break;
	626	+	case 41:
680	627		case 42:
681		-	case 43:
682	628		if ((jjbitVec0[i2] & l2) != 0L)
683		-	{ jjCheckNAddStates(6, 8); }
684		-	break;
685		-	case 51:
686		-	case 52:
687		-	if ((jjbitVec0[i2] & l2) != 0L)
688		-	{ jjCheckNAddStates(9, 11); }
	629	+	{ jjCheckNAddStates(3, 5); }
689	630		break;
690	631		default : break;
691	632		}
		skipped 6 lines
698	639		kind = 0x7fffffff;
699	640		}
700	641		++curPos;
701		-	if ((i = jjnewStateCnt) == (startsAt = 59 - (jjnewStateCnt = startsAt)))
	642	+	if ((i = jjnewStateCnt) == (startsAt = 49 - (jjnewStateCnt = startsAt)))
702	643		break;
703	644		try { curChar = input_stream.readChar(); }
704	645		catch(java.io.IOException e) { break; }
		skipped 18 lines
723	664
724	665		return toRet;
725	666		}
	667	+	private final int jjStopStringLiteralDfa_1(int pos, long active0){
	668	+	switch (pos)
	669	+	{
	670	+	default :
	671	+	return -1;
	672	+	}
	673	+	}
	674	+	private final int jjStartNfa_1(int pos, long active0){
	675	+	return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
	676	+	}
	677	+	private int jjMoveStringLiteralDfa0_1(){
	678	+	switch(curChar)
	679	+	{
	680	+	case 39:
	681	+	return jjStopAtPos(0, 31);
	682	+	default :
	683	+	return jjMoveNfa_1(3, 0);
	684	+	}
	685	+	}
	686	+	private int jjMoveNfa_1(int startState, int curPos)
	687	+	{
	688	+	int startsAt = 0;
	689	+	jjnewStateCnt = 3;
	690	+	int i = 1;
	691	+	jjstateSet[0] = startState;
	692	+	int kind = 0x7fffffff;
	693	+	for (;;)
	694	+	{
	695	+	if (++jjround == 0x7fffffff)
	696	+	ReInitRounds();
	697	+	if (curChar < 64)
	698	+	{
	699	+	long l = 1L << curChar;
	700	+	do
	701	+	{
	702	+	switch(jjstateSet[--i])
	703	+	{
	704	+	case 3:
	705	+	case 2:
	706	+	if ((0xffffff7fffffffffL & l) == 0L)
	707	+	break;
	708	+	if (kind > 30)
	709	+	kind = 30;
	710	+	{ jjCheckNAddTwoStates(0, 2); }
	711	+	break;
	712	+	case 1:
	713	+	if (kind > 30)
	714	+	kind = 30;
	715	+	{ jjCheckNAddTwoStates(0, 2); }
	716	+	break;
	717	+	default : break;
	718	+	}
	719	+	} while(i != startsAt);
	720	+	}
	721	+	else if (curChar < 128)
	722	+	{
	723	+	long l = 1L << (curChar & 077);
	724	+	do
	725	+	{
	726	+	switch(jjstateSet[--i])
	727	+	{
	728	+	case 3:
	729	+	if ((0xffffffffefffffffL & l) != 0L)
	730	+	{
	731	+	if (kind > 30)
	732	+	kind = 30;
	733	+	{ jjCheckNAddTwoStates(0, 2); }
	734	+	}
	735	+	else if (curChar == 92)
	736	+	jjstateSet[jjnewStateCnt++] = 1;
	737	+	break;
	738	+	case 0:
	739	+	if (curChar == 92)
	740	+	jjstateSet[jjnewStateCnt++] = 1;
	741	+	break;
	742	+	case 1:
	743	+	if (kind > 30)
	744	+	kind = 30;
	745	+	{ jjCheckNAddTwoStates(0, 2); }
	746	+	break;
	747	+	case 2:
	748	+	if ((0xffffffffefffffffL & l) == 0L)
	749	+	break;
	750	+	if (kind > 30)
	751	+	kind = 30;
	752	+	{ jjCheckNAddTwoStates(0, 2); }
	753	+	break;
	754	+	default : break;
	755	+	}
	756	+	} while(i != startsAt);
	757	+	}
	758	+	else
	759	+	{
	760	+	int i2 = (curChar & 0xff) >> 6;
	761	+	long l2 = 1L << (curChar & 077);
	762	+	do
	763	+	{
	764	+	switch(jjstateSet[--i])
	765	+	{
	766	+	case 3:
	767	+	case 2:
	768	+	case 1:
	769	+	if ((jjbitVec0[i2] & l2) == 0L)
	770	+	break;
	771	+	if (kind > 30)
	772	+	kind = 30;
	773	+	{ jjCheckNAddTwoStates(0, 2); }
	774	+	break;
	775	+	default : break;
	776	+	}
	777	+	} while(i != startsAt);
	778	+	}
	779	+	if (kind != 0x7fffffff)
	780	+	{
	781	+	jjmatchedKind = kind;
	782	+	jjmatchedPos = curPos;
	783	+	kind = 0x7fffffff;
	784	+	}
	785	+	++curPos;
	786	+	if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
	787	+	return curPos;
	788	+	try { curChar = input_stream.readChar(); }
	789	+	catch(java.io.IOException e) { return curPos; }
	790	+	}
	791	+	}
	792	+	private final int jjStopStringLiteralDfa_2(int pos, long active0){
	793	+	switch (pos)
	794	+	{
	795	+	default :
	796	+	return -1;
	797	+	}
	798	+	}
	799	+	private final int jjStartNfa_2(int pos, long active0){
	800	+	return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
	801	+	}
	802	+	private int jjMoveStringLiteralDfa0_2(){
	803	+	switch(curChar)
	804	+	{
	805	+	case 34:
	806	+	return jjStopAtPos(0, 33);
	807	+	default :
	808	+	return jjMoveNfa_2(3, 0);
	809	+	}
	810	+	}
	811	+	private int jjMoveNfa_2(int startState, int curPos)
	812	+	{
	813	+	int startsAt = 0;
	814	+	jjnewStateCnt = 3;
	815	+	int i = 1;
	816	+	jjstateSet[0] = startState;
	817	+	int kind = 0x7fffffff;
	818	+	for (;;)
	819	+	{
	820	+	if (++jjround == 0x7fffffff)
	821	+	ReInitRounds();
	822	+	if (curChar < 64)
	823	+	{
	824	+	long l = 1L << curChar;
	825	+	do
	826	+	{
	827	+	switch(jjstateSet[--i])
	828	+	{
	829	+	case 3:
	830	+	case 2:
	831	+	if ((0xfffffffbffffffffL & l) == 0L)
	832	+	break;
	833	+	if (kind > 32)
	834	+	kind = 32;
	835	+	{ jjCheckNAddTwoStates(0, 2); }
	836	+	break;
	837	+	case 1:
	838	+	if (kind > 32)
	839	+	kind = 32;
	840	+	{ jjCheckNAddTwoStates(0, 2); }
	841	+	break;
	842	+	default : break;
	843	+	}
	844	+	} while(i != startsAt);
	845	+	}
	846	+	else if (curChar < 128)
	847	+	{
	848	+	long l = 1L << (curChar & 077);
	849	+	do
	850	+	{
	851	+	switch(jjstateSet[--i])
	852	+	{
	853	+	case 3:
	854	+	if ((0xffffffffefffffffL & l) != 0L)
	855	+	{
	856	+	if (kind > 32)
	857	+	kind = 32;
	858	+	{ jjCheckNAddTwoStates(0, 2); }
	859	+	}
	860	+	else if (curChar == 92)
	861	+	jjstateSet[jjnewStateCnt++] = 1;
	862	+	break;
	863	+	case 0:
	864	+	if (curChar == 92)
	865	+	jjstateSet[jjnewStateCnt++] = 1;
	866	+	break;
	867	+	case 1:
	868	+	if (kind > 32)
	869	+	kind = 32;
	870	+	{ jjCheckNAddTwoStates(0, 2); }
	871	+	break;
	872	+	case 2:
	873	+	if ((0xffffffffefffffffL & l) == 0L)
	874	+	break;
	875	+	if (kind > 32)
	876	+	kind = 32;
	877	+	{ jjCheckNAddTwoStates(0, 2); }
	878	+	break;
	879	+	default : break;
	880	+	}
	881	+	} while(i != startsAt);
	882	+	}
	883	+	else
	884	+	{
	885	+	int i2 = (curChar & 0xff) >> 6;
	886	+	long l2 = 1L << (curChar & 077);
	887	+	do
	888	+	{
	889	+	switch(jjstateSet[--i])
	890	+	{
	891	+	case 3:
	892	+	case 2:
	893	+	case 1:
	894	+	if ((jjbitVec0[i2] & l2) == 0L)
	895	+	break;
	896	+	if (kind > 32)
	897	+	kind = 32;
	898	+	{ jjCheckNAddTwoStates(0, 2); }
	899	+	break;
	900	+	default : break;
	901	+	}
	902	+	} while(i != startsAt);
	903	+	}
	904	+	if (kind != 0x7fffffff)
	905	+	{
	906	+	jjmatchedKind = kind;
	907	+	jjmatchedPos = curPos;
	908	+	kind = 0x7fffffff;
	909	+	}
	910	+	++curPos;
	911	+	if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
	912	+	return curPos;
	913	+	try { curChar = input_stream.readChar(); }
	914	+	catch(java.io.IOException e) { return curPos; }
	915	+	}
	916	+	}
726	917
727	918		/** Token literal values. */
728	919		public static final String[] jjstrLiteralImages = {
729	920		"", null, null, "\41\75", "\76", "\74", "\76\75", "\74\75", null, null, null,
730		-	null, null, null, null, null, null, null, null, null, null, "\50", "\51", null,
731		-	"\56", null, "\133", "\135", "\54", "\43", };
	921	+	null, null, null, null, null, null, null, null, "\50", "\51", null, "\56", null,
	922	+	"\133", "\135", "\54", "\43", "\47", "\42", null, "\47", null, "\42", null, };
732	923		protected Token jjFillToken()
733	924		{
734	925		final Token t;
		skipped 18 lines
753	944		return t;
754	945		}
755	946		static final int[] jjnextStates = {
756		-	32, 34, 35, 27, 29, 30, 41, 43, 46, 50, 52, 53,
	947	+	31, 33, 36, 40, 42, 43,
757	948		};
758	949
759	950		int curLexState = 0;
		skipped 24 lines
784	975		return matchedToken;
785	976		}
786	977
787		-	jjmatchedKind = 0x7fffffff;
788		-	jjmatchedPos = 0;
789		-	curPos = jjMoveStringLiteralDfa0_0();
790		-	if (jjmatchedKind != 0x7fffffff)
	978	+	switch(curLexState)
791	979		{
792		-	if (jjmatchedPos + 1 < curPos)
793		-	input_stream.backup(curPos - jjmatchedPos - 1);
794		-	if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
795		-	{
796		-	matchedToken = jjFillToken();
797		-	return matchedToken;
798		-	}
799		-	else
800		-	{
801		-	continue EOFLoop;
802		-	}
	980	+	case 0:
	981	+	jjmatchedKind = 0x7fffffff;
	982	+	jjmatchedPos = 0;
	983	+	curPos = jjMoveStringLiteralDfa0_0();
	984	+	if (jjmatchedPos == 0 && jjmatchedKind > 34)
	985	+	{
	986	+	jjmatchedKind = 34;
	987	+	}
	988	+	break;
	989	+	case 1:
	990	+	jjmatchedKind = 0x7fffffff;
	991	+	jjmatchedPos = 0;
	992	+	curPos = jjMoveStringLiteralDfa0_1();
	993	+	if (jjmatchedPos == 0 && jjmatchedKind > 34)
	994	+	{
	995	+	jjmatchedKind = 34;
	996	+	}
	997	+	break;
	998	+	case 2:
	999	+	jjmatchedKind = 0x7fffffff;
	1000	+	jjmatchedPos = 0;
	1001	+	curPos = jjMoveStringLiteralDfa0_2();
	1002	+	if (jjmatchedPos == 0 && jjmatchedKind > 34)
	1003	+	{
	1004	+	jjmatchedKind = 34;
	1005	+	}
	1006	+	break;
803	1007		}
804		-	int error_line = input_stream.getEndLine();
805		-	int error_column = input_stream.getEndColumn();
806		-	String error_after = null;
807		-	boolean EOFSeen = false;
808		-	try { input_stream.readChar(); input_stream.backup(1); }
809		-	catch (java.io.IOException e1) {
810		-	EOFSeen = true;
811		-	error_after = curPos <= 1 ? "" : input_stream.GetImage();
812		-	if (curChar == '\n' \|\| curChar == '\r') {
813		-	error_line++;
814		-	error_column = 0;
815		-	}
816		-	else
817		-	error_column++;
818		-	}
819		-	if (!EOFSeen) {
820		-	input_stream.backup(1);
821		-	error_after = curPos <= 1 ? "" : input_stream.GetImage();
822		-	}
823		-	throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
	1008	+	if (jjmatchedKind != 0x7fffffff)
	1009	+	{
	1010	+	if (jjmatchedPos + 1 < curPos)
	1011	+	input_stream.backup(curPos - jjmatchedPos - 1);
	1012	+	if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
	1013	+	{
	1014	+	matchedToken = jjFillToken();
	1015	+	if (jjnewLexState[jjmatchedKind] != -1)
	1016	+	curLexState = jjnewLexState[jjmatchedKind];
	1017	+	return matchedToken;
	1018	+	}
	1019	+	else
	1020	+	{
	1021	+	if (jjnewLexState[jjmatchedKind] != -1)
	1022	+	curLexState = jjnewLexState[jjmatchedKind];
	1023	+	continue EOFLoop;
	1024	+	}
	1025	+	}
	1026	+	int error_line = input_stream.getEndLine();
	1027	+	int error_column = input_stream.getEndColumn();
	1028	+	String error_after = null;
	1029	+	boolean EOFSeen = false;
	1030	+	try { input_stream.readChar(); input_stream.backup(1); }
	1031	+	catch (java.io.IOException e1) {
	1032	+	EOFSeen = true;
	1033	+	error_after = curPos <= 1 ? "" : input_stream.GetImage();
	1034	+	if (curChar == '\n' \|\| curChar == '\r') {
	1035	+	error_line++;
	1036	+	error_column = 0;
	1037	+	}
	1038	+	else
	1039	+	error_column++;
	1040	+	}
	1041	+	if (!EOFSeen) {
	1042	+	input_stream.backup(1);
	1043	+	error_after = curPos <= 1 ? "" : input_stream.GetImage();
	1044	+	}
	1045	+	throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
824	1046		}
825	1047		}
826	1048
		skipped 82 lines
909	1131		{
910	1132		int i;
911	1133		jjround = 0x80000001;
912		-	for (i = 59; i-- > 0;)
	1134	+	for (i = 49; i-- > 0;)
913	1135		jjrounds[i] = 0x80000000;
914	1136		}
915	1137
		skipped 8 lines
924	1146		/** Switch to specified lex state. */
925	1147		public void SwitchTo(int lexState)
926	1148		{
927		-	if (lexState >= 1 \|\| lexState < 0)
	1149	+	if (lexState >= 3 \|\| lexState < 0)
928	1150		throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
929	1151		else
930	1152		curLexState = lexState;
		skipped 3 lines
934	1156		/** Lexer state names. */
935	1157		public static final String[] lexStateNames = {
936	1158		"DEFAULT",
	1159	+	"SINGLE_QUOTED_STRING",
	1160	+	"DOUBLE_QUOTED_STRING",
937	1161		};
938	1162
939	1163		/** Lex State array. */
940	1164		public static final int[] jjnewLexState = {
941	1165		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
942		-	-1, -1, -1, -1, -1,
	1166	+	-1, -1, -1, 1, 2, -1, 0, -1, 0, -1,
943	1167		};
944	1168		static final long[] jjtoToken = {
945		-	0x3ffffffdL,
	1169	+	0x7fffffffdL,
946	1170		};
947	1171		static final long[] jjtoSkip = {
948	1172		0x2L,
		skipped 6 lines
955	1179		};
956	1180		protected SimpleCharStream input_stream;
957	1181
958		-	private final int[] jjrounds = new int[59];
959		-	private final int[] jjstateSet = new int[2 * 59];
	1182	+	private final int[] jjrounds = new int[49];
	1183	+	private final int[] jjstateSet = new int[2 * 49];
960	1184		private final StringBuilder jjimage = new StringBuilder();
961	1185		private StringBuilder image = jjimage;
962	1186		private int jjimageLen;
		skipped 4 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filter/savedfilter/SavedFilter.java

		skipped 12 lines
13	13		private String filterString;
14	14
15	15		public SavedFilter(FilterLibraryController filterLibraryController, String name, String filterString) throws ParseException {
16		-	this.name = name.replaceAll("[^a-zA-Z0-9]", "_");
	16	+	this.name = name.replaceAll("[^a-zA-Z0-9_.]", "_");
17	17		this.setFilter(new LogFilter(filterLibraryController, filterString));
18	18		}
19	19
		skipped 12 lines
32	32		}
33	33
34	34		public void setName(String name) {
35		-	name = name.replaceAll("[^a-zA-Z0-9]", "_");
	35	+	name = name.replaceAll("[^a-zA-Z0-9_.]", "_");
36	36		this.name = name;
37	37		}
38	38
		skipped 24 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/filterlibrary/FilterLibraryTableModel.java

		skipped 14 lines
15	15		private final FilterLibraryController controller;
16	16		JButton btnApplyFilter;
17	17		JButton btnSetColorFilter;
18		-	private final String[] columnNames = {"Title", "LogFilter", "", ""};
	18	+	private final String[] columnNames = {"Alias", "LogFilter", "", ""};
19	19
20	20		public FilterLibraryTableModel(FilterLibraryController controller){
21	21		this.controller = controller;
		skipped 44 lines
66	66		if(savedFilter == null) return;
67	67		if(column == 0) {
68	68		savedFilter.setName((String) value);
	69	+	if(!((String) value).equalsIgnoreCase(savedFilter.getName())){
	70	+	JOptionPane.showMessageDialog(BurpExtender.instance.getUiComponent(), "Alias names may only contain alphanumeric characters and the symbols period (.) and underscore (_)\n" +
	71	+	"Invalid characters have been replaced with an underscore.", "Alias Error", JOptionPane.WARNING_MESSAGE);
	72	+	}
69	73		}
70	74		if(column == 1){
71	75		try{
		skipped 2 lines
74	78		//Not a valid filter...
75	79		savedFilter.setFilterString((String) value);
76	80		savedFilter.setFilter(null);
77		-	JOptionPane.showMessageDialog(JOptionPane.getFrameForComponent(BurpExtender.instance.getUiComponent()), e.getMessage(), "Filter Exception", JOptionPane.ERROR_MESSAGE);
	81	+	JOptionPane.showMessageDialog(BurpExtender.instance.getUiComponent(), e.getMessage(), "Filter Exception", JOptionPane.ERROR_MESSAGE);
78	82		}
79	83		}
80	84		controller.saveFilters();
		skipped 42 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/logentry/LogEntryField.java

1	1		package com.nccgroup.loggerplusplus.logentry;
2	2
3		-	import java.util.Arrays;
4		-	import java.util.Date;
5		-	import java.util.HashMap;
	3	+	import java.util.*;
6	4
7	5		public enum LogEntryField {
8	6
9	7		//Proxy
10		-	NUMBER(FieldGroup.PROXY, Integer.class, "Number"),
11		-	PROXY_TOOL(FieldGroup.PROXY, String.class, "Tool"),
12		-	LISTENER_INTERFACE(FieldGroup.PROXY, String.class, "ListenInterface", "Interface"),
13		-	CLIENT_IP(FieldGroup.PROXY, String.class, "ClientIP", "ClientAddress"),
14		-	USES_COOKIE_JAR_PROXY(FieldGroup.PROXY, String.class, "UsesCookieJar", "CookieJar"),
15		-	COMMENT(FieldGroup.PROXY, String.class, "Comment"),
	8	+	NUMBER(FieldGroup.PROXY, Integer.class, "", "Number"),
	9	+	PROXY_TOOL(FieldGroup.PROXY, String.class, "", "Tool"),
	10	+	LISTENER_INTERFACE(FieldGroup.PROXY, String.class, "", "ListenInterface", "Interface"),
	11	+	CLIENT_IP(FieldGroup.PROXY, String.class, "", "ClientIP", "ClientAddress"),
	12	+	USES_COOKIE_JAR_PROXY(FieldGroup.PROXY, String.class, "", "UsesCookieJar", "CookieJar"),
	13	+	COMMENT(FieldGroup.PROXY, String.class, "", "Comment"),
16	14
17	15		//Request + Response
18		-	REQUEST_HEADERS(FieldGroup.REQUEST, String.class, "Headers"),
19		-	RESPONSE_HEADERS(FieldGroup.RESPONSE, String.class, "Headers"),
20		-	REQUEST_BODY(FieldGroup.REQUEST, String.class, "Body"),
21		-	RESPONSE_BODY(FieldGroup.RESPONSE, String.class, "Body"),
22		-	REQUEST_TIME(FieldGroup.REQUEST, Date.class, "Time"),
23		-	RESPONSE_TIME(FieldGroup.RESPONSE, Date.class, "Time"),
24		-	REQUEST_LENGTH(FieldGroup.REQUEST, Integer.class, "Length"),
25		-	RESPONSE_LENGTH(FieldGroup.RESPONSE, Integer.class, "Length"),
	16	+	REQUEST_HEADERS(FieldGroup.REQUEST, String.class, "", "Headers"),
	17	+	RESPONSE_HEADERS(FieldGroup.RESPONSE, String.class, "", "Headers"),
	18	+	REQUEST_BODY(FieldGroup.REQUEST, String.class, "", "Body"),
	19	+	RESPONSE_BODY(FieldGroup.RESPONSE, String.class, "", "Body"),
	20	+	REQUEST_TIME(FieldGroup.REQUEST, Date.class, "", "Time"),
	21	+	RESPONSE_TIME(FieldGroup.RESPONSE, Date.class, "", "Time"),
	22	+	REQUEST_LENGTH(FieldGroup.REQUEST, Integer.class, "", "Length"),
	23	+	RESPONSE_LENGTH(FieldGroup.RESPONSE, Integer.class, "", "Length"),
26	24
27	25
28	26		//Request
29		-	REQUEST_TOOL(FieldGroup.REQUEST, String.class, "Tool"), //Alias for proxy.tool
30		-	COMPLETE(FieldGroup.REQUEST, Boolean.class, "Complete", "isComplete"),
31		-	URL(FieldGroup.REQUEST, String.class, "URL"),
32		-	METHOD(FieldGroup.REQUEST, String.class, "Method"),
33		-	PATH(FieldGroup.REQUEST, String.class, "Path"),
34		-	QUERY(FieldGroup.REQUEST, String.class, "Query"),
35		-	PROTOCOL(FieldGroup.REQUEST, String.class, "Protocol"),
36		-	ISSSL(FieldGroup.REQUEST, Boolean.class, "IsSSL", "ssl"),
37		-	REQUEST_USES_COOKIE_JAR(FieldGroup.REQUEST, String.class, "UsesCookieJar", "CookieJar"), //Alias for proxy.usescookiejar
38		-	HOSTNAME(FieldGroup.REQUEST, String.class, "Hostname"),
39		-	HOST(FieldGroup.REQUEST, String.class, "Host"),
40		-	PORT(FieldGroup.REQUEST, Short.class, "Port"),
41		-	REQUEST_CONTENT_TYPE(FieldGroup.REQUEST, String.class, "ContentType", "Content_Type"),
42		-	EXTENSION(FieldGroup.REQUEST, String.class, "Extension"),
43		-	REFERRER(FieldGroup.REQUEST, String.class, "Referrer"),
44		-	HASPARAMS(FieldGroup.REQUEST, Boolean.class, "HasParams", "Has_Params"),
45		-	HASGETPARAM(FieldGroup.REQUEST, Boolean.class, "HasGetParam", "HasQueryString", "QueryString"),
46		-	HASPOSTPARAM(FieldGroup.REQUEST, Boolean.class, "HasPostParam", "HasPayload", "Payload"),
47		-	HASCOOKIEPARAM(FieldGroup.REQUEST, Boolean.class, "HasSentCookies"),
48		-	SENTCOOKIES(FieldGroup.REQUEST, Boolean.class, "CookieString", "SentCookies", "Cookies"),
	27	+	REQUEST_TOOL(FieldGroup.REQUEST, String.class, "The tool used to initiate the request.", "Tool"), //Alias for proxy.tool
	28	+	COMPLETE(FieldGroup.REQUEST, Boolean.class, "", "Complete", "isComplete"),
	29	+	URL(FieldGroup.REQUEST, String.class, "", "URL"),
	30	+	METHOD(FieldGroup.REQUEST, String.class, "", "Method"),
	31	+	PATH(FieldGroup.REQUEST, String.class, "", "Path"),
	32	+	QUERY(FieldGroup.REQUEST, String.class, "", "Query"),
	33	+	PROTOCOL(FieldGroup.REQUEST, String.class, "", "Protocol"),
	34	+	ISSSL(FieldGroup.REQUEST, Boolean.class, "", "IsSSL", "ssl"),
	35	+	REQUEST_USES_COOKIE_JAR(FieldGroup.REQUEST, String.class, "", "UsesCookieJar", "CookieJar"), //Alias for proxy.usescookiejar
	36	+	HOSTNAME(FieldGroup.REQUEST, String.class, "", "Hostname"),
	37	+	HOST(FieldGroup.REQUEST, String.class, "", "Host"),
	38	+	PORT(FieldGroup.REQUEST, Short.class, "", "Port"),
	39	+	REQUEST_CONTENT_TYPE(FieldGroup.REQUEST, String.class, "", "ContentType", "Content_Type"),
	40	+	EXTENSION(FieldGroup.REQUEST, String.class, "", "Extension"),
	41	+	REFERRER(FieldGroup.REQUEST, String.class, "", "Referrer"),
	42	+	HASPARAMS(FieldGroup.REQUEST, Boolean.class, "", "HasParams", "Has_Params"),
	43	+	HASGETPARAM(FieldGroup.REQUEST, Boolean.class, "", "HasGetParam", "HasQueryString", "QueryString"),
	44	+	HASPOSTPARAM(FieldGroup.REQUEST, Boolean.class, "", "HasPostParam", "HasPayload", "Payload"),
	45	+	HASCOOKIEPARAM(FieldGroup.REQUEST, Boolean.class, "", "HasSentCookies"),
	46	+	SENTCOOKIES(FieldGroup.REQUEST, Boolean.class, "", "CookieString", "SentCookies", "Cookies"),
49	47
50	48
51	49		//Response
52		-	STATUS(FieldGroup.RESPONSE, Short.class, "Status"),
53		-	RTT(FieldGroup.RESPONSE, Integer.class, "RTT", "TimeTaken"),
54		-	TITLE(FieldGroup.RESPONSE, String.class, "Title"),
55		-	RESPONSE_CONTENT_TYPE(FieldGroup.RESPONSE, String.class, "ContentType", "Content_Type"),
56		-	MIME_TYPE(FieldGroup.RESPONSE, String.class, "MimeType", "Mime_Type"),
57		-	INFERRED_TYPE(FieldGroup.RESPONSE, String.class, "InferredType", "Inferred_Type"),
58		-	HAS_SET_COOKIES(FieldGroup.RESPONSE, Boolean.class, "HasSetCookies", "Has_Set_Cookies"),
59		-	NEW_COOKIES(FieldGroup.RESPONSE, String.class, "NewCookies", "New_Cookies");
	50	+	STATUS(FieldGroup.RESPONSE, Short.class, "", "Status"),
	51	+	RTT(FieldGroup.RESPONSE, Integer.class, "", "RTT", "TimeTaken"),
	52	+	TITLE(FieldGroup.RESPONSE, String.class, "", "Title"),
	53	+	RESPONSE_CONTENT_TYPE(FieldGroup.RESPONSE, String.class, "", "ContentType", "Content_Type"),
	54	+	MIME_TYPE(FieldGroup.RESPONSE, String.class, "", "MimeType", "Mime_Type"),
	55	+	INFERRED_TYPE(FieldGroup.RESPONSE, String.class, "", "InferredType", "Inferred_Type"),
	56	+	HAS_SET_COOKIES(FieldGroup.RESPONSE, Boolean.class, "", "HasSetCookies", "Has_Set_Cookies"),
	57	+	NEW_COOKIES(FieldGroup.RESPONSE, String.class, "", "NewCookies", "New_Cookies");
60	58
61	59		private static final HashMap<FieldGroup, HashMap<String, LogEntryField>> completeGroupFieldMap = new HashMap<>();
62	60		private static final HashMap<FieldGroup, HashMap<String, LogEntryField>> shortGroupFieldMap = new HashMap<>();
63	61
64	62		static {
65	63		for (FieldGroup fieldGroup : FieldGroup.values()) {
66		-	completeGroupFieldMap.put(fieldGroup, new HashMap<>());
67		-	shortGroupFieldMap.put(fieldGroup, new HashMap<>());
	64	+	completeGroupFieldMap.put(fieldGroup, new LinkedHashMap<>());
	65	+	shortGroupFieldMap.put(fieldGroup, new LinkedHashMap<>());
68	66		}
69	67
70	68		for (LogEntryField field : LogEntryField.values()) {
71		-	shortGroupFieldMap.get(field.fieldGroup).put(field.labels[0].toUpperCase(), field);
	69	+	shortGroupFieldMap.get(field.fieldGroup).put(field.labels[0], field);
72	70		for (String label : field.labels) {
73		-	completeGroupFieldMap.get(field.fieldGroup).put(label.toUpperCase(), field);
	71	+	completeGroupFieldMap.get(field.fieldGroup).put(label.toLowerCase(), field);
74	72		}
75	73		}
76	74		}
		skipped 1 lines
78	76
79	77		private FieldGroup fieldGroup;
80	78		private Class<?> type;
	79	+	private String description;
81	80		private String[] labels;
82	81
83	82
84		-	LogEntryField(FieldGroup fieldGroup, Class<?> type, String... labels){
	83	+	LogEntryField(FieldGroup fieldGroup, Class<?> type, String description, String... labels){
85	84		this.fieldGroup = fieldGroup;
86	85		this.type = type;
	86	+	this.description = description;
87	87		this.labels = labels;
88	88		}
89	89
		skipped 19 lines
109	109
110	110		public static LogEntryField getByLabel(FieldGroup fieldGroup, String searchLabel){
111	111		HashMap<String, LogEntryField> groupFields = completeGroupFieldMap.get(fieldGroup);
112		-	return groupFields != null ? groupFields.get(searchLabel.toUpperCase()) : null;
	112	+	return groupFields != null ? groupFields.get(searchLabel.toLowerCase()) : null;
113	113		}
114	114
115		-	public static HashMap<String, LogEntryField> getFieldsInGroup(FieldGroup fieldGroup){
116		-	return completeGroupFieldMap.get(fieldGroup);
	115	+	public static Collection<LogEntryField> getFieldsInGroup(FieldGroup fieldGroup){
	116	+	return shortGroupFieldMap.get(fieldGroup).values();
117	117		}
118	118
119	119		public static LogEntryField getByFullyQualifiedName(String fqn){
120	120		String[] split = fqn.split("\\.");
121	121		FieldGroup group = FieldGroup.findByLabel(split[0]);
122	122		return getByLabel(group, split[1]);
	123	+	}
	124	+
	125	+	public String getDescriptiveMessage(){
	126	+	return String.format("Field: %s\nDescription: %s", String.join(", ", labels), description);
123	127		}
124	128
125	129		@Override
		skipped 6 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/logview/LogViewPanel.java

		skipped 38 lines
39	39		scrollBar.getValue() + scrollBar.getHeight() >= scrollBar.getMaximum());
40	40		}
41	41		});
42		-	logTableScrollPane.getVerticalScrollBar().addMouseListener(new MouseListener() {
43		-	@Override
44		-	public void mouseClicked(MouseEvent mouseEvent) {}
45		-	@Override
46		-	public void mousePressed(MouseEvent mouseEvent) {}
	42	+	logTableScrollPane.getVerticalScrollBar().addMouseListener(new MouseAdapter() {
47	43		@Override
48	44		public void mouseReleased(MouseEvent mouseEvent) {
49	45		JScrollBar scrollBar = logTableScrollPane.getVerticalScrollBar();
50	46		LoggerPlusPlus.preferences.setSetting(Globals.PREF_AUTO_SCROLL,
51	47		scrollBar.getValue() + scrollBar.getHeight() >= scrollBar.getMaximum());
52	48		}
53		-	@Override
54		-	public void mouseEntered(MouseEvent mouseEvent) {}
55		-	@Override
56		-	public void mouseExited(MouseEvent mouseEvent) {}
57	49		});
58	50
59	51		this.add(this.logTableScrollPane, BorderLayout.CENTER);
		skipped 59 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/logview/logtable/LogTable.java

		skipped 17 lines
18	18		import com.nccgroup.loggerplusplus.userinterface.LogTableModel;
19	19		import com.nccgroup.loggerplusplus.userinterface.renderer.BooleanRenderer;
20	20		import com.nccgroup.loggerplusplus.util.Globals;
	21	+	import org.jdesktop.swingx.JXTable;
21	22
22	23		import javax.swing.*;
23	24		import javax.swing.event.RowSorterEvent;
		skipped 304 lines

■ ■ ■ ■ ■ ■

src/main/java/com/nccgroup/loggerplusplus/util/MoreHelp.java

		skipped 4 lines
5	5		import com.nccgroup.loggerplusplus.LoggerPlusPlus;
6	6
7	7		import javax.swing.*;
	8	+	import java.awt.*;
8	9		import java.io.InputStream;
9	10		import java.io.UnsupportedEncodingException;
10	11		import java.net.URL;
		skipped 204 lines

Filter parser improvements, error message improvements