fable 3.0.134 → 3.0.136

package/example_applications/mathematical_playground/.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+	// Use IntelliSense to learn about possible attributes.
+	// Hover to view descriptions of existing attributes.
+	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"type": "node",
+			"request": "launch",
+			"name": "Launch Program",
+			"skipFiles": [
+				"<node_internals>/**"
+			],
+			"program": "${workspaceFolder}/Math-Solver-Harness.js"
+		}
+	]
+}

package/example_applications/mathematical_playground/Math-Solver-Harness.js

@@ -15,35 +15,35 @@ _Fable.log.info(`One-liner solve is: ${_Fable.ExpressionParser.solve("Result = 7
 // Let's put it in a variable for easier exercises
 const _ExpressionParser = _Fable.ExpressionParser;
 // Look up somoe variables in an object
-_Fable.log.info(`One-liner solve with variables is: ${_ExpressionParser.solve("Volume = Width * Height * Depth", {"Width": 73.5, "Height": 28.8, "Depth": 200.5})}`);
+// _Fable.log.info(`One-liner solve with variables is: ${_ExpressionParser.solve("Volume = Width * Height * Depth", {"Width": 73.5, "Height": 28.8, "Depth": 200.5})}`);
 
 
-/* * * * * * * * * * * * * * * * *
- *
- * A simple run through of some mathematical expressions
- * 
- */
-_Fable.log.info(`Beginning Run-through for Set of Test Expressions....`);
-// An array of equations with expected values
-let _Equations = require(`./Equations.json`);
-// The application state is a plain javascript object we pass into the solver to pull variables from
-let _AppData = require(`./AppData.json`);
-// The manifest is a Manyfest which describes hashes for complex addresses in the application state object
-// For example you can't use "Student[0].Age" as a variable in the expression
-// ...but you can use "Student[0].Age" as an address in the manifest with a hash of "StudentAge"
-// ...and then reference "StudentAge" in the expression.
-let tmpManifestConfiguration = { "Scope":"None", "Descriptors":[] };
-let tmpManifest = _Fable.newManyfest(tmpManifestConfiguration);
-// Run each expression in the Equations.json file through the expression parser.
-for (let i = 0; i < _Equations.Expressions.length; i++)
-{
-	let tmpResultValue = _ExpressionParser.solve(_Equations.Expressions[i].Equation, _AppData, {}, tmpManifest);
-	console.log(`Expression [${i}]: [${_Equations.Expressions[i].Equation}] ==> ${tmpResultValue}`);
-	if (tmpResultValue !== _Equations.Expressions[i].ExpectedResult)
-	{
-		console.log(`Error: Equation ${_Equations.Expressions[i].Equation} expected [${_Equations.Expressions[i].ExpectedResult}] but got [${tmpResultValue}]`);
-	}
-}
+// /* * * * * * * * * * * * * * * * *
+//  *
+//  * A simple run through of some mathematical expressions
+//  * 
+//  */
+// _Fable.log.info(`Beginning Run-through for Set of Test Expressions....`);
+// // An array of equations with expected values
+// let _Equations = require(`./Equations.json`);
+// // The application state is a plain javascript object we pass into the solver to pull variables from
+// let _AppData = require(`./AppData.json`);
+// // The manifest is a Manyfest which describes hashes for complex addresses in the application state object
+// // For example you can't use "Student[0].Age" as a variable in the expression
+// // ...but you can use "Student[0].Age" as an address in the manifest with a hash of "StudentAge"
+// // ...and then reference "StudentAge" in the expression.
+// let tmpManifestConfiguration = { "Scope":"None", "Descriptors":[] };
+// let tmpManifest = _Fable.newManyfest(tmpManifestConfiguration);
+// // Run each expression in the Equations.json file through the expression parser.
+// for (let i = 0; i < _Equations.Expressions.length; i++)
+// {
+// 	let tmpResultValue = _ExpressionParser.solve(_Equations.Expressions[i].Equation, _AppData, {}, tmpManifest);
+// 	console.log(`Expression [${i}]: [${_Equations.Expressions[i].Equation}] ==> ${tmpResultValue}`);
+// 	if (tmpResultValue !== _Equations.Expressions[i].ExpectedResult)
+// 	{
+// 		console.log(`Error: Equation ${_Equations.Expressions[i].Equation} expected [${_Equations.Expressions[i].ExpectedResult}] but got [${tmpResultValue}]`);
+// 	}
+// }
 
 
 /* * * * * * * * * * * * * * * * *
@@ -59,7 +59,7 @@ let _FruitManifest = _Fable.newManyfest(_FruitManifestDescription);
 _Fable.log.info(`Beginning Manual Solve with Embedded Fruit Data....`);
 
 // The expression we pass into the solver is just a string
-let tmpExpression = 'HyperMax.HealthIndex = (SUM(Calories) / SUM(Sugar)) * MEDIAN(Fat) + (SQRT(AVG(Protein)) - (PI() + 99)';
+let tmpExpression = 'HyperMax.HealthIndex = (SUM(Calories) / SUM(Sugar)) * MEDIAN(Fat) + (SQRT(AVG(Protein)) - (PI() + 99))';
 _Fable.log.info(`Solving tmpExpression: [${tmpExpression}]`);
 
 // This is an object where the parser will write out the results of each phase of the compiler/parser/solver
@@ -74,15 +74,12 @@ let complexLintedResults = _ExpressionParser.lintTokenizedExpression(complexToke
 let complexPostfixedResults = _ExpressionParser.buildPostfixedSolveList(complexTokenizedResults, tmpExpressionParseOutcome);
 // Step 4: Substitute the values references in the tokenized objects representing data within the postfixed expression
 _ExpressionParser.substituteValuesInTokenizedObjects(tmpExpressionParseOutcome.PostfixTokenObjects, _FruitData, tmpExpressionParseOutcome, _FruitManifest);
-// Now that we have a postfixed expression and the mapped-in values, show the user what the solution steps look like
-for (let i = 0; i < tmpExpressionParseOutcome.PostfixSolveList.length; i++)
-{
-	let tmpToken = tmpExpressionParseOutcome.PostfixSolveList[i];
-	console.log(`${i}: ${tmpToken.VirtualSymbolName} = (${tmpToken.LeftValue.Token}::${tmpToken.LeftValue.Value})  ${tmpToken.Operation.Token}  (${tmpToken.RightValue.Token}::${tmpToken.RightValue.Value}) `)
-}
 // Step 5: Solve the postfixed expression
 let tmpResultValue = _ExpressionParser.solvePostfixedExpression(tmpExpressionParseOutcome.PostfixSolveList, tmpSolverResultsObject, tmpExpressionParseOutcome, _FruitManifest);
 
+// Now that we have a solved expression and the mapped-in values, show the user the solution
+_Fable.ExpressionParser.Messaging.logFunctionOutcome(tmpExpressionParseOutcome);
+
 // Step 6: Look at the results.
 console.log(`Outcome object: ${JSON.stringify(tmpSolverResultsObject)}`);
 console.log(`Result of ${tmpExpression} solve: ${tmpResultValue}`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.134",
+    "version": "3.0.136",
     "description": "A service dependency injection, configuration and logging library.",
     "main": "source/Fable.js",
     "scripts": {

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-ExpressionTokenizer.js

@@ -5,7 +5,6 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 	constructor(pFable, pOptions, pServiceHash)
 	{
 		super(pFable, pOptions, pServiceHash);
-
 		this.serviceType = 'ExpressionParser-Tokenizer';
 	}
 

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-Linter.js

@@ -5,7 +5,6 @@ class ExpressionParserLinter extends libExpressionParserOperationBase
 	constructor(pFable, pOptions, pServiceHash)
 	{
 		super(pFable, pOptions, pServiceHash);
-
 		this.serviceType = 'ExpressionParser-Linter';
 	}
 

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-Messaging.js

@@ -0,0 +1,159 @@
+const { PE } = require('big.js');
+const libExpressionParserOperationBase = require('./Fable-Service-ExpressionParser-Base.js');
+
+/**
+ * Represents a user-friendly messaging service for the ExpressionParser compiler output.
+ * @class ExpressionParserMessaging
+ * @extends libExpressionParserOperationBase
+ */
+class ExpressionParserMessaging extends libExpressionParserOperationBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+		this.serviceType = 'ExpressionParser-Messaging';
+	}
+
+	getOperationVirtualSymbolName(pOperationToken)
+	{
+		return (pOperationToken && ('VirtualSymbolName' in pOperationToken)) ? pOperationToken.VirtualSymbolName 
+			: (pOperationToken.Type === 'Token.VirtualSymbol') ? pOperationToken.Token
+			: 'NO_VIRTUAL_SYMBOL_NAME_FOUND';
+	}
+
+	getVirtualTokenValue(pToken, pOperationResults)
+	{
+		let tmpVirtualSymbol = this.getOperationVirtualSymbolName(pToken);
+		let tmpVirtualSymbolData = ('VirtualSymbols' in pOperationResults) ? pOperationResults.VirtualSymbols : {};
+		
+		if (this.ExpressionParser.GenericManifest.checkAddressExists(tmpVirtualSymbolData, tmpVirtualSymbol))
+		{
+			let tmpValue = this.ExpressionParser.GenericManifest.getValueAtAddress(tmpVirtualSymbolData, tmpVirtualSymbol);
+
+			if (typeof(tmpValue) === 'object')
+			{
+				return `{${Object.keys(tmpValue).length} values}`;
+			}
+			if (Array.isArray(tmpValue))
+			{
+				return `[${Object.keys(tmpValue).length} values]`;
+			}
+			return tmpValue;
+		}
+
+		return 'NO_VALUE_FOUND';
+	}
+
+	getTokenAddressString(pToken)
+	{
+		return pExpression.Token;
+	}
+
+	getTokenSymbolString(pExpressionToken)
+	{
+		return pExpressionToken.Token;
+	}
+
+	getOperationSymbolMessage(pOperation)
+	{
+		if (!pOperation)
+		{
+			return 'INVALID_OPERATION';
+		}
+		let tmpOperationVirtualSymbol = this.getOperationVirtualSymbolName(pOperation);
+		let tmpOperationLeftValue = this.getTokenSymbolString(pOperation.LeftValue);
+		let tmpOperationSymbol = this.getTokenSymbolString(pOperation.Operation);
+		let tmpOperationRightValue = this.getTokenSymbolString(pOperation.RightValue);
+
+		let tmpVirtualSymbolPrefix = tmpOperationVirtualSymbol.substring(0, 3);
+
+		if (tmpOperationSymbol === '=')
+		{
+			// Assignment operators are special
+			return `${tmpOperationVirtualSymbol} = ${tmpOperationLeftValue}`;
+		}
+
+		if (tmpVirtualSymbolPrefix === 'VFE')
+		{
+			// Virtual Function Expression
+			return `${tmpOperationVirtualSymbol} = ${tmpOperationSymbol}(${tmpOperationRightValue})`;
+		}
+
+		return `${tmpOperationVirtualSymbol} = ${tmpOperationLeftValue} ${tmpOperationSymbol} ${tmpOperationRightValue}`;
+	}
+
+	getOperationValueMessage(pOperation, pResultObject)
+	{
+		if (!pOperation)
+		{
+			return 'INVALID_OPERATION';
+		}
+		let tmpOperationVirtualSymbol = this.getOperationVirtualSymbolName(pOperation);
+		let tmpOperationLeftValue = this.getVirtualTokenValue(pOperation.LeftValue, pResultObject);
+		let tmpOperationSymbol = this.getTokenSymbolString(pOperation.Operation);
+		let tmpOperationRightValue = this.getVirtualTokenValue(pOperation.RightValue, pResultObject);
+
+		let tmpVirtualSymbolPrefix = tmpOperationVirtualSymbol.substring(0, 3);
+
+		if (tmpOperationSymbol === '=')
+		{
+			// Assignment operators are special
+			return `${tmpOperationVirtualSymbol} = ${tmpOperationLeftValue}`;
+		}
+
+		if (tmpVirtualSymbolPrefix === 'VFE')
+		{
+			// Virtual Function Expression
+			return `${tmpOperationVirtualSymbol} = ${tmpOperationSymbol}(${tmpOperationLeftValue})`;
+		}
+
+		return `${tmpOperationVirtualSymbol} = ${tmpOperationLeftValue} ${tmpOperationSymbol} ${tmpOperationRightValue}`;
+	}
+
+	logFunctionOutcome(pResultObject)
+	{
+		if (typeof(pResultObject) !== 'object')
+		{
+			this.log.error(`Solver results object was not an object.  Cannot log outcome.`);
+			return;
+		}
+		let tmpAssignmentAddress = ('PostfixedAssignmentAddress' in pResultObject) ? pResultObject.PostfixedAssignmentAddress : 'NO_ASSIGNMENT_ADDRESS_FOUND';
+		let tmpRawExpression = ('RawExpression' in pResultObject) ? pResultObject.RawExpression : 'NO_EXPRESSION_FOUND';
+		let tmpRawResult = ('RawResult' in pResultObject) ? pResultObject.RawResult : 'NO_RESULT_FOUND';
+
+		this.log.info(`Solved f(${tmpAssignmentAddress}) = {${tmpRawExpression}}`);
+		for (let i = 0; i < pResultObject.PostfixSolveList.length; i++)
+		{
+			let tmpToken = pResultObject.PostfixSolveList[i];
+			let tmpTokenSymbolMessage = this.getOperationSymbolMessage(tmpToken);
+			this.log.info(`${i} Symbols: ${tmpTokenSymbolMessage}`);
+			let tmpTokenValueMessage = this.getOperationValueMessage(tmpToken, pResultObject);
+			this.log.info(`${i}  Values: ${tmpTokenValueMessage}`);
+		}
+		this.log.info(`{${tmpRawExpression}} = ${tmpRawResult}`);
+	}
+
+	logFunctionSolve(pResultObject)
+	{
+		if (typeof(pResultObject) !== 'object')
+		{
+			this.log.error(`Solver results object was not an object.  Cannot log the solve.`);
+			return;
+		}
+		if (!('PostfixSolveList' in pResultObject) || !Array.isArray(pResultObject.PostfixSolveList))
+		{
+			this.log.error(`Solver results object did not contain a PostfixSolveList array.  Cannot log the solve.`);
+			return;
+		}
+
+		for (let i = 0; i < tmpExpressionParseOutcome.PostfixSolveList.length; i++)
+		{
+			let tmpToken = tmpExpressionParseOutcome.PostfixSolveList[i];
+			console.log(`${i}: ${tmpToken.VirtualSymbolName} = (${tmpToken.LeftValue.Token}::${tmpToken.LeftValue.Value})  ${tmpToken.Operation.Token}  (${tmpToken.RightValue.Token}::${tmpToken.RightValue.Value}) `)
+		}
+
+		this.logFunctionOutcome(pResultObject);
+	}
+}
+
+module.exports = ExpressionParserMessaging;

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-Postfix.js

@@ -5,7 +5,6 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 	constructor(pFable, pOptions, pServiceHash)
 	{
 		super(pFable, pOptions, pServiceHash);
-
 		this.serviceType = 'ExpressionParser-Postfix';
 	}
 
@@ -638,9 +637,13 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 		}
 
 		// 7. Lastly set the assignment address.
-		let tmpAssignmentInstruction = this.getPosfixSolveListOperation(this.getTokenContainerObject('Assign', 'Token.SolverInstruction'), this.getTokenContainerObject('DestinationHash', 'Token.SolverInstruction'), this.getTokenContainerObject('Resulting', 'Token.SolverInstruction'));
-		tmpAssignmentInstruction.VirtualSymbolName = tmpResults.PostfixedAssignmentAddress;
-		tmpResults.PostfixSolveList.push(tmpAssignmentInstruction);
+		let tmpAbstractAssignToken = this.getTokenContainerObject('=');
+		// The address we are assigning to
+		tmpAbstractAssignToken.VirtualSymbolName = tmpResults.PostfixedAssignmentAddress;
+		// The address it's coming from
+		let tmpSolveResultToken = this.getTokenContainerObject('Result', 'Token.LastResult');
+		let tmpFinalAssignmentInstruction = this.getPosfixSolveListOperation(tmpAbstractAssignToken, tmpSolveResultToken, this.getTokenContainerObject('SolverMarshal', 'Token.SolverMarshal'));
+		tmpResults.PostfixSolveList.push(tmpFinalAssignmentInstruction);
 
 		return tmpResults.PostfixSolveList;
 	}

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-SolvePostfixedExpression.js

@@ -5,7 +5,6 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 	constructor(pFable, pOptions, pServiceHash)
 	{
 		super(pFable, pOptions, pServiceHash);
-
 		this.serviceType = 'ExpressionParser-Solver';
 	}
 
@@ -48,7 +47,15 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 			}
 			let tmpStepResultObject = { ExpressionStep: pPostfixedExpression[i], ExpressionStepIndex: i, ResultsObject: tmpResults, Manifest: tmpManifest};
 
-			// Resolve the virtual symbols to their actual values
+			if (tmpStepResultObject.ExpressionStep.LeftValue.Type === 'Token.LastResult')
+			{
+				tmpStepResultObject.ExpressionStep.LeftValue.Value = tmpResults.LastResult;
+			}
+			if (tmpStepResultObject.ExpressionStep.RightValue.Type === 'Token.LastResult')
+			{
+				tmpStepResultObject.ExpressionStep.RightValue.Value = tmpResults.LastResult;
+			}
+
 			if (tmpStepResultObject.ExpressionStep.LeftValue.Type === 'Token.VirtualSymbol')
 			{
 				tmpStepResultObject.ExpressionStep.LeftValue.Value = tmpManifest.getValueAtAddress(tmpResults.VirtualSymbols, tmpStepResultObject.ExpressionStep.LeftValue.Token);
@@ -94,9 +101,10 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 
 				try
 				{
-					this.log.trace(`Solving Step ${i} [${tmpStepResultObject.ExpressionStep.VirtualSymbolName}] --> [${tmpStepResultObject.ExpressionStep.Operation.Token}]: ( ${tmpStepResultObject.ExpressionStep.LeftValue.Value} , ${tmpStepResultObject.ExpressionStep.RightValue.Value} )`);
-					tmpResults.VirtualSymbols[tmpStepResultObject.ExpressionStep.VirtualSymbolName] = tmpManifest.getValueAtAddress(tmpStepResultObject, `${tmpFunctionAddress}(ExpressionStep.LeftValue.Value,ExpressionStep.RightValue.Value)`);
-					this.log.trace(`   ---> Step ${i}: ${tmpResults.VirtualSymbols[tmpStepResultObject.ExpressionStep.VirtualSymbolName]}`)
+					//this.log.trace(`Solving Step ${i} [${tmpStepResultObject.ExpressionStep.VirtualSymbolName}] --> [${tmpStepResultObject.ExpressionStep.Operation.Token}]: ( ${tmpStepResultObject.ExpressionStep.LeftValue.Value} , ${tmpStepResultObject.ExpressionStep.RightValue.Value} )`);
+					tmpManifest.setValueAtAddress(tmpResults.VirtualSymbols, tmpStepResultObject.ExpressionStep.VirtualSymbolName, tmpManifest.getValueAtAddress(tmpStepResultObject, `${tmpFunctionAddress}(ExpressionStep.LeftValue.Value,ExpressionStep.RightValue.Value)`));
+					tmpResults.LastResult = tmpManifest.getValueAtAddress(tmpResults.VirtualSymbols, tmpStepResultObject.ExpressionStep.VirtualSymbolName);
+					//this.log.trace(`   ---> Step ${i}: ${tmpResults.VirtualSymbols[tmpStepResultObject.ExpressionStep.VirtualSymbolName]}`)
 				}
 				catch (pError)
 				{
@@ -112,17 +120,18 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 
 		let tmpSolverResultValue = tmpManifest.getValueAtAddress(tmpResults, `VirtualSymbols.${tmpResults.SolverFinalVirtualSymbol}`);
 
-		// Now deal with final assignment
+		// Now deal with final assignment(s)
 		for (let i = 0; i < pPostfixedExpression.length; i++)
 		{
-			if ((pPostfixedExpression[i].Operation.Type === 'Token.SolverInstruction') && (pPostfixedExpression[i].Operation.Token == 'Assign'))
+			if (pPostfixedExpression[i].RightValue.Type === 'Token.SolverMarshal')
 			{
 				tmpManifest.setValueAtAddress(tmpResults.VirtualSymbols, pPostfixedExpression[i].VirtualSymbolName, tmpSolverResultValue);
 				tmpManifest.setValueByHash(tmpDataDestinationObject, pPostfixedExpression[i].VirtualSymbolName, tmpSolverResultValue);
 			}
-
 		}
-		// Clean up the reference if we added it to the object.
+		tmpResults.RawResult = tmpSolverResultValue;
+
+		// Clean up the fable reference if we added it to the object.
 		if (!tmpPassedInFable)
 		{
 			delete tmpResults.fable;

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-ValueMarshal.js

@@ -0,0 +1,146 @@
+const libExpressionParserOperationBase = require('./Fable-Service-ExpressionParser-Base.js');
+
+class ExpressionParserValueMarshal extends libExpressionParserOperationBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+		this.serviceType = 'ExpressionParser-ValueMarshal';
+	}
+
+	/**
+	 * Substitutes values in tokenized objects based on the provided data source and manifest.
+	 * 
+	 * TODO: Move this to its own file in the "Fable-Service-ExpressionParser" directory.
+	 *
+	 * @param {Array} pTokenizedObjects - The array of tokenized objects.
+	 * @param {Object} pDataSource - The data source object where we pull values from.
+	 * @param {Object} pResultObject - The result object where the algorithm shows its work.
+	 * @param {Object} pManifest - The manifest object to use for hash resolution.
+	 * @returns {Array} - The modified tokenized objects array.
+	 */
+	substituteValuesInTokenizedObjects(pTokenizedObjects, pDataSource, pResultObject, pManifest)
+	{
+		let tmpResults = (typeof(pResultObject) === 'object') ? pResultObject : { ExpressionParserLog: [] };
+
+		if (!Array.isArray(pTokenizedObjects))
+		{
+			tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.substituteValuesInTokenizedObjects was passed a non-array tokenized object list.`);
+			this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+			return pTokenizedObjects;
+		}
+		if (typeof(pDataSource) !== 'object')
+		{
+			tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.substituteValuesInTokenizedObjects either was passed no data source, or was passed a non-object data source.`);
+			this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+			return pTokenizedObjects;
+		}
+
+		let tmpDataSource = pDataSource;
+
+		let tmpManifest = (typeof(pManifest) == 'object') ? pManifest : this.fable.newManyfest(pManifest);
+
+		for (let i = 0; i < pTokenizedObjects.length; i++)
+		{
+			if (typeof(pTokenizedObjects[i]) !== 'object')
+			{
+				tmpResults.ExpressionParserLog.push(`WARNING: ExpressionParser.substituteValuesInTokenizedObjects found a non-object tokenized object at index ${i}`);
+				this.log.warn(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+				continue;
+			}
+			let tmpToken = pTokenizedObjects[i];
+			if ((pTokenizedObjects[i].Type === 'Token.Symbol') && !tmpToken.Resolved)
+			{
+				// Symbols always look up values by hash first
+				let tmpValue = tmpManifest.getValueByHash(tmpDataSource, tmpToken.Token);
+				// if (!tmpValue)
+				// {
+				// 	// If no hash resolves, try by address.
+				// 	tmpValue = tmpManifest.getValueAtAddress(tmpToken.Token, tmpDataSource);
+				// }
+				if (!tmpValue)
+				{
+					tmpResults.ExpressionParserLog.push(`WARNING: ExpressionParser.substituteValuesInTokenizedObjects found no value for the symbol hash or address ${tmpToken.Token} at index ${i}`);
+					this.log.warn(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+					continue;
+				}
+				else
+				{
+					tmpResults.ExpressionParserLog.push(`INFO: ExpressionParser.substituteValuesInTokenizedObjects found a value [${tmpValue}] for the state address ${tmpToken.Token} at index ${i}`);
+					if (this.LogNoisiness > 1) this.log.info(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+					try
+					{
+						let tmpValueParsed = new this.fable.Utility.bigNumber(tmpValue);
+						tmpToken.Resolved = true;
+						tmpToken.Value = tmpValueParsed.toString();
+					}
+					catch(pError)
+					{
+						// TODO: Should we allow this to be a function?  Good god the complexity and beauty of that...
+						if (Array.isArray(tmpValue) || (typeof(tmpValue) === 'object'))
+						{
+							tmpToken.Resolved = true;
+							tmpToken.Value = tmpValue;
+						}
+						else
+						{
+							tmpResults.ExpressionParserLog.push(`INFO: ExpressionParser.substituteValuesInTokenizedObjects found a non-numeric, non-set value for the state address ${tmpToken.Token} at index ${i}`);
+							this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+							tmpToken.Resolved = false;
+						}
+					}
+				}
+			}
+			if ((pTokenizedObjects[i].Type === 'Token.StateAddress') && !tmpToken.Resolved)
+			{
+				// Symbols are always hashes.  This gracefully works for simple shallow objects because hashes default to the address in Manyfest.
+				let tmpValue = tmpManifest.getValueAtAddress(tmpDataSource, tmpToken.Token);
+				if (!tmpValue)
+				{
+					tmpResults.ExpressionParserLog.push(`WARNING: ExpressionParser.substituteValuesInTokenizedObjects found no value for the state address ${tmpToken.Token} at index ${i}`);
+					this.log.warn(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+					continue;
+				}
+				else
+				{
+					//tmpResults.ExpressionParserLog.push(`INFO: ExpressionParser.substituteValuesInTokenizedObjects found a value [${tmpValue}] for the state address ${tmpToken.Token} at index ${i}`);
+					this.log.info(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+					try
+					{
+						let tmpValueParsed = new this.fable.Utility.bigNumber(tmpValue);
+						tmpToken.Resolved = true;
+						tmpToken.Value = tmpValueParsed.toString();
+					}
+					catch(pError)
+					{
+						tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.substituteValuesInTokenizedObjects found a non-numeric value for the state address ${tmpToken.Token} at index ${i}`);
+						this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+						tmpToken.Resolved = false;
+					}
+				}
+			}
+			if ((pTokenizedObjects[i].Type === 'Token.Constant') && !tmpToken.Resolved)
+			{
+				tmpResults.ExpressionParserLog.push(`INFO: ExpressionParser.substituteValuesInTokenizedObjects found a value [${tmpToken.Token}] for the constant ${tmpToken.Token} at index ${i}`);
+				if (this.LogNoisiness > 1) this.log.info(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+				try
+				{
+					let tmpValueParsed = new this.fable.Utility.bigNumber(tmpToken.Token);
+					tmpToken.Resolved = true;
+					tmpToken.Value = tmpValueParsed.toString();
+				}
+				catch(pError)
+				{
+					// This constant has the right symbols but apparently isn't a parsable number.
+					tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.substituteValuesInTokenizedObjects found a non-numeric value for the state address ${tmpToken.Token} at index ${i}`);
+					this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+					tmpToken.Resolved = false;
+				}
+			}
+		}
+
+		return pTokenizedObjects;
+	}
+}
+
+module.exports = ExpressionParserValueMarshal;