You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@metron.apache.org by ce...@apache.org on 2016/01/26 15:18:26 UTC
[48/89] [abbrv] [partial] incubator-metron git commit: Rename all
OpenSOC files to Metron
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/Cli.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/Cli.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/Cli.java
new file mode 100644
index 0000000..0d9486e
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/Cli.java
@@ -0,0 +1,186 @@
+package com.opensoc.helpers.topology;
+
+import java.io.File;
+
+import org.apache.commons.cli.BasicParser;
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+
+public class Cli {
+
+ private String[] args = null;
+ private Options options = new Options();
+
+ private String path = null;
+ private boolean debug = true;
+ private boolean local_mode = true;
+ private boolean generator_spout = false;
+
+ public boolean isGenerator_spout() {
+ return generator_spout;
+ }
+
+ public void setGenerator_spout(boolean generator_spout) {
+ this.generator_spout = generator_spout;
+ }
+
+ public String getPath() {
+ return path;
+ }
+
+ public void setPath(String path) {
+ this.path = path;
+ }
+
+ public boolean isDebug() {
+ return debug;
+ }
+
+ public void setDebug(boolean debug) {
+ this.debug = debug;
+ }
+
+ public boolean isLocal_mode() {
+ return local_mode;
+ }
+
+ public void setLocal_mode(boolean local_mode) {
+ this.local_mode = local_mode;
+ }
+
+ public Cli(String[] args) {
+
+ this.args = args;
+
+ Option help = new Option("h", "Display help menue");
+ options.addOption(help);
+ options.addOption(
+ "config_path",
+ true,
+ "OPTIONAL ARGUMENT [/path/to/configs] Path to configuration folder. If not provided topology will initialize with default configs");
+ options.addOption(
+ "local_mode",
+ true,
+ "REQUIRED ARGUMENT [true|false] Local mode or cluster mode. If set to true the topology will run in local mode. If set to false the topology will be deployed to Storm nimbus");
+ options.addOption(
+ "debug",
+ true,
+ "OPTIONAL ARGUMENT [true|false] Storm debugging enabled. Default value is true");
+ options.addOption(
+ "generator_spout",
+ true,
+ "REQUIRED ARGUMENT [true|false] Turn on test generator spout. Default is set to false. If test generator spout is turned on then kafka spout is turned off. Instead the generator spout will read telemetry from file and ingest it into a topology");
+ }
+
+ public void parse() {
+ CommandLineParser parser = new BasicParser();
+
+ CommandLine cmd = null;
+ try {
+ cmd = parser.parse(options, args);
+
+ if (cmd.hasOption("h"))
+ help();
+
+ if (cmd.hasOption("local_mode")) {
+
+ String local_value = cmd.getOptionValue("local_mode").trim()
+ .toLowerCase();
+
+ if (local_value.equals("true"))
+ local_mode = true;
+
+ else if (local_value.equals("false"))
+ local_mode = false;
+ else {
+ System.out
+ .println("[OpenSOC] ERROR: Invalid value for local mode");
+ System.out
+ .println("[OpenSOC] ERROR: Using cli argument -local_mode="
+ + cmd.getOptionValue("local_mode"));
+ help();
+ }
+ } else {
+ System.out
+ .println("[OpenSOC] ERROR: Invalid value for local mode");
+ help();
+ }
+ if (cmd.hasOption("generator_spout")) {
+
+ String local_value = cmd.getOptionValue("generator_spout").trim()
+ .toLowerCase();
+
+ if (local_value.equals("true"))
+ generator_spout = true;
+
+ else if (local_value.equals("false"))
+ generator_spout = false;
+ else {
+ System.out
+ .println("[OpenSOC] ERROR: Invalid value for local generator_spout");
+ System.out
+ .println("[OpenSOC] ERROR: Using cli argument -generator_spout="
+ + cmd.getOptionValue("generator_spout"));
+ help();
+ }
+ } else {
+ System.out
+ .println("[OpenSOC] ERROR: Invalid value for generator_spout");
+ help();
+ }
+ if (cmd.hasOption("config_path")) {
+
+ path = cmd.getOptionValue("config_path").trim();
+
+ File file = new File(path);
+
+ if (!file.isDirectory() || !file.exists()) {
+ System.out
+ .println("[OpenSOC] ERROR: Invalid settings directory name given");
+ System.out
+ .println("[OpenSOC] ERROR: Using cli argument -config_path="
+ + cmd.getOptionValue("config_path"));
+ help();
+ }
+ }
+
+ if (cmd.hasOption("debug")) {
+ String debug_value = cmd.getOptionValue("debug");
+
+ if (debug_value.equals("true"))
+ debug = true;
+ else if (debug_value.equals("false"))
+ debug = false;
+ else {
+ System.out
+ .println("[OpenSOC] ERROR: Invalid value for debug_value");
+ System.out
+ .println("[OpenSOC] ERROR: Using cli argument -debug_value="
+ + cmd.getOptionValue("debug_value"));
+ help();
+ }
+ }
+
+ } catch (ParseException e) {
+ System.out
+ .println("[OpenSOC] ERROR: Failed to parse command line arguments");
+ help();
+ }
+ }
+
+ private void help() {
+ // This prints out some help
+ HelpFormatter formater = new HelpFormatter();
+
+ formater.printHelp("Topology Options:", options);
+
+ System.out
+ .println("[OpenSOC] Example usage: \n storm jar OpenSOC-Topologies-0.3BETA-SNAPSHOT.jar com.opensoc.topology.Bro -local_mode true -config_path OpenSOC_Configs/ -generator_spout true");
+
+ System.exit(0);
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/ErrorGenerator.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/ErrorGenerator.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/ErrorGenerator.java
new file mode 100644
index 0000000..97f0ba7
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/ErrorGenerator.java
@@ -0,0 +1,37 @@
+package com.opensoc.helpers.topology;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+import org.apache.commons.lang.exception.ExceptionUtils;
+import org.json.simple.JSONObject;
+
+public class ErrorGenerator {
+
+ @SuppressWarnings("unchecked")
+ public static JSONObject generateErrorMessage(String message, Exception e)
+ {
+ JSONObject error_message = new JSONObject();
+
+ /*
+ * Save full stack trace in object.
+ */
+ String stackTrace = ExceptionUtils.getStackTrace(e);
+
+ String exception = e.toString();
+
+ error_message.put("time", System.currentTimeMillis());
+ try {
+ error_message.put("hostname", InetAddress.getLocalHost().getHostName());
+ } catch (UnknownHostException ex) {
+ // TODO Auto-generated catch block
+ ex.printStackTrace();
+ }
+
+ error_message.put("message", message);
+ error_message.put("exception", exception);
+ error_message.put("stack", stackTrace);
+
+ return error_message;
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/SettingsLoader.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/SettingsLoader.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/SettingsLoader.java
new file mode 100644
index 0000000..261d481
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/helpers/topology/SettingsLoader.java
@@ -0,0 +1,149 @@
+package com.opensoc.helpers.topology;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.apache.commons.configuration.Configuration;
+import org.apache.commons.configuration.ConfigurationException;
+import org.apache.commons.configuration.PropertiesConfiguration;
+import org.apache.commons.configuration.XMLConfiguration;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+public class SettingsLoader {
+
+ @SuppressWarnings("unchecked")
+ public static JSONObject loadEnvironmentIdnetifier(String config_path)
+ throws ConfigurationException {
+ Configuration config = new PropertiesConfiguration(config_path);
+
+ String customer = config.getString("customer.id", "unknown");
+ String datacenter = config.getString("datacenter.id", "unknown");
+ String instance = config.getString("instance.id", "unknown");
+
+ JSONObject identifier = new JSONObject();
+ identifier.put("customer", customer);
+ identifier.put("datacenter", datacenter);
+ identifier.put("instance", instance);
+
+ return identifier;
+ }
+
+ @SuppressWarnings("unchecked")
+ public static JSONObject loadTopologyIdnetifier(String config_path)
+ throws ConfigurationException {
+ Configuration config = new PropertiesConfiguration(config_path);
+
+ String topology = config.getString("topology.id", "unknown");
+ String instance = config.getString("instance.id", "unknown");
+
+ JSONObject identifier = new JSONObject();
+ identifier.put("topology", topology);
+ identifier.put("topology_instance", instance);
+
+ return identifier;
+ }
+
+
+ public static String generateTopologyName(JSONObject env, JSONObject topo) {
+
+ return (env.get("customer") + "_" + env.get("datacenter") + "_"
+ + env.get("instance") + "_" + topo.get("topology") + "_" + topo.get("topology_instance"));
+ }
+
+ @SuppressWarnings("unchecked")
+ public static JSONObject generateAlertsIdentifier(JSONObject env, JSONObject topo)
+ {
+ JSONObject identifier = new JSONObject();
+ identifier.put("environment", env);
+ identifier.put("topology", topo);
+
+ return identifier;
+ }
+
+ public static Map<String, JSONObject> loadRegexAlerts(String config_path)
+ throws ConfigurationException, ParseException {
+ XMLConfiguration alert_rules = new XMLConfiguration();
+ alert_rules.setDelimiterParsingDisabled(true);
+ alert_rules.load(config_path);
+
+ //int number_of_rules = alert_rules.getList("rule.pattern").size();
+
+ String[] patterns = alert_rules.getStringArray("rule.pattern");
+ String[] alerts = alert_rules.getStringArray("rule.alert");
+
+ JSONParser pr = new JSONParser();
+ Map<String, JSONObject> rules = new HashMap<String, JSONObject>();
+
+ for (int i = 0; i < patterns.length; i++)
+ rules.put(patterns[i], (JSONObject) pr.parse(alerts[i]));
+
+ return rules;
+ }
+
+ public static Map<String, JSONObject> loadKnownHosts(String config_path)
+ throws ConfigurationException, ParseException {
+ Configuration hosts = new PropertiesConfiguration(config_path);
+
+ Iterator<String> keys = hosts.getKeys();
+ Map<String, JSONObject> known_hosts = new HashMap<String, JSONObject>();
+ JSONParser parser = new JSONParser();
+
+ while (keys.hasNext()) {
+ String key = keys.next().trim();
+ JSONArray value = (JSONArray) parser.parse(hosts.getProperty(key)
+ .toString());
+ known_hosts.put(key, (JSONObject) value.get(0));
+ }
+
+ return known_hosts;
+ }
+
+ public static void printConfigOptions(PropertiesConfiguration config, String path_fragment)
+ {
+ Iterator<String> itr = config.getKeys();
+
+ while(itr.hasNext())
+ {
+ String key = itr.next();
+
+ if(key.contains(path_fragment))
+ {
+
+ System.out.println("[OpenSOC] Key: " + key + " -> " + config.getString(key));
+ }
+ }
+
+ }
+
+ public static void printOptionalSettings(Map<String, String> settings)
+ {
+ for(String setting: settings.keySet())
+ {
+ System.out.println("[OpenSOC] Optional Setting: " + setting + " -> " +settings.get(setting));
+ }
+
+ }
+
+ public static Map<String, String> getConfigOptions(PropertiesConfiguration config, String path_fragment)
+ {
+ Iterator<String> itr = config.getKeys();
+ Map<String, String> settings = new HashMap<String, String>();
+
+ while(itr.hasNext())
+ {
+ String key = itr.next();
+
+ if(key.contains(path_fragment))
+ {
+ String tmp_key = key.replace(path_fragment, "");
+ settings.put(tmp_key, config.getString(key));
+ }
+ }
+
+ return settings;
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/index/interfaces/IndexAdapter.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/index/interfaces/IndexAdapter.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/index/interfaces/IndexAdapter.java
new file mode 100644
index 0000000..dfdfc8e
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/index/interfaces/IndexAdapter.java
@@ -0,0 +1,15 @@
+package com.opensoc.index.interfaces;
+
+import java.util.Map;
+
+import org.json.simple.JSONObject;
+
+public interface IndexAdapter {
+
+ boolean initializeConnection(String ip, int port, String cluster_name,
+ String index_name, String document_name, int bulk, String date_format) throws Exception;
+
+ int bulkIndex(JSONObject raw_message);
+
+ void setOptionalSettings(Map<String, String> settings);
+}
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParser.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParser.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParser.java
new file mode 100644
index 0000000..a54f1ce
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParser.java
@@ -0,0 +1,644 @@
+/* Generated By:JavaCC: Do not edit this line. ISEParser.java */
+package com.opensoc.ise.parser;
+import java.io.*;
+import java.util.*;
+
+import org.json.simple.*;
+
+/**
+* Basic ISE data parser generated by JavaCC.
+*/
+public class ISEParser implements Serializable, ISEParserConstants {
+ // private boolean nativeNumbers = false;
+
+ private static final long serialVersionUID = -2531656825360044979L;
+
+ public ISEParser()
+ { //do nothing
+ }
+
+ public ISEParser(String input)
+ {
+ this (new StringReader(input));
+ }
+
+ /**
+ * Parses a ISE String into a JSON object {@code Map}.
+ */
+ public JSONObject parseObject() throws ParseException
+ {
+ JSONObject toReturn = object();
+ if (!ensureEOF()) throw new IllegalStateException("Expected EOF, but still had content to parse");
+ return toReturn;
+ }
+
+ @SuppressWarnings("unused")
+final public boolean ensureEOF() throws ParseException {
+ switch (jj_nt.kind) {
+ case COMMA:
+ jj_consume_token(COMMA);
+ break;
+ default:
+ jj_la1[0] = jj_gen;
+ ;
+ }
+ jj_consume_token(0);
+ {if (true) return true;}
+ throw new Error("Missing return statement in function");
+ }
+
+ @SuppressWarnings({ "unchecked", "unused" })
+final public JSONObject innerMap() throws ParseException {
+ final JSONObject json = new JSONObject();
+ String key;
+ Object value;
+ key = objectKey();
+ jj_consume_token(EQUALS);
+ value = value();
+ json.put(key, value);
+ key = null;
+ value = null;
+ label_1:
+ while (true) {
+ switch (jj_nt.kind) {
+ case SLASH:
+ ;
+ break;
+ default:
+ jj_la1[1] = jj_gen;
+ break label_1;
+ }
+ jj_consume_token(SLASH);
+ jj_consume_token(COMMA);
+ key = objectKey();
+ jj_consume_token(EQUALS);
+ value = value();
+ json.put(key, value);
+ key = null;
+ value = null;
+ }
+ {if (true) return json;}
+ throw new Error("Missing return statement in function");
+ }
+
+ @SuppressWarnings({ "unused", "unchecked" })
+final public JSONObject object() throws ParseException {
+ final JSONObject json = new JSONObject();
+ String key;
+ Object value;
+ key = objectKey();
+ jj_consume_token(EQUALS);
+ value = value();
+ json.put(key, value);
+ key = null;
+ value = null;
+ label_2:
+ while (true) {
+ if (jj_2_1(2)) {
+ ;
+ } else {
+ break label_2;
+ }
+ jj_consume_token(COMMA);
+ key = objectKey();
+ jj_consume_token(EQUALS);
+ value = value();
+ json.put(key, value);
+ key = null;
+ value = null;
+ }
+ {if (true) return json;}
+ throw new Error("Missing return statement in function");
+ }
+
+ @SuppressWarnings("unused")
+final public String objectKey() throws ParseException {
+ String k;
+ k = string();
+ // System.out.println("key == " + k);
+ {if (true) return k.trim();}
+ throw new Error("Missing return statement in function");
+ }
+
+ @SuppressWarnings({ "unused", "rawtypes" })
+final public Object value() throws ParseException {
+ Object x;
+ String eof = "EOF";
+ Map m = null;
+ if (jj_2_2(2147483647)) {
+ x = nullValue();
+ } else if (jj_2_3(2147483647)) {
+ x = innerMap();
+ } else {
+ switch (jj_nt.kind) {
+ case TAG:
+ x = tagString();
+ break;
+ default:
+ jj_la1[2] = jj_gen;
+ if (jj_2_4(2147483647)) {
+ x = blankValue();
+ } else if (jj_2_5(2147483647)) {
+ x = braced_string();
+ } else if (jj_2_6(2)) {
+ x = string();
+ } else {
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ }
+ }
+ // System.out.println("val == " + x);
+ //if (x instanceof Map) return "Map";
+ //return (String) x;
+ {if (true) return x;}
+ throw new Error("Missing return statement in function");
+ }
+
+ @SuppressWarnings("unused")
+final public String nullValue() throws ParseException {
+ {if (true) return null;}
+ throw new Error("Missing return statement in function");
+ }
+
+ @SuppressWarnings("unused")
+final public String tagString() throws ParseException {
+ String output = "(tag=0)";
+ jj_consume_token(TAG);
+ jj_consume_token(STRING_BODY);
+ {if (true) return output + token.image;}
+ throw new Error("Missing return statement in function");
+ }
+
+ @SuppressWarnings("unused")
+final public String blankValue() throws ParseException {
+ {if (true) return null;}
+ throw new Error("Missing return statement in function");
+ }
+
+ @SuppressWarnings("unused")
+final public String string() throws ParseException {
+ String s;
+ jj_consume_token(STRING_BODY);
+ {if (true) return token.image.trim();}
+ throw new Error("Missing return statement in function");
+ }
+
+ @SuppressWarnings("unused")
+final public String braced_string() throws ParseException {
+ String s;
+ jj_consume_token(BRACED_STRING);
+ // System.out.println("braced == " + token.image);
+ s = token.image;
+ jj_consume_token(COMMA);
+ {if (true) return s.trim();}
+ throw new Error("Missing return statement in function");
+ }
+
+ private boolean jj_2_1(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_1(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(0, xla); }
+ }
+
+ private boolean jj_2_2(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_2(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(1, xla); }
+ }
+
+ private boolean jj_2_3(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_3(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(2, xla); }
+ }
+
+ private boolean jj_2_4(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_4(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(3, xla); }
+ }
+
+ private boolean jj_2_5(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_5(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(4, xla); }
+ }
+
+ private boolean jj_2_6(int xla) {
+ jj_la = xla; jj_lastpos = jj_scanpos = token;
+ try { return !jj_3_6(); }
+ catch(LookaheadSuccess ls) { return true; }
+ finally { jj_save(5, xla); }
+ }
+
+ private boolean jj_3_5() {
+ if (jj_3R_5()) return true;
+ return false;
+ }
+
+ private boolean jj_3_4() {
+ if (jj_scan_token(0)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_5() {
+ if (jj_scan_token(BRACED_STRING)) return true;
+ if (jj_scan_token(COMMA)) return true;
+ return false;
+ }
+
+ private boolean jj_3_3() {
+ if (jj_3R_4()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_4() {
+ if (jj_3R_3()) return true;
+ if (jj_scan_token(EQUALS)) return true;
+ if (jj_3R_7()) return true;
+ Token xsp;
+ while (true) {
+ xsp = jj_scanpos;
+ if (jj_3R_8()) { jj_scanpos = xsp; break; }
+ }
+ return false;
+ }
+
+ private boolean jj_3_2() {
+ if (jj_scan_token(COMMA)) return true;
+ return false;
+ }
+
+ private boolean jj_3_6() {
+ if (jj_3R_6()) return true;
+ return false;
+ }
+
+ private boolean jj_3_1() {
+ if (jj_scan_token(COMMA)) return true;
+ if (jj_3R_3()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_13() {
+ if (jj_3R_5()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_12() {
+ if (jj_3R_16()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_11() {
+ if (jj_3R_15()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_6() {
+ if (jj_scan_token(STRING_BODY)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_10() {
+ if (jj_3R_4()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_9() {
+ if (jj_3R_14()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_7() {
+ Token xsp;
+ xsp = jj_scanpos;
+ if (jj_3R_9()) {
+ jj_scanpos = xsp;
+ if (jj_3R_10()) {
+ jj_scanpos = xsp;
+ if (jj_3R_11()) {
+ jj_scanpos = xsp;
+ if (jj_3R_12()) {
+ jj_scanpos = xsp;
+ if (jj_3R_13()) {
+ jj_scanpos = xsp;
+ if (jj_3_6()) return true;
+ }
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ private boolean jj_3R_16() {
+ return false;
+ }
+
+ private boolean jj_3R_15() {
+ if (jj_scan_token(TAG)) return true;
+ if (jj_scan_token(STRING_BODY)) return true;
+ return false;
+ }
+
+ private boolean jj_3R_3() {
+ if (jj_3R_6()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_8() {
+ if (jj_scan_token(SLASH)) return true;
+ if (jj_scan_token(COMMA)) return true;
+ if (jj_3R_3()) return true;
+ if (jj_scan_token(EQUALS)) return true;
+ if (jj_3R_7()) return true;
+ return false;
+ }
+
+ private boolean jj_3R_14() {
+ return false;
+ }
+
+ /** Generated Token Manager. */
+ public ISEParserTokenManager token_source;
+ JavaCharStream jj_input_stream;
+ /** Current token. */
+ public Token token;
+ /** Next token. */
+ public Token jj_nt;
+ private Token jj_scanpos, jj_lastpos;
+ private int jj_la;
+ private int jj_gen;
+ final private int[] jj_la1 = new int[3];
+ static private int[] jj_la1_0;
+ static {
+ jj_la1_init_0();
+ }
+ private static void jj_la1_init_0() {
+ jj_la1_0 = new int[] {0x20,0x80,0x100,};
+ }
+ final private JJCalls[] jj_2_rtns = new JJCalls[6];
+ private boolean jj_rescan = false;
+ private int jj_gc = 0;
+
+ /** Constructor with InputStream. */
+ public ISEParser(java.io.InputStream stream) {
+ this(stream, null);
+ }
+ /** Constructor with InputStream and supplied encoding */
+ public ISEParser(java.io.InputStream stream, String encoding) {
+ try { jj_input_stream = new JavaCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
+ token_source = new ISEParserTokenManager(jj_input_stream);
+ token = new Token();
+ token.next = jj_nt = token_source.getNextToken();
+ jj_gen = 0;
+ for (int i = 0; i < 3; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ /** Reinitialise. */
+ public void ReInit(java.io.InputStream stream) {
+ ReInit(stream, null);
+ }
+ /** Reinitialise. */
+ public void ReInit(java.io.InputStream stream, String encoding) {
+ try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
+ token_source.ReInit(jj_input_stream);
+ token = new Token();
+ token.next = jj_nt = token_source.getNextToken();
+ jj_gen = 0;
+ for (int i = 0; i < 3; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ /** Constructor. */
+ public ISEParser(java.io.Reader stream) {
+ jj_input_stream = new JavaCharStream(stream, 1, 1);
+ token_source = new ISEParserTokenManager(jj_input_stream);
+ token = new Token();
+ token.next = jj_nt = token_source.getNextToken();
+ jj_gen = 0;
+ for (int i = 0; i < 3; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ /** Reinitialise. */
+ public void ReInit(java.io.Reader stream) {
+ jj_input_stream.ReInit(stream, 1, 1);
+ token_source.ReInit(jj_input_stream);
+ token = new Token();
+ token.next = jj_nt = token_source.getNextToken();
+ jj_gen = 0;
+ for (int i = 0; i < 3; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ /** Constructor with generated Token Manager. */
+ public ISEParser(ISEParserTokenManager tm) {
+ token_source = tm;
+ token = new Token();
+ token.next = jj_nt = token_source.getNextToken();
+ jj_gen = 0;
+ for (int i = 0; i < 3; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ /** Reinitialise. */
+ public void ReInit(ISEParserTokenManager tm) {
+ token_source = tm;
+ token = new Token();
+ token.next = jj_nt = token_source.getNextToken();
+ jj_gen = 0;
+ for (int i = 0; i < 3; i++) jj_la1[i] = -1;
+ for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
+ }
+
+ private Token jj_consume_token(int kind) throws ParseException {
+ Token oldToken = token;
+ if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
+ else jj_nt = jj_nt.next = token_source.getNextToken();
+ if (token.kind == kind) {
+ jj_gen++;
+ if (++jj_gc > 100) {
+ jj_gc = 0;
+ for (int i = 0; i < jj_2_rtns.length; i++) {
+ JJCalls c = jj_2_rtns[i];
+ while (c != null) {
+ if (c.gen < jj_gen) c.first = null;
+ c = c.next;
+ }
+ }
+ }
+ return token;
+ }
+ jj_nt = token;
+ token = oldToken;
+ jj_kind = kind;
+ throw generateParseException();
+ }
+
+ static private final class LookaheadSuccess extends java.lang.Error {
+
+ private static final long serialVersionUID = -5724812746511794505L; }
+ final private LookaheadSuccess jj_ls = new LookaheadSuccess();
+ private boolean jj_scan_token(int kind) {
+ if (jj_scanpos == jj_lastpos) {
+ jj_la--;
+ if (jj_scanpos.next == null) {
+ jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
+ } else {
+ jj_lastpos = jj_scanpos = jj_scanpos.next;
+ }
+ } else {
+ jj_scanpos = jj_scanpos.next;
+ }
+ if (jj_rescan) {
+ int i = 0; Token tok = token;
+ while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
+ if (tok != null) jj_add_error_token(kind, i);
+ }
+ if (jj_scanpos.kind != kind) return true;
+ if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
+ return false;
+ }
+
+
+/** Get the next Token. */
+ final public Token getNextToken() {
+ if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
+ else jj_nt = jj_nt.next = token_source.getNextToken();
+ jj_gen++;
+ return token;
+ }
+
+/** Get the specific Token. */
+ final public Token getToken(int index) {
+ Token t = token;
+ for (int i = 0; i < index; i++) {
+ if (t.next != null) t = t.next;
+ else t = t.next = token_source.getNextToken();
+ }
+ return t;
+ }
+
+ private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
+ private int[] jj_expentry;
+ private int jj_kind = -1;
+ private int[] jj_lasttokens = new int[100];
+ private int jj_endpos;
+
+ private void jj_add_error_token(int kind, int pos) {
+ if (pos >= 100) return;
+ if (pos == jj_endpos + 1) {
+ jj_lasttokens[jj_endpos++] = kind;
+ } else if (jj_endpos != 0) {
+ jj_expentry = new int[jj_endpos];
+ for (int i = 0; i < jj_endpos; i++) {
+ jj_expentry[i] = jj_lasttokens[i];
+ }
+ jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
+ int[] oldentry = (int[])(it.next());
+ if (oldentry.length == jj_expentry.length) {
+ for (int i = 0; i < jj_expentry.length; i++) {
+ if (oldentry[i] != jj_expentry[i]) {
+ continue jj_entries_loop;
+ }
+ }
+ jj_expentries.add(jj_expentry);
+ break jj_entries_loop;
+ }
+ }
+ if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
+ }
+ }
+
+ /** Generate ParseException. */
+ public ParseException generateParseException() {
+ jj_expentries.clear();
+ boolean[] la1tokens = new boolean[11];
+ if (jj_kind >= 0) {
+ la1tokens[jj_kind] = true;
+ jj_kind = -1;
+ }
+ for (int i = 0; i < 3; i++) {
+ if (jj_la1[i] == jj_gen) {
+ for (int j = 0; j < 32; j++) {
+ if ((jj_la1_0[i] & (1<<j)) != 0) {
+ la1tokens[j] = true;
+ }
+ }
+ }
+ }
+ for (int i = 0; i < 11; i++) {
+ if (la1tokens[i]) {
+ jj_expentry = new int[1];
+ jj_expentry[0] = i;
+ jj_expentries.add(jj_expentry);
+ }
+ }
+ jj_endpos = 0;
+ jj_rescan_token();
+ jj_add_error_token(0, 0);
+ int[][] exptokseq = new int[jj_expentries.size()][];
+ for (int i = 0; i < jj_expentries.size(); i++) {
+ exptokseq[i] = jj_expentries.get(i);
+ }
+ return new ParseException(token, exptokseq, tokenImage);
+ }
+
+ /** Enable tracing. */
+ final public void enable_tracing() {
+ }
+
+ /** Disable tracing. */
+ final public void disable_tracing() {
+ }
+
+ private void jj_rescan_token() {
+ jj_rescan = true;
+ for (int i = 0; i < 6; i++) {
+ try {
+ JJCalls p = jj_2_rtns[i];
+ do {
+ if (p.gen > jj_gen) {
+ jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
+ switch (i) {
+ case 0: jj_3_1(); break;
+ case 1: jj_3_2(); break;
+ case 2: jj_3_3(); break;
+ case 3: jj_3_4(); break;
+ case 4: jj_3_5(); break;
+ case 5: jj_3_6(); break;
+ }
+ }
+ p = p.next;
+ } while (p != null);
+ } catch(LookaheadSuccess ls) { }
+ }
+ jj_rescan = false;
+ }
+
+ private void jj_save(int index, int xla) {
+ JJCalls p = jj_2_rtns[index];
+ while (p.gen > jj_gen) {
+ if (p.next == null) { p = p.next = new JJCalls(); break; }
+ p = p.next;
+ }
+ p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
+ }
+
+ static final class JJCalls {
+ int gen;
+ Token first;
+ int arg;
+ JJCalls next;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParser.jj
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParser.jj b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParser.jj
new file mode 100644
index 0000000..bcd5dfd
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParser.jj
@@ -0,0 +1,12 @@
+options{ CHOICE_AMBIGUITY_CHECK = 3; OTHER_AMBIGUITY_CHECK = 2; //DEBUG_PARSER=true
+ //DEBUG_LOOKAHEAD=true
+ //DEBUG_TOKEN_MANAGER=true
+ ERROR_REPORTING = true; JAVA_UNICODE_ESCAPE = true; UNICODE_INPUT = true; IGNORE_CASE = true; SUPPORT_CLASS_VISIBILITY_PUBLIC = false; FORCE_LA_CHECK = true; CACHE_TOKENS = true; SANITY_CHECK = true; STATIC = false; //KEEP_LINE_COLUMN=true;
+}PARSER_BEGIN(ISEParser)package com.opensoc.ise.parser;import java.io.*;import java.util.*;import org.json.simple.*;/**
+* Basic ISE data parser generated by JavaCC.
+*/public class ISEParser implements Serializable{ private boolean nativeNumbers = false; public ISEParser() { //do nothing
+ } public ISEParser(String input) { this (new StringReader(input)); } /**
+ * Parses a ISE String into a JSON object {@code Map}.
+ */ public JSONObject parseObject() throws ParseException { JSONObject toReturn = object(); if (!ensureEOF()) throw new IllegalStateException("Expected EOF, but still had content to parse"); return toReturn; }}PARSER_END(ISEParser)// Ignore commentsSKIP :{ < C_SINGLE_COMMENT : "//" (~[ "\n", "\r", "\f" ])* < EOL >>| < C_MULTILINE_COMMENT : "/*" (~[ ])* "*/" >| < SH_SINGLE_COMMENT : "#" (~[ "\n", "\r", "\f" ])* < EOL >> /*| < WHITESPACE : " " | "\t" >*/| < EOL : "\n" | "\r" | "\f" >}// Common tokens
+TOKEN :{ < COMMA : "," >| < EQUALS : "=" >| < SLASH : "\\" >| < TAG : "(tag=0)" >}// Null token/*TOKEN :{ //< NULL : "null" >}*/// String tokens
+TOKEN :{ //< SYMBOL : ([ "a"-"z", "A"-"Z", "0", "1"-"9", " ", "\t" , ":" , "-" , "." ])+ > < STRING_BODY : ( (~[ "\"", "\r", "\n", "\f", "\t", "=", "," ]) | ( "\\" ( "r" | "n" | "f" | "\\" | "/" | "\"" | "b" | "t" | "," ) ) )+ >| < BRACED_STRING : ( "{" (~[ "{", "}" ])+ "}" ) >}boolean ensureEOF() :{}{ (< COMMA >)? < EOF > { return true; }}JSONObject innerMap() :{ final JSONObject json = new JSONObject(); String key; Object value;}{ key = objectKey() < EQUALS > value = value() { json.put(key, value); } { key = null; value = null; } ( < SLASH > < COMMA > key = objectKey() < EQUALS > value = value() { json.put(key, value); } { key = null; value = null; } )* { return json; }}JSONObject object() :{ final JSONObject json = new JSONObject()
; String key; Object value;}{ key = objectKey() < EQUALS > value = value() { json.put(key, value); } { key = null; value = null; } ( ( LOOKAHEAD(2) < COMMA > key = objectKey() < EQUALS > value = value() { json.put(key, value); } { key = null; value = null; } )* | LOOKAHEAD(2) < COMMA > < EOF > ) // ensureEOF() { return json; }}String objectKey() :{ String k;}{ ( k = string() ) { // System.out.println("key == " + k); return k.trim(); }}Object value() :{ Object x; String eof = "EOF"; Map m = null;}{ ( LOOKAHEAD(< COMMA >) x = nullValue() | LOOKAHEAD(innerMap()) x = innerMap() | x = tagString() | LOOKAHEAD(< EOF >) x = blankValue() | LOOKAHEAD(braced_string()) x = braced_string() | LOOKAHEAD(2) x = string() ) { // System.out.println("val == " + x); //if (x instanceof Map) return "Map
"; //return (String) x; return x; }}String nullValue() :{}{ { return null; }}String tagString() :{ String output = "(tag=0)";}{ < TAG > < STRING_BODY > { return output + token.image; }}String blankValue() :{}{ { return null; }}String string() :{ String s;}{ < STRING_BODY > { return token.image.trim(); }}String braced_string() :{ String s;}{ < BRACED_STRING > { // System.out.println("braced == " + token.image); s = token.image; } < COMMA > { return s.trim(); }}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParserConstants.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParserConstants.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParserConstants.java
new file mode 100644
index 0000000..62ea0a3
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParserConstants.java
@@ -0,0 +1,52 @@
+/* Generated By:JavaCC: Do not edit this line. ISEParserConstants.java */
+package com.opensoc.ise.parser;
+
+
+/**
+ * Token literal values and constants.
+ * Generated by org.javacc.parser.OtherFilesGen#start()
+ */
+interface ISEParserConstants {
+
+ /** End of File. */
+ int EOF = 0;
+ /** RegularExpression Id. */
+ int C_SINGLE_COMMENT = 1;
+ /** RegularExpression Id. */
+ int C_MULTILINE_COMMENT = 2;
+ /** RegularExpression Id. */
+ int SH_SINGLE_COMMENT = 3;
+ /** RegularExpression Id. */
+ int EOL = 4;
+ /** RegularExpression Id. */
+ int COMMA = 5;
+ /** RegularExpression Id. */
+ int EQUALS = 6;
+ /** RegularExpression Id. */
+ int SLASH = 7;
+ /** RegularExpression Id. */
+ int TAG = 8;
+ /** RegularExpression Id. */
+ int STRING_BODY = 9;
+ /** RegularExpression Id. */
+ int BRACED_STRING = 10;
+
+ /** Lexical state. */
+ int DEFAULT = 0;
+
+ /** Literal token values. */
+ String[] tokenImage = {
+ "<EOF>",
+ "<C_SINGLE_COMMENT>",
+ "<C_MULTILINE_COMMENT>",
+ "<SH_SINGLE_COMMENT>",
+ "<EOL>",
+ "\",\"",
+ "\"=\"",
+ "\"\\\\\"",
+ "\"(tag=0)\"",
+ "<STRING_BODY>",
+ "<BRACED_STRING>",
+ };
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParserTokenManager.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParserTokenManager.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParserTokenManager.java
new file mode 100644
index 0000000..9999452
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ISEParserTokenManager.java
@@ -0,0 +1,659 @@
+/* Generated By:JavaCC: Do not edit this line. ISEParserTokenManager.java */
+package com.opensoc.ise.parser;
+
+/** Token Manager. */
+class ISEParserTokenManager implements ISEParserConstants
+{
+
+ /** Debug output. */
+ public java.io.PrintStream debugStream = System.out;
+ /** Set debug output. */
+ public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
+private final int jjStopStringLiteralDfa_0(int pos, long active0)
+{
+ switch (pos)
+ {
+ case 0:
+ if ((active0 & 0x100L) != 0L)
+ {
+ jjmatchedKind = 9;
+ return 18;
+ }
+ if ((active0 & 0x80L) != 0L)
+ return 6;
+ return -1;
+ case 1:
+ if ((active0 & 0x100L) != 0L)
+ {
+ jjmatchedKind = 9;
+ jjmatchedPos = 1;
+ return 18;
+ }
+ return -1;
+ case 2:
+ if ((active0 & 0x100L) != 0L)
+ {
+ jjmatchedKind = 9;
+ jjmatchedPos = 2;
+ return 18;
+ }
+ return -1;
+ case 3:
+ if ((active0 & 0x100L) != 0L)
+ {
+ jjmatchedKind = 9;
+ jjmatchedPos = 3;
+ return 18;
+ }
+ return -1;
+ case 4:
+ if ((active0 & 0x100L) != 0L)
+ {
+ if (jjmatchedPos < 3)
+ {
+ jjmatchedKind = 9;
+ jjmatchedPos = 3;
+ }
+ return -1;
+ }
+ return -1;
+ case 5:
+ if ((active0 & 0x100L) != 0L)
+ {
+ if (jjmatchedPos < 3)
+ {
+ jjmatchedKind = 9;
+ jjmatchedPos = 3;
+ }
+ return -1;
+ }
+ return -1;
+ default :
+ return -1;
+ }
+}
+private final int jjStartNfa_0(int pos, long active0)
+{
+ return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
+}
+private int jjStopAtPos(int pos, int kind)
+{
+ jjmatchedKind = kind;
+ jjmatchedPos = pos;
+ return pos + 1;
+}
+private int jjMoveStringLiteralDfa0_0()
+{
+ switch(curChar)
+ {
+ case 40:
+ return jjMoveStringLiteralDfa1_0(0x100L);
+ case 44:
+ return jjStopAtPos(0, 5);
+ case 61:
+ return jjStopAtPos(0, 6);
+ case 92:
+ return jjStartNfaWithStates_0(0, 7, 6);
+ default :
+ return jjMoveNfa_0(0, 0);
+ }
+}
+private int jjMoveStringLiteralDfa1_0(long active0)
+{
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(0, active0);
+ return 1;
+ }
+ switch(curChar)
+ {
+ case 84:
+ case 116:
+ return jjMoveStringLiteralDfa2_0(active0, 0x100L);
+ default :
+ break;
+ }
+ return jjStartNfa_0(0, active0);
+}
+private int jjMoveStringLiteralDfa2_0(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_0(0, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(1, active0);
+ return 2;
+ }
+ switch(curChar)
+ {
+ case 65:
+ case 97:
+ return jjMoveStringLiteralDfa3_0(active0, 0x100L);
+ default :
+ break;
+ }
+ return jjStartNfa_0(1, active0);
+}
+private int jjMoveStringLiteralDfa3_0(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_0(1, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(2, active0);
+ return 3;
+ }
+ switch(curChar)
+ {
+ case 71:
+ case 103:
+ return jjMoveStringLiteralDfa4_0(active0, 0x100L);
+ default :
+ break;
+ }
+ return jjStartNfa_0(2, active0);
+}
+private int jjMoveStringLiteralDfa4_0(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_0(2, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(3, active0);
+ return 4;
+ }
+ switch(curChar)
+ {
+ case 61:
+ return jjMoveStringLiteralDfa5_0(active0, 0x100L);
+ default :
+ break;
+ }
+ return jjStartNfa_0(3, active0);
+}
+private int jjMoveStringLiteralDfa5_0(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_0(3, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(4, active0);
+ return 5;
+ }
+ switch(curChar)
+ {
+ case 48:
+ return jjMoveStringLiteralDfa6_0(active0, 0x100L);
+ default :
+ break;
+ }
+ return jjStartNfa_0(4, active0);
+}
+private int jjMoveStringLiteralDfa6_0(long old0, long active0)
+{
+ if (((active0 &= old0)) == 0L)
+ return jjStartNfa_0(4, old0);
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) {
+ jjStopStringLiteralDfa_0(5, active0);
+ return 6;
+ }
+ switch(curChar)
+ {
+ case 41:
+ if ((active0 & 0x100L) != 0L)
+ return jjStopAtPos(6, 8);
+ break;
+ default :
+ break;
+ }
+ return jjStartNfa_0(5, active0);
+}
+private int jjStartNfaWithStates_0(int pos, int kind, int state)
+{
+ jjmatchedKind = kind;
+ jjmatchedPos = pos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return pos + 1; }
+ return jjMoveNfa_0(state, pos + 1);
+}
+static final long[] jjbitVec0 = {
+ 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+static final long[] jjbitVec2 = {
+ 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+private int jjMoveNfa_0(int startState, int curPos)
+{
+ int startsAt = 0;
+ jjnewStateCnt = 18;
+ int i = 1;
+ jjstateSet[0] = startState;
+ int kind = 0x7fffffff;
+ for (;;)
+ {
+ if (++jjround == 0x7fffffff)
+ ReInitRounds();
+ if (curChar < 64)
+ {
+ long l = 1L << curChar;
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 18:
+ case 4:
+ if ((0xdfffeffbffffc9ffL & l) == 0L)
+ break;
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ break;
+ case 0:
+ if ((0xdfffeffbffffc9ffL & l) != 0L)
+ {
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ }
+ else if ((0x3400L & l) != 0L)
+ {
+ if (kind > 4)
+ kind = 4;
+ }
+ if (curChar == 47)
+ jjAddStates(0, 1);
+ else if (curChar == 35)
+ jjCheckNAddTwoStates(1, 2);
+ break;
+ case 6:
+ if ((0xdfffeffbffffc9ffL & l) != 0L)
+ {
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ }
+ if ((0x900400000000L & l) != 0L)
+ {
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ }
+ break;
+ case 1:
+ if ((0xffffffffffffcbffL & l) != 0L)
+ jjCheckNAddTwoStates(1, 2);
+ break;
+ case 2:
+ if ((0x3400L & l) != 0L && kind > 3)
+ kind = 3;
+ break;
+ case 3:
+ if ((0x3400L & l) != 0L && kind > 4)
+ kind = 4;
+ break;
+ case 8:
+ jjAddStates(2, 3);
+ break;
+ case 10:
+ if (curChar == 47)
+ jjAddStates(0, 1);
+ break;
+ case 11:
+ if (curChar == 47)
+ jjCheckNAddTwoStates(12, 13);
+ break;
+ case 12:
+ if ((0xffffffffffffcbffL & l) != 0L)
+ jjCheckNAddTwoStates(12, 13);
+ break;
+ case 13:
+ if ((0x3400L & l) != 0L && kind > 1)
+ kind = 1;
+ break;
+ case 14:
+ if (curChar == 42)
+ jjCheckNAddTwoStates(15, 17);
+ break;
+ case 15:
+ jjCheckNAddTwoStates(15, 17);
+ break;
+ case 16:
+ if (curChar == 47 && kind > 2)
+ kind = 2;
+ break;
+ case 17:
+ if (curChar == 42)
+ jjstateSet[jjnewStateCnt++] = 16;
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else if (curChar < 128)
+ {
+ long l = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 18:
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ if (curChar == 92)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 0:
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ if (curChar == 123)
+ jjCheckNAdd(8);
+ else if (curChar == 92)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 6:
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ if ((0x14404410144044L & l) != 0L)
+ {
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ }
+ if (curChar == 92)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 1:
+ jjAddStates(4, 5);
+ break;
+ case 4:
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ break;
+ case 5:
+ if (curChar == 92)
+ jjstateSet[jjnewStateCnt++] = 6;
+ break;
+ case 7:
+ if (curChar == 123)
+ jjCheckNAdd(8);
+ break;
+ case 8:
+ if ((0xd7ffffffffffffffL & l) != 0L)
+ jjCheckNAddTwoStates(8, 9);
+ break;
+ case 9:
+ if (curChar == 125 && kind > 10)
+ kind = 10;
+ break;
+ case 12:
+ jjAddStates(6, 7);
+ break;
+ case 15:
+ jjAddStates(8, 9);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ else
+ {
+ int hiByte = (int)(curChar >> 8);
+ int i1 = hiByte >> 6;
+ long l1 = 1L << (hiByte & 077);
+ int i2 = (curChar & 0xff) >> 6;
+ long l2 = 1L << (curChar & 077);
+ do
+ {
+ switch(jjstateSet[--i])
+ {
+ case 18:
+ case 4:
+ if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
+ break;
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ break;
+ case 0:
+ if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
+ break;
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ break;
+ case 6:
+ if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
+ break;
+ if (kind > 9)
+ kind = 9;
+ jjCheckNAddTwoStates(4, 5);
+ break;
+ case 1:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(4, 5);
+ break;
+ case 8:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(2, 3);
+ break;
+ case 12:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(6, 7);
+ break;
+ case 15:
+ if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+ jjAddStates(8, 9);
+ break;
+ default : break;
+ }
+ } while(i != startsAt);
+ }
+ if (kind != 0x7fffffff)
+ {
+ jjmatchedKind = kind;
+ jjmatchedPos = curPos;
+ kind = 0x7fffffff;
+ }
+ ++curPos;
+ if ((i = jjnewStateCnt) == (startsAt = 18 - (jjnewStateCnt = startsAt)))
+ return curPos;
+ try { curChar = input_stream.readChar(); }
+ catch(java.io.IOException e) { return curPos; }
+ }
+}
+static final int[] jjnextStates = {
+ 11, 14, 8, 9, 1, 2, 12, 13, 15, 17,
+};
+private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
+{
+ switch(hiByte)
+ {
+ case 0:
+ return ((jjbitVec2[i2] & l2) != 0L);
+ default :
+ if ((jjbitVec0[i1] & l1) != 0L)
+ return true;
+ return false;
+ }
+}
+
+/** Token literal values. */
+public static final String[] jjstrLiteralImages = {
+"", null, null, null, null, "\54", "\75", "\134", null, null, null, };
+
+/** Lexer state names. */
+public static final String[] lexStateNames = {
+ "DEFAULT",
+};
+static final long[] jjtoToken = {
+ 0x7e1L,
+};
+static final long[] jjtoSkip = {
+ 0x1eL,
+};
+protected JavaCharStream input_stream;
+private final int[] jjrounds = new int[18];
+private final int[] jjstateSet = new int[36];
+protected char curChar;
+/** Constructor. */
+public ISEParserTokenManager(JavaCharStream stream){
+ if (JavaCharStream.staticFlag)
+ throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
+ input_stream = stream;
+}
+
+/** Constructor. */
+public ISEParserTokenManager(JavaCharStream stream, int lexState){
+ this(stream);
+ SwitchTo(lexState);
+}
+
+/** Reinitialise parser. */
+public void ReInit(JavaCharStream stream)
+{
+ jjmatchedPos = jjnewStateCnt = 0;
+ curLexState = defaultLexState;
+ input_stream = stream;
+ ReInitRounds();
+}
+private void ReInitRounds()
+{
+ int i;
+ jjround = 0x80000001;
+ for (i = 18; i-- > 0;)
+ jjrounds[i] = 0x80000000;
+}
+
+/** Reinitialise parser. */
+public void ReInit(JavaCharStream stream, int lexState)
+{
+ ReInit(stream);
+ SwitchTo(lexState);
+}
+
+/** Switch to specified lex state. */
+public void SwitchTo(int lexState)
+{
+ if (lexState >= 1 || lexState < 0)
+ throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
+ else
+ curLexState = lexState;
+}
+
+protected Token jjFillToken()
+{
+ final Token t;
+ final String curTokenImage;
+ final int beginLine;
+ final int endLine;
+ final int beginColumn;
+ final int endColumn;
+ String im = jjstrLiteralImages[jjmatchedKind];
+ curTokenImage = (im == null) ? input_stream.GetImage() : im;
+ beginLine = input_stream.getBeginLine();
+ beginColumn = input_stream.getBeginColumn();
+ endLine = input_stream.getEndLine();
+ endColumn = input_stream.getEndColumn();
+ t = Token.newToken(jjmatchedKind, curTokenImage);
+
+ t.beginLine = beginLine;
+ t.endLine = endLine;
+ t.beginColumn = beginColumn;
+ t.endColumn = endColumn;
+
+ return t;
+}
+
+int curLexState = 0;
+int defaultLexState = 0;
+int jjnewStateCnt;
+int jjround;
+int jjmatchedPos;
+int jjmatchedKind;
+
+/** Get the next Token. */
+public Token getNextToken()
+{
+ Token matchedToken;
+ int curPos = 0;
+
+ EOFLoop :
+ for (;;)
+ {
+ try
+ {
+ curChar = input_stream.BeginToken();
+ }
+ catch(java.io.IOException e)
+ {
+ jjmatchedKind = 0;
+ matchedToken = jjFillToken();
+ return matchedToken;
+ }
+
+ jjmatchedKind = 0x7fffffff;
+ jjmatchedPos = 0;
+ curPos = jjMoveStringLiteralDfa0_0();
+ if (jjmatchedKind != 0x7fffffff)
+ {
+ if (jjmatchedPos + 1 < curPos)
+ input_stream.backup(curPos - jjmatchedPos - 1);
+ if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+ {
+ matchedToken = jjFillToken();
+ return matchedToken;
+ }
+ else
+ {
+ continue EOFLoop;
+ }
+ }
+ int error_line = input_stream.getEndLine();
+ int error_column = input_stream.getEndColumn();
+ String error_after = null;
+ boolean EOFSeen = false;
+ try { input_stream.readChar(); input_stream.backup(1); }
+ catch (java.io.IOException e1) {
+ EOFSeen = true;
+ error_after = curPos <= 1 ? "" : input_stream.GetImage();
+ if (curChar == '\n' || curChar == '\r') {
+ error_line++;
+ error_column = 0;
+ }
+ else
+ error_column++;
+ }
+ if (!EOFSeen) {
+ input_stream.backup(1);
+ error_after = curPos <= 1 ? "" : input_stream.GetImage();
+ }
+ throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
+ }
+}
+
+private void jjCheckNAdd(int state)
+{
+ if (jjrounds[state] != jjround)
+ {
+ jjstateSet[jjnewStateCnt++] = state;
+ jjrounds[state] = jjround;
+ }
+}
+private void jjAddStates(int start, int end)
+{
+ do {
+ jjstateSet[jjnewStateCnt++] = jjnextStates[start];
+ } while (start++ != end);
+}
+private void jjCheckNAddTwoStates(int state1, int state2)
+{
+ jjCheckNAdd(state1);
+ jjCheckNAdd(state2);
+}
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/JavaCharStream.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/JavaCharStream.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/JavaCharStream.java
new file mode 100644
index 0000000..dbe7138
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/JavaCharStream.java
@@ -0,0 +1,616 @@
+/* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 5.0 */
+/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=false */
+package com.opensoc.ise.parser;
+
+/**
+ * An implementation of interface CharStream, where the stream is assumed to
+ * contain only ASCII characters (with java-like unicode escape processing).
+ */
+
+class JavaCharStream
+{
+ /** Whether parser is static. */
+ public static final boolean staticFlag = false;
+
+ static final int hexval(char c) throws java.io.IOException {
+ switch(c)
+ {
+ case '0' :
+ return 0;
+ case '1' :
+ return 1;
+ case '2' :
+ return 2;
+ case '3' :
+ return 3;
+ case '4' :
+ return 4;
+ case '5' :
+ return 5;
+ case '6' :
+ return 6;
+ case '7' :
+ return 7;
+ case '8' :
+ return 8;
+ case '9' :
+ return 9;
+
+ case 'a' :
+ case 'A' :
+ return 10;
+ case 'b' :
+ case 'B' :
+ return 11;
+ case 'c' :
+ case 'C' :
+ return 12;
+ case 'd' :
+ case 'D' :
+ return 13;
+ case 'e' :
+ case 'E' :
+ return 14;
+ case 'f' :
+ case 'F' :
+ return 15;
+ }
+
+ throw new java.io.IOException(); // Should never come here
+ }
+
+/** Position in buffer. */
+ public int bufpos = -1;
+ int bufsize;
+ int available;
+ int tokenBegin;
+ protected int bufline[];
+ protected int bufcolumn[];
+
+ protected int column = 0;
+ protected int line = 1;
+
+ protected boolean prevCharIsCR = false;
+ protected boolean prevCharIsLF = false;
+
+ protected java.io.Reader inputStream;
+
+ protected char[] nextCharBuf;
+ protected char[] buffer;
+ protected int maxNextCharInd = 0;
+ protected int nextCharInd = -1;
+ protected int inBuf = 0;
+ protected int tabSize = 8;
+
+ protected void setTabSize(int i) { tabSize = i; }
+ protected int getTabSize(int i) { return tabSize; }
+
+ protected void ExpandBuff(boolean wrapAround)
+ {
+ char[] newbuffer = new char[bufsize + 2048];
+ int newbufline[] = new int[bufsize + 2048];
+ int newbufcolumn[] = new int[bufsize + 2048];
+
+ try
+ {
+ if (wrapAround)
+ {
+ System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
+ System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos);
+ buffer = newbuffer;
+
+ System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
+ System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
+ bufline = newbufline;
+
+ System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
+ System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
+ bufcolumn = newbufcolumn;
+
+ bufpos += (bufsize - tokenBegin);
+ }
+ else
+ {
+ System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
+ buffer = newbuffer;
+
+ System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
+ bufline = newbufline;
+
+ System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
+ bufcolumn = newbufcolumn;
+
+ bufpos -= tokenBegin;
+ }
+ }
+ catch (Throwable t)
+ {
+ throw new Error(t.getMessage());
+ }
+
+ available = (bufsize += 2048);
+ tokenBegin = 0;
+ }
+
+ protected void FillBuff() throws java.io.IOException
+ {
+ int i;
+ if (maxNextCharInd == 4096)
+ maxNextCharInd = nextCharInd = 0;
+
+ try {
+ if ((i = inputStream.read(nextCharBuf, maxNextCharInd,
+ 4096 - maxNextCharInd)) == -1)
+ {
+ inputStream.close();
+ throw new java.io.IOException();
+ }
+ else
+ maxNextCharInd += i;
+ return;
+ }
+ catch(java.io.IOException e) {
+ if (bufpos != 0)
+ {
+ --bufpos;
+ backup(0);
+ }
+ else
+ {
+ bufline[bufpos] = line;
+ bufcolumn[bufpos] = column;
+ }
+ throw e;
+ }
+ }
+
+ protected char ReadByte() throws java.io.IOException
+ {
+ if (++nextCharInd >= maxNextCharInd)
+ FillBuff();
+
+ return nextCharBuf[nextCharInd];
+ }
+
+/** @return starting character for token. */
+ public char BeginToken() throws java.io.IOException
+ {
+ if (inBuf > 0)
+ {
+ --inBuf;
+
+ if (++bufpos == bufsize)
+ bufpos = 0;
+
+ tokenBegin = bufpos;
+ return buffer[bufpos];
+ }
+
+ tokenBegin = 0;
+ bufpos = -1;
+
+ return readChar();
+ }
+
+ protected void AdjustBuffSize()
+ {
+ if (available == bufsize)
+ {
+ if (tokenBegin > 2048)
+ {
+ bufpos = 0;
+ available = tokenBegin;
+ }
+ else
+ ExpandBuff(false);
+ }
+ else if (available > tokenBegin)
+ available = bufsize;
+ else if ((tokenBegin - available) < 2048)
+ ExpandBuff(true);
+ else
+ available = tokenBegin;
+ }
+
+ protected void UpdateLineColumn(char c)
+ {
+ column++;
+
+ if (prevCharIsLF)
+ {
+ prevCharIsLF = false;
+ line += (column = 1);
+ }
+ else if (prevCharIsCR)
+ {
+ prevCharIsCR = false;
+ if (c == '\n')
+ {
+ prevCharIsLF = true;
+ }
+ else
+ line += (column = 1);
+ }
+
+ switch (c)
+ {
+ case '\r' :
+ prevCharIsCR = true;
+ break;
+ case '\n' :
+ prevCharIsLF = true;
+ break;
+ case '\t' :
+ column--;
+ column += (tabSize - (column % tabSize));
+ break;
+ default :
+ break;
+ }
+
+ bufline[bufpos] = line;
+ bufcolumn[bufpos] = column;
+ }
+
+/** Read a character. */
+ public char readChar() throws java.io.IOException
+ {
+ if (inBuf > 0)
+ {
+ --inBuf;
+
+ if (++bufpos == bufsize)
+ bufpos = 0;
+
+ return buffer[bufpos];
+ }
+
+ char c;
+
+ if (++bufpos == available)
+ AdjustBuffSize();
+
+ if ((buffer[bufpos] = c = ReadByte()) == '\\')
+ {
+ UpdateLineColumn(c);
+
+ int backSlashCnt = 1;
+
+ for (;;) // Read all the backslashes
+ {
+ if (++bufpos == available)
+ AdjustBuffSize();
+
+ try
+ {
+ if ((buffer[bufpos] = c = ReadByte()) != '\\')
+ {
+ UpdateLineColumn(c);
+ // found a non-backslash char.
+ if ((c == 'u') && ((backSlashCnt & 1) == 1))
+ {
+ if (--bufpos < 0)
+ bufpos = bufsize - 1;
+
+ break;
+ }
+
+ backup(backSlashCnt);
+ return '\\';
+ }
+ }
+ catch(java.io.IOException e)
+ {
+ // We are returning one backslash so we should only backup (count-1)
+ if (backSlashCnt > 1)
+ backup(backSlashCnt-1);
+
+ return '\\';
+ }
+
+ UpdateLineColumn(c);
+ backSlashCnt++;
+ }
+
+ // Here, we have seen an odd number of backslash's followed by a 'u'
+ try
+ {
+ while ((c = ReadByte()) == 'u')
+ ++column;
+
+ buffer[bufpos] = c = (char)(hexval(c) << 12 |
+ hexval(ReadByte()) << 8 |
+ hexval(ReadByte()) << 4 |
+ hexval(ReadByte()));
+
+ column += 4;
+ }
+ catch(java.io.IOException e)
+ {
+ throw new Error("Invalid escape character at line " + line +
+ " column " + column + ".");
+ }
+
+ if (backSlashCnt == 1)
+ return c;
+ else
+ {
+ backup(backSlashCnt - 1);
+ return '\\';
+ }
+ }
+ else
+ {
+ UpdateLineColumn(c);
+ return c;
+ }
+ }
+
+ @Deprecated
+ /**
+ * @deprecated
+ * @see #getEndColumn
+ */
+ public int getColumn() {
+ return bufcolumn[bufpos];
+ }
+
+ @Deprecated
+ /**
+ * @deprecated
+ * @see #getEndLine
+ */
+ public int getLine() {
+ return bufline[bufpos];
+ }
+
+/** Get end column. */
+ public int getEndColumn() {
+ return bufcolumn[bufpos];
+ }
+
+/** Get end line. */
+ public int getEndLine() {
+ return bufline[bufpos];
+ }
+
+/** @return column of token start */
+ public int getBeginColumn() {
+ return bufcolumn[tokenBegin];
+ }
+
+/** @return line number of token start */
+ public int getBeginLine() {
+ return bufline[tokenBegin];
+ }
+
+/** Retreat. */
+ public void backup(int amount) {
+
+ inBuf += amount;
+ if ((bufpos -= amount) < 0)
+ bufpos += bufsize;
+ }
+
+/** Constructor. */
+ public JavaCharStream(java.io.Reader dstream,
+ int startline, int startcolumn, int buffersize)
+ {
+ inputStream = dstream;
+ line = startline;
+ column = startcolumn - 1;
+
+ available = bufsize = buffersize;
+ buffer = new char[buffersize];
+ bufline = new int[buffersize];
+ bufcolumn = new int[buffersize];
+ nextCharBuf = new char[4096];
+ }
+
+/** Constructor. */
+ public JavaCharStream(java.io.Reader dstream,
+ int startline, int startcolumn)
+ {
+ this(dstream, startline, startcolumn, 4096);
+ }
+
+/** Constructor. */
+ public JavaCharStream(java.io.Reader dstream)
+ {
+ this(dstream, 1, 1, 4096);
+ }
+/** Reinitialise. */
+ public void ReInit(java.io.Reader dstream,
+ int startline, int startcolumn, int buffersize)
+ {
+ inputStream = dstream;
+ line = startline;
+ column = startcolumn - 1;
+
+ if (buffer == null || buffersize != buffer.length)
+ {
+ available = bufsize = buffersize;
+ buffer = new char[buffersize];
+ bufline = new int[buffersize];
+ bufcolumn = new int[buffersize];
+ nextCharBuf = new char[4096];
+ }
+ prevCharIsLF = prevCharIsCR = false;
+ tokenBegin = inBuf = maxNextCharInd = 0;
+ nextCharInd = bufpos = -1;
+ }
+
+/** Reinitialise. */
+ public void ReInit(java.io.Reader dstream,
+ int startline, int startcolumn)
+ {
+ ReInit(dstream, startline, startcolumn, 4096);
+ }
+
+/** Reinitialise. */
+ public void ReInit(java.io.Reader dstream)
+ {
+ ReInit(dstream, 1, 1, 4096);
+ }
+/** Constructor. */
+ public JavaCharStream(java.io.InputStream dstream, String encoding, int startline,
+ int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
+ {
+ this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
+ }
+
+/** Constructor. */
+ public JavaCharStream(java.io.InputStream dstream, int startline,
+ int startcolumn, int buffersize)
+ {
+ this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
+ }
+
+/** Constructor. */
+ public JavaCharStream(java.io.InputStream dstream, String encoding, int startline,
+ int startcolumn) throws java.io.UnsupportedEncodingException
+ {
+ this(dstream, encoding, startline, startcolumn, 4096);
+ }
+
+/** Constructor. */
+ public JavaCharStream(java.io.InputStream dstream, int startline,
+ int startcolumn)
+ {
+ this(dstream, startline, startcolumn, 4096);
+ }
+
+/** Constructor. */
+ public JavaCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
+ {
+ this(dstream, encoding, 1, 1, 4096);
+ }
+
+/** Constructor. */
+ public JavaCharStream(java.io.InputStream dstream)
+ {
+ this(dstream, 1, 1, 4096);
+ }
+
+/** Reinitialise. */
+ public void ReInit(java.io.InputStream dstream, String encoding, int startline,
+ int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
+ {
+ ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
+ }
+
+/** Reinitialise. */
+ public void ReInit(java.io.InputStream dstream, int startline,
+ int startcolumn, int buffersize)
+ {
+ ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
+ }
+/** Reinitialise. */
+ public void ReInit(java.io.InputStream dstream, String encoding, int startline,
+ int startcolumn) throws java.io.UnsupportedEncodingException
+ {
+ ReInit(dstream, encoding, startline, startcolumn, 4096);
+ }
+/** Reinitialise. */
+ public void ReInit(java.io.InputStream dstream, int startline,
+ int startcolumn)
+ {
+ ReInit(dstream, startline, startcolumn, 4096);
+ }
+/** Reinitialise. */
+ public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
+ {
+ ReInit(dstream, encoding, 1, 1, 4096);
+ }
+
+/** Reinitialise. */
+ public void ReInit(java.io.InputStream dstream)
+ {
+ ReInit(dstream, 1, 1, 4096);
+ }
+
+ /** @return token image as String */
+ public String GetImage()
+ {
+ if (bufpos >= tokenBegin)
+ return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
+ else
+ return new String(buffer, tokenBegin, bufsize - tokenBegin) +
+ new String(buffer, 0, bufpos + 1);
+ }
+
+ /** @return suffix */
+ public char[] GetSuffix(int len)
+ {
+ char[] ret = new char[len];
+
+ if ((bufpos + 1) >= len)
+ System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
+ else
+ {
+ System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
+ len - bufpos - 1);
+ System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
+ }
+
+ return ret;
+ }
+
+ /** Set buffers back to null when finished. */
+ public void Done()
+ {
+ nextCharBuf = null;
+ buffer = null;
+ bufline = null;
+ bufcolumn = null;
+ }
+
+ /**
+ * Method to adjust line and column numbers for the start of a token.
+ */
+ public void adjustBeginLineColumn(int newLine, int newCol)
+ {
+ int start = tokenBegin;
+ int len;
+
+ if (bufpos >= tokenBegin)
+ {
+ len = bufpos - tokenBegin + inBuf + 1;
+ }
+ else
+ {
+ len = bufsize - tokenBegin + bufpos + 1 + inBuf;
+ }
+
+ int i = 0, j = 0, k = 0;
+ int nextColDiff = 0, columnDiff = 0;
+
+ while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
+ {
+ bufline[j] = newLine;
+ nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
+ bufcolumn[j] = newCol + columnDiff;
+ columnDiff = nextColDiff;
+ i++;
+ }
+
+ if (i < len)
+ {
+ bufline[j] = newLine++;
+ bufcolumn[j] = newCol + columnDiff;
+
+ while (i++ < len)
+ {
+ if (bufline[j = start % bufsize] != bufline[++start % bufsize])
+ bufline[j] = newLine++;
+ else
+ bufline[j] = newLine;
+ }
+ }
+
+ line = bufline[j];
+ column = bufcolumn[j];
+ }
+
+}
+/* JavaCC - OriginalChecksum=96a5b0b0fa09286690f250998f047719 (do not edit this line) */
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ParseException.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ParseException.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ParseException.java
new file mode 100644
index 0000000..31f3b5b
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/ParseException.java
@@ -0,0 +1,187 @@
+/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 5.0 */
+/* JavaCCOptions:KEEP_LINE_COL=null */
+package com.opensoc.ise.parser;
+
+/**
+ * This exception is thrown when parse errors are encountered.
+ * You can explicitly create objects of this exception type by
+ * calling the method generateParseException in the generated
+ * parser.
+ *
+ * You can modify this class to customize your error reporting
+ * mechanisms so long as you retain the public fields.
+ */
+public class ParseException extends Exception {
+
+ /**
+ * The version identifier for this Serializable class.
+ * Increment only if the <i>serialized</i> form of the
+ * class changes.
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * This constructor is used by the method "generateParseException"
+ * in the generated parser. Calling this constructor generates
+ * a new object of this type with the fields "currentToken",
+ * "expectedTokenSequences", and "tokenImage" set.
+ */
+ public ParseException(Token currentTokenVal,
+ int[][] expectedTokenSequencesVal,
+ String[] tokenImageVal
+ )
+ {
+ super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal));
+ currentToken = currentTokenVal;
+ expectedTokenSequences = expectedTokenSequencesVal;
+ tokenImage = tokenImageVal;
+ }
+
+ /**
+ * The following constructors are for use by you for whatever
+ * purpose you can think of. Constructing the exception in this
+ * manner makes the exception behave in the normal way - i.e., as
+ * documented in the class "Throwable". The fields "errorToken",
+ * "expectedTokenSequences", and "tokenImage" do not contain
+ * relevant information. The JavaCC generated code does not use
+ * these constructors.
+ */
+
+ public ParseException() {
+ super();
+ }
+
+ /** Constructor with message. */
+ public ParseException(String message) {
+ super(message);
+ }
+
+
+ /**
+ * This is the last token that has been consumed successfully. If
+ * this object has been created due to a parse error, the token
+ * followng this token will (therefore) be the first error token.
+ */
+ public Token currentToken;
+
+ /**
+ * Each entry in this array is an array of integers. Each array
+ * of integers represents a sequence of tokens (by their ordinal
+ * values) that is expected at this point of the parse.
+ */
+ public int[][] expectedTokenSequences;
+
+ /**
+ * This is a reference to the "tokenImage" array of the generated
+ * parser within which the parse error occurred. This array is
+ * defined in the generated ...Constants interface.
+ */
+ public String[] tokenImage;
+
+ /**
+ * It uses "currentToken" and "expectedTokenSequences" to generate a parse
+ * error message and returns it. If this object has been created
+ * due to a parse error, and you do not catch it (it gets thrown
+ * from the parser) the correct error message
+ * gets displayed.
+ */
+ private static String initialise(Token currentToken,
+ int[][] expectedTokenSequences,
+ String[] tokenImage) {
+ String eol = System.getProperty("line.separator", "\n");
+ StringBuffer expected = new StringBuffer();
+ int maxSize = 0;
+ for (int i = 0; i < expectedTokenSequences.length; i++) {
+ if (maxSize < expectedTokenSequences[i].length) {
+ maxSize = expectedTokenSequences[i].length;
+ }
+ for (int j = 0; j < expectedTokenSequences[i].length; j++) {
+ expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' ');
+ }
+ if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
+ expected.append("...");
+ }
+ expected.append(eol).append(" ");
+ }
+ String retval = "Encountered \"";
+ Token tok = currentToken.next;
+ for (int i = 0; i < maxSize; i++) {
+ if (i != 0) retval += " ";
+ if (tok.kind == 0) {
+ retval += tokenImage[0];
+ break;
+ }
+ retval += " " + tokenImage[tok.kind];
+ retval += " \"";
+ retval += add_escapes(tok.image);
+ retval += " \"";
+ tok = tok.next;
+ }
+ retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
+ retval += "." + eol;
+ if (expectedTokenSequences.length == 1) {
+ retval += "Was expecting:" + eol + " ";
+ } else {
+ retval += "Was expecting one of:" + eol + " ";
+ }
+ retval += expected.toString();
+ return retval;
+ }
+
+ /**
+ * The end of line string for this machine.
+ */
+ protected String eol = System.getProperty("line.separator", "\n");
+
+ /**
+ * Used to convert raw characters to their escaped version
+ * when these raw version cannot be used as part of an ASCII
+ * string literal.
+ */
+ static String add_escapes(String str) {
+ StringBuffer retval = new StringBuffer();
+ char ch;
+ for (int i = 0; i < str.length(); i++) {
+ switch (str.charAt(i))
+ {
+ case 0 :
+ continue;
+ case '\b':
+ retval.append("\\b");
+ continue;
+ case '\t':
+ retval.append("\\t");
+ continue;
+ case '\n':
+ retval.append("\\n");
+ continue;
+ case '\f':
+ retval.append("\\f");
+ continue;
+ case '\r':
+ retval.append("\\r");
+ continue;
+ case '\"':
+ retval.append("\\\"");
+ continue;
+ case '\'':
+ retval.append("\\\'");
+ continue;
+ case '\\':
+ retval.append("\\\\");
+ continue;
+ default:
+ if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+ String s = "0000" + Integer.toString(ch, 16);
+ retval.append("\\u" + s.substring(s.length() - 4, s.length()));
+ } else {
+ retval.append(ch);
+ }
+ continue;
+ }
+ }
+ return retval.toString();
+ }
+
+}
+/* JavaCC - OriginalChecksum=f9f7217056f99de5708d01ebd497dede (do not edit this line) */
http://git-wip-us.apache.org/repos/asf/incubator-metron/blob/90cda3ff/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/Token.java
----------------------------------------------------------------------
diff --git a/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/Token.java b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/Token.java
new file mode 100644
index 0000000..805125f
--- /dev/null
+++ b/metron-streaming/Metron-Common/src/main/java/com/apache/metron/ise/parser/Token.java
@@ -0,0 +1,131 @@
+/* Generated By:JavaCC: Do not edit this line. Token.java Version 5.0 */
+/* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null,SUPPORT_CLASS_VISIBILITY_PUBLIC=false */
+package com.opensoc.ise.parser;
+
+/**
+ * Describes the input token stream.
+ */
+
+class Token implements java.io.Serializable {
+
+ /**
+ * The version identifier for this Serializable class.
+ * Increment only if the <i>serialized</i> form of the
+ * class changes.
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * An integer that describes the kind of this token. This numbering
+ * system is determined by JavaCCParser, and a table of these numbers is
+ * stored in the file ...Constants.java.
+ */
+ public int kind;
+
+ /** The line number of the first character of this Token. */
+ public int beginLine;
+ /** The column number of the first character of this Token. */
+ public int beginColumn;
+ /** The line number of the last character of this Token. */
+ public int endLine;
+ /** The column number of the last character of this Token. */
+ public int endColumn;
+
+ /**
+ * The string image of the token.
+ */
+ public String image;
+
+ /**
+ * A reference to the next regular (non-special) token from the input
+ * stream. If this is the last token from the input stream, or if the
+ * token manager has not read tokens beyond this one, this field is
+ * set to null. This is true only if this token is also a regular
+ * token. Otherwise, see below for a description of the contents of
+ * this field.
+ */
+ public Token next;
+
+ /**
+ * This field is used to access special tokens that occur prior to this
+ * token, but after the immediately preceding regular (non-special) token.
+ * If there are no such special tokens, this field is set to null.
+ * When there are more than one such special token, this field refers
+ * to the last of these special tokens, which in turn refers to the next
+ * previous special token through its specialToken field, and so on
+ * until the first special token (whose specialToken field is null).
+ * The next fields of special tokens refer to other special tokens that
+ * immediately follow it (without an intervening regular token). If there
+ * is no such token, this field is null.
+ */
+ public Token specialToken;
+
+ /**
+ * An optional attribute value of the Token.
+ * Tokens which are not used as syntactic sugar will often contain
+ * meaningful values that will be used later on by the compiler or
+ * interpreter. This attribute value is often different from the image.
+ * Any subclass of Token that actually wants to return a non-null value can
+ * override this method as appropriate.
+ */
+ public Object getValue() {
+ return null;
+ }
+
+ /**
+ * No-argument constructor
+ */
+ public Token() {}
+
+ /**
+ * Constructs a new token for the specified Image.
+ */
+ public Token(int kind)
+ {
+ this(kind, null);
+ }
+
+ /**
+ * Constructs a new token for the specified Image and Kind.
+ */
+ public Token(int kind, String image)
+ {
+ this.kind = kind;
+ this.image = image;
+ }
+
+ /**
+ * Returns the image.
+ */
+ public String toString()
+ {
+ return image;
+ }
+
+ /**
+ * Returns a new Token object, by default. However, if you want, you
+ * can create and return subclass objects based on the value of ofKind.
+ * Simply add the cases to the switch for all those special cases.
+ * For example, if you have a subclass of Token called IDToken that
+ * you want to create if ofKind is ID, simply add something like :
+ *
+ * case MyParserConstants.ID : return new IDToken(ofKind, image);
+ *
+ * to the following switch statement. Then you can cast matchedToken
+ * variable to the appropriate type and use sit in your lexical actions.
+ */
+ public static Token newToken(int ofKind, String image)
+ {
+ switch(ofKind)
+ {
+ default : return new Token(ofKind, image);
+ }
+ }
+
+ public static Token newToken(int ofKind)
+ {
+ return newToken(ofKind, null);
+ }
+
+}
+/* JavaCC - OriginalChecksum=99daf0baa94b6c270eea5be0575db6aa (do not edit this line) */