 			var i:int;
 			var token:String;
 			var str:String;
+			var call:CompiledFunctionCall;
 			
 			// first step: compile quoted Strings and Numbers
 			for (i = 0; i < tokens.length; i++)

									localSymbolTable[result] = undefined;
							result = undefined;
						}
						else if (method == operators[FUNCTION]) // inline function definition
						{
							var _symbolTables:Array = [localSymbolTable].concat(symbolTable); // works whether symbolTable is an Array or Object
							if (useThisScope)

		 */
		private function compileOperator(operatorName:String, compiledParams:Array):CompiledFunctionCall
		{
			// special case for inline functions
			if (operatorName == FUNCTION || operatorName == '=>')
			{
				// compiledParams should have two parameters: argument list and function body
				var args:CompiledFunctionCall = compiledParams[0] as CompiledFunctionCall;
				var body:ICompiledObject = compiledParams[1] as ICompiledObject;
				if (compiledParams.length != 2 || !args || !body)
					throwInvalidSyntax(operatorName);
				
				// if there is only a single variable name, wrap it in an operator ',' call
				if (!args.compiledParams)
					args = compileOperator(',', [args]);
				
				if (args.evaluatedMethod != operators[','])
					throwInvalidSyntax(operatorName);
				
				// verify that each parameter inside operator ',' is a variable name or a local assignment to a constant.
				var variableNames:Array = [];
				var variableValues:Array = [];
				for each (var token:Object in args.compiledParams)
				{
					var variable:CompiledFunctionCall = token as CompiledFunctionCall;
					if (!variable)
						throwInvalidSyntax(operatorName);
					
					if (!variable.compiledParams)
					{
						// local variable
						variableNames.push(variable.evaluatedMethod);
						variableValues.push(undefined);
					}
					else if (variable.evaluatedMethod == operators['='] && variable.compiledParams.length == 2 && variable.compiledParams[1] is CompiledConstant)
					{
						// local variable assignment
						variableNames.push(variable.evaluatedParams[0]);
						variableValues.push(variable.evaluatedParams[1]);
					}
					else
						throwInvalidSyntax(operatorName);
				}
				var functionParams:Object = {};
				functionParams[FUNCTION_PARAM_NAMES] = variableNames;
				functionParams[FUNCTION_PARAM_VALUES] = variableValues;
				functionParams[FUNCTION_CODE] = finalize(body);
				
				compiledParams = [new CompiledConstant(null, functionParams)];
			}
			
			operatorName = OPERATOR_ESCAPE + operatorName;
			return new CompiledFunctionCall(new CompiledConstant(operatorName, constants[operatorName]), compiledParams);
		}
