Merge branch 'transparent' into 0.2.x, stateless code parser updated

Author: pfmiles

src/main/java/com/github/pfmiles/dropincc/impl/runtime/impl/CodeParser.java

@@ -24,7 +24,7 @@
  * @author pf-miles
  * 
  */
-public abstract class CodeParser extends Parser {
+public abstract class CodeParser extends Parser implements Cloneable {
 
     protected CodeLexer lexer;
 
@@ -89,4 +89,16 @@ protected DelayedAction newDelayedAction(Object action, Object matched) {
         }
         return new DelayedAction(action, matched);
     }
+
+    protected CodeParser clone() {
+        CodeParser ret = null;
+        try {
+            ret = (CodeParser) super.clone();
+        } catch (CloneNotSupportedException e) {
+            throw new DropinccException(e);
+        }
+        // reset all states
+        ret.parseCache = new HashMap<ParseCacheKey, Pair<DelayedAction, Integer>>();
+        return ret;
+    }
 }

src/main/java/com/github/pfmiles/dropincc/impl/runtime/impl/StatelessParserPrototype.java

@@ -11,14 +11,9 @@
 package com.github.pfmiles.dropincc.impl.runtime.impl;
 
 import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 import com.github.pfmiles.dropincc.DropinccException;
-import com.github.pfmiles.dropincc.Predicate;
-import com.github.pfmiles.dropincc.impl.TokenType;
 import com.github.pfmiles.dropincc.impl.syntactical.codegen.ParserCodeGenResult;
 
 /**
@@ -27,16 +22,9 @@
  */
 public class StatelessParserPrototype implements ParserPrototype {
 
-    private Class<? extends Parser> parserCls;
-
-    private Map<String, TokenType> fieldTokenTypeMapping = new HashMap<String, TokenType>();
-    private Map<String, Object> fieldAltsActionMapping = new HashMap<String, Object>();
-    private Map<String, Predicate<?>> fieldPredsMapping = new HashMap<String, Predicate<?>>();
-    private Map<String, RunningDfaState> fieldRuleDfaMapping = new HashMap<String, RunningDfaState>();
-    private Map<String, RunningDfaState> fieldKleeneDfaMapping = new HashMap<String, RunningDfaState>();
-
-    // parser fields cache
-    private Map<String, Field> parserFieldsCache = new HashMap<String, Field>();
+    // because the parser is implemented stateless. So we can reuse the parser
+    // instance over and over again by cloning it.
+    private CodeParser parserPrototype;
 
     /**
      * Construct a stateless singleton parser prototype by parser class.
@@ -45,57 +33,35 @@ public class StatelessParserPrototype implements ParserPrototype {
      * @param parserCodeGenResult
      */
     public StatelessParserPrototype(Class<? extends Parser> cls, ParserCodeGenResult parserCodeGenResult) {
-        this.parserCls = cls;
-        this.fieldAltsActionMapping = parserCodeGenResult.getFieldAltsActionMapping();
-        this.fieldKleeneDfaMapping = parserCodeGenResult.getFieldKleeneDfaMapping();
-        this.fieldPredsMapping = parserCodeGenResult.getFieldPredsMapping();
-        this.fieldRuleDfaMapping = parserCodeGenResult.getFieldRuleDfaMapping();
-        this.fieldTokenTypeMapping = parserCodeGenResult.getFieldTokenTypeMapping();
-        // init fields cache
-        List<String> allFields = new ArrayList<String>();
-        allFields.addAll(this.fieldAltsActionMapping.keySet());
-        allFields.addAll(this.fieldKleeneDfaMapping.keySet());
-        allFields.addAll(this.fieldPredsMapping.keySet());
-        allFields.addAll(this.fieldRuleDfaMapping.keySet());
-        allFields.addAll(this.fieldTokenTypeMapping.keySet());
-        for (String fname : allFields) {
-            try {
-                Field f = cls.getField(fname);
-                f.setAccessible(true);// this boosts reflection
-                this.parserFieldsCache.put(fname, f);
-            } catch (Exception e) {
-                throw new DropinccException(e);
-            }
+        try {
+            this.parserPrototype = (CodeParser) cls.newInstance();
+        } catch (Exception e) {
+            throw new DropinccException(e);
         }
+        // setting all compiled results
+        mappingField(cls, parserPrototype, parserCodeGenResult.getFieldAltsActionMapping());
+        mappingField(cls, parserPrototype, parserCodeGenResult.getFieldKleeneDfaMapping());
+        mappingField(cls, parserPrototype, parserCodeGenResult.getFieldPredsMapping());
+        mappingField(cls, parserPrototype, parserCodeGenResult.getFieldRuleDfaMapping());
+        mappingField(cls, parserPrototype, parserCodeGenResult.getFieldTokenTypeMapping());
+
     }
 
     // setting fields' values of obj by field name to value mapping
-    private void mappingField(Object obj, Map<String, ?> fieldToValue) {
-        for (Map.Entry<String, ?> e : fieldToValue.entrySet()) {
-            Field f = this.parserFieldsCache.get(e.getKey());
-            try {
-                // those fields are public
+    private void mappingField(Class<?> cls, Object obj, Map<String, ?> fieldToValue) {
+        try {
+            for (Map.Entry<String, ?> e : fieldToValue.entrySet()) {
+                Field f = cls.getField(e.getKey());
+                f.setAccessible(true);
                 f.set(obj, e.getValue());
-            } catch (Exception ex) {
-                throw new DropinccException(ex);
             }
+        } catch (Exception ex) {
+            throw new DropinccException(ex);
         }
     }
 
     public Parser create(Lexer lexer) {
-        Parser parser = null;
-        try {
-            parser = parserCls.newInstance();
-        } catch (Exception e) {
-            throw new DropinccException(e);
-        }
-        // setting all compiled results
-        mappingField(parser, this.fieldAltsActionMapping);
-        mappingField(parser, this.fieldKleeneDfaMapping);
-        mappingField(parser, this.fieldPredsMapping);
-        mappingField(parser, this.fieldRuleDfaMapping);
-        mappingField(parser, this.fieldTokenTypeMapping);
-
+        Parser parser = this.parserPrototype.clone();
         parser.setLexer(lexer);
         return parser;
     }