//////////////////////////////////////////////
public static PainContext CreateContext(
this PainProgram Program,
IDictionary <String, Object> Values = null,
IDictionary <String, Object> StaticValues = null,
Boolean BreakEveryLine = false,
Boolean CopyParameters = false)
{
if (Values == null)
{
Values = new Dictionary <String, Object>();
}
foreach (PainMethod painMethod in Program.Methods)
{
Values[painMethod.Name] = painMethod;
}
foreach (PainClass painClass in Program.Classes)
{
Values[painClass.Name] = painClass;
}
return(CreateContext(
Program.Lines,
Values,
StaticValues,
BreakEveryLine,
CopyParameters));
}
////////////////////////////////////////////////////////////////////
public static PainObject Exec(
this PainProgram Program,
IDictionary <String, Object> Parameters = null,
IDictionary <String, Object> StaticValues = null)
{
using (PainContext context = CreateContext(Program, Parameters, StaticValues, false))
{
return(Exec(context));
}
}
public static Object EvalStep(
this PainProgram Program,
IDictionary <String, Object> Parameters = null,
IDictionary <String, Object> StaticValues = null)
{
using (PainContext context = CreateContext(Program, Parameters, StaticValues, true))
{
return(Eval(context));
}
}
public static Boolean EvaluateMethod(
Object Object,
Object MethodObject,
IList <Object> Parameters,
PainContext PainContext)
{
if (MethodObject is PainMethod)
{
if (Parameters == null)
{
Parameters = new Object[0];
}
PainMethod method = (PainMethod)MethodObject;
PainContextType contextType = PainContextType.METHOD;
// jesli tworzenie klasy (wolanie konstruktora)
if (MethodObject is PainClass)
{
contextType = PainContextType.CLASS;
}
PainState newContext = PainContext.
PushContext(method, contextType, Parameters);
newContext.Object.ParentObject = method.ParentObject;
return(true);
}
else if (MethodObject is PainProgram)
{
PainProgram program = (PainProgram)MethodObject;
IDictionary <String, Object> currentValues = (PainContext == null || PainContext.CurrentState == null || PainContext.CurrentState.Object == null ?
null :
PainContext.
CurrentState.
Object.
DynamicValues);
IDictionary <String, Object> currentStaticValues = (PainContext == null || PainContext.CurrentState == null || PainContext.CurrentState.Object == null ?
null :
PainContext.
CurrentState.
Object.
StaticValues);
PainState newState = PainContext.PushContext(
program,
PainContextType.METHOD,
null);
if (currentValues != null)
{
foreach (String key in currentValues.Keys)
{
newState.Object.DynamicValues[key] = currentValues[key];
}
}
newState.Object.StaticValues = currentStaticValues;
return(true);
}
else
{
ExpressionMethodResult methodResult = EvaluateInlineMethod(
Object,
MethodObject,
Parameters,
PainContext);
if (methodResult != null &&
methodResult.NewContextCreated)
{
return(true);
}
else
{
var v = methodResult == null ? null : methodResult.Value;
PainContext.CurrentExpressionState.PushValue(v);
return(false);
}
}
}
public PainProgram Compile(IList <Char> Code)
{
CodeLines lines = GetLines(Code);
PainProgram mainProgram = new PainProgram();
List <PainProgram> methodStack = new List <PainProgram>();
methodStack.Push(mainProgram);
foreach (CodeLine line in lines)
{
Int32 currentDepth = -1;
PainMethod method = null;
method = GetMethodDefinition(line);
if (method != null)
{
currentDepth = method.Depth;
}
PainClass classDefinition = null;
if (method == null)
{
classDefinition = GetClassDefinition(line);
if (classDefinition != null)
{
currentDepth = classDefinition.Depth;
}
}
PainCodeLine codeLine = null;
if (method == null && classDefinition == null)
{
codeLine = GetCodeLine(line);
if (codeLine != null)
{
currentDepth = codeLine.Depth;
}
}
PainProgram currentMethod = methodStack.Peek();
if (codeLine == null || !codeLine.IsLineEmpty)
{
while (currentDepth < currentMethod.Depth ||
(currentDepth == currentMethod.Depth && classDefinition != null && classDefinition != currentMethod) ||
(currentDepth == currentMethod.Depth && method != null && method != currentMethod))
{
methodStack.Pop();
currentMethod = methodStack.Peek();
}
}
if (method != null)
{
currentMethod.Methods.Remove_by_Name(method.Name);
currentMethod.Methods.Add(method);
methodStack.Push(method);
continue;
}
if (classDefinition != null)
{
currentMethod.Classes.Remove_by_Name(classDefinition.Name);
currentMethod.Classes.Add(classDefinition);
methodStack.Push(classDefinition);
continue;
}
if (codeLine != null)
{
if (codeLine.IsLineEmpty == false)
{
currentMethod.Lines.Add(codeLine);
}
}
}
return(mainProgram);
}
