Config parser/loader changes: IfOreDict can now contain only delayed statements and is a delayed statement itself (will be evaluated when loadDealayed is called)

Also 2 new terms added at parser level - delayedStatement(s) - to separate lists that require delayed statements

src/net/bdew/lib/recipes/DataClasses.scala

@@ -125,13 +125,14 @@ case class StIfHaveMod(mod: String, thn: List[Statement], els: List[Statement])
 
 /**
  * Conditional block - checks if mod is loaded
+ * Can contain only delayed statements
  * Syntax: ifOreDict {string} { {statements} } [else { {statements} }]
  * Parser: [[net.bdew.lib.recipes.RecipeParser.ifOreDict]]
  * @param id Ore Dictionary Entry
  * @param thn Statements to run if present
  * @param els Statements to run otherwise
  */
-case class StIfHaveOD(id: String, thn: List[Statement], els: List[Statement]) extends Statement
+case class StIfHaveOD(id: String, thn: List[DelayedStatement], els: List[DelayedStatement]) extends DelayedStatement
 
 /**
  * Removes previously defined recieps for a specific result

src/net/bdew/lib/recipes/RecipeLoader.scala

@@ -222,15 +222,6 @@ class RecipeLoader {
         processStatementsSafe(els)
       }
 
-    case StIfHaveOD(od, thn, els) =>
-      if (OreDictionary.getOres(od).size() > 0) {
-        log.info("ifOreDict: %s found".format(od))
-        processStatementsSafe(thn)
-      } else {
-        log.info("ifOreDict: %s not found".format(od))
-        processStatementsSafe(els)
-      }
-
     case StClearRecipes(res) =>
       log.info("Clearing recipes that produce %s".format(res))
       delayedStatements = delayedStatements.filter({
@@ -315,16 +306,34 @@ class RecipeLoader {
         }
       }
 
+    case StIfHaveOD(od, thn, els) =>
+      if (OreDictionary.getOres(od).size() > 0) {
+        log.info("ifOreDict: %s found".format(od))
+        processDelayedStatementsSafe(thn)
+      } else {
+        log.info("ifOreDict: %s not found".format(od))
+        processDelayedStatementsSafe(els)
+      }
+
     case x =>
       log.severe("Can't process %s - this is a programing bug!".format(x))
   }
 
   /**
-   * Process delayed statements, clear the list afterwards
+   * Process main delayed statements list, clear the list afterwards
    */
   def processDelayedStatements() {
     log.info("Processing %d delayed statements".format(delayedStatements.size))
-    for (s <- delayedStatements) {
+    processDelayedStatementsSafe(delayedStatements)
+    delayedStatements = List.empty
+  }
+
+  /**
+   * Process a list of delayed statements and catch all exceptions
+   * @param list The list to process
+   */
+  def processDelayedStatementsSafe(list: List[DelayedStatement]) {
+    for (s <- list) {
       try {
         processDelayedStatement(s)
       } catch {
@@ -335,9 +344,9 @@ class RecipeLoader {
           e.printStackTrace()
       }
     }
-    delayedStatements = List.empty
   }
 
+
   /**
    * Process a list of statements and catch all exceptions
    * @param r The list to process

src/net/bdew/lib/recipes/RecipeParser.scala

@@ -78,8 +78,8 @@ class RecipeParser extends JavaTokenParsers {
     case mod ~ thn ~ els => new StIfHaveMod(mod, thn, els.getOrElse(List.empty[Statement]))
   }
 
-  def ifOreDict = ("ifOreDict" ~> str) ~ ("{" ~> statements <~ "}") ~ ("else" ~> "{" ~> statements <~ "}").? ^^ {
-    case id ~ thn ~ els => new StIfHaveOD(id, thn, els.getOrElse(List.empty[Statement]))
+  def ifOreDict = ("ifOreDict" ~> str) ~ ("{" ~> delayedStatements <~ "}") ~ ("else" ~> "{" ~> delayedStatements <~ "}").? ^^ {
+    case id ~ thn ~ els => new StIfHaveOD(id, thn, els.getOrElse(List.empty[DelayedStatement]))
   }
 
   def recipeShaped3x3 = recipeTriplet ~ recipeTriplet ~ ("=>" ~> specWithCount) ~ recipeTriplet ^^ {
@@ -104,20 +104,21 @@ class RecipeParser extends JavaTokenParsers {
 
   def clearRecipes = "clearRecipes" ~> ":" ~> spec ^^ { case sp => StClearRecipes(sp) }
 
-  def statement: Parser[Statement] = (
+  def delayedStatement: Parser[DelayedStatement] = (
     charSpec
       | classMacro
-      | ifMod
       | ifOreDict
       | recipeShaped3x3
       | recipeShaped2x2
       | recipeShaped9
       | recipeShapeless
       | recipeSmelting
-      | clearRecipes
     )
 
+  def statement: Parser[Statement] = delayedStatement | ifMod | clearRecipes
+
   def statements = statement.*
+  def delayedStatements = delayedStatement.*
 
   def doParse(r: Reader): List[Statement] = {
     parseAll(statements, r) match {