public SpokeType Get(string variableName, SpokeVariable mv)
{
var def = Variables[variableName];
if (def != null && mv != null)
mv.VariableIndex = indeces[variableName];
return def;
}
public int Add(string s, SpokeType spokeType, SpokeVariable sv)
{
allVariables.Add(new Tuple<string, int, SpokeType>(s, index, spokeType));
Variables.Add(s, spokeType);
indeces.Add(s, index++);
if (sv != null)
{
sv.VariableIndex = indeces[s];
}
return index - 1;
}
public void Reset(string variableName, SpokeType spokeType, SpokeVariable sv)
{
if (Variables.ContainsKey(variableName))
{
Variables[variableName] = spokeType;
if (sv != null)
{
sv.VariableIndex = indeces[variableName];
}
}
}
public SpokeType this[string s, SpokeVariable mv]
{
get { return Get(s, mv); }
}
public bool TryGetValue(string s, out SpokeType spokeType, SpokeVariable sv)
{
var def = Variables.TryGetValue(s, out spokeType);
if (def && sv != null)
sv.VariableIndex = indeces[s];
return def;
}
public int Set(string s, SpokeType spokeType, SpokeVariable sv)
{
if (sv != null)
{
sv.VariableIndex = indeces[s];
}
return indeces[s];
}
public Spoke eval(TokenEnumerator enumerator, int tabIndex, evalInformation inf)
{
if (inf.ResetCurrentVal)
{
CurrentItem = null;
}
#if DEBUGs
sb.AppendLine("Starting Eval " + enumerator.Current.Type);
#endif
if (inf.CheckMacs < 2)
{
var df = CurrentItem;
CurrentItem = null;
var rm = checkRunMacro(enumerator, tabIndex, inf);
if (rm != null)
{
CurrentItem = rm;
}
else CurrentItem = df;
}
switch (enumerator.Current.Type)
{
case Token.Word:
if (((TokenWord)enumerator.Current).Word.ToLower() == "null")
{
CurrentItem = new SpokeNull();
}
else CurrentItem = new SpokeVariable() { Parent = CurrentItem, VariableName = ((TokenWord)enumerator.Current).Word };
enumerator.MoveNext();
break;
case Token.Int:
CurrentItem = new SpokeInt() { Value = ((TokenInt)enumerator.Current)._value };
enumerator.MoveNext();
break;
case Token.Float:
CurrentItem = new SpokeFloat() { Value = ((TokenFloat)enumerator.Current)._value };
enumerator.MoveNext();
break;
case Token.String:
CurrentItem = new SpokeString() { Value = ((TokenString)enumerator.Current)._value };
enumerator.MoveNext();
break;
case Token.False:
CurrentItem = new SpokeBool() { Value = false };
enumerator.MoveNext();
break;
case Token.True:
CurrentItem = new SpokeBool() { Value = true };
enumerator.MoveNext();
break;
case Token.OpenParen:
enumerator.MoveNext();
CurrentItem = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf));
if (enumerator.Current.Type == Token.Tab)
{
enumerator.MoveNext();
}
if (enumerator.Current.Type != Token.CloseParen)
{
throw new AbandonedMutexException();
}
enumerator.MoveNext();
break;
case Token.Switch:
return (SpokeLine)evaluateSwitch(enumerator, tabIndex, inf);
case Token.If:
enumerator.MoveNext();
var i_f = new SpokeIf() { Condition = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf)) };
enumerator.MoveNext();
i_f.IfLines = getLines(enumerator, tabIndex + 1, new evalInformation(inf)).ToArray();
StaticMethods.Assert(enumerator.Current.Type == Token.NewLine || enumerator.Current.Type == Token.EndOfCodez, enumerator.Current.Type + " Isnt Newline");
enumerator.MoveNext();
if (enumerator.Current.Type == Token.Tab && enumerator.PeakNext().Type == Token.Else)
{
enumerator.MoveNext();
enumerator.MoveNext();
i_f.ElseLines = getLines(enumerator, tabIndex + 1, new evalInformation(inf)).ToArray();
StaticMethods.Assert(enumerator.Current.Type == Token.NewLine || enumerator.Current.Type == Token.EndOfCodez, enumerator.Current.Type + " Isnt Newline");
enumerator.MoveNext();
}
if (enumerator.Current.Type == Token.Tab && inf.EatTab)
enumerator.MoveNext();
return i_f;
break;
case Token.Bar:
var an = new SpokeAnonMethod() { Parent = CurrentItem };
enumerator.MoveNext();
StaticMethods.Assert(enumerator.Current.Type == Token.OpenParen, enumerator.Current.Type + " Isnt OpenParen");
List<ParamEter> parameters_ = new List<ParamEter>();
enumerator.MoveNext();
if (enumerator.Current.Type != Token.CloseParen)
{
pback2:
bool byRe_f = false;
if (((TokenWord)enumerator.Current).Word.ToLower() == "ref")
{
byRe_f = true;
enumerator.MoveNext();
}
parameters_.Add(new ParamEter() { ByRef = byRe_f, Name = ((TokenWord)enumerator.Current).Word });
enumerator.MoveNext();
switch (enumerator.Current.Type)
{
case Token.CloseParen:
enumerator.MoveNext();
break;
case Token.Comma:
enumerator.MoveNext();
goto pback2;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
an.Parameters = parameters_.ToArray();
StaticMethods.Assert(enumerator.Current.Type == Token.AnonMethodStart, enumerator.Current.Type + " Isnt anonmethodstart");
enumerator.MoveNext();
StaticMethods.Assert(enumerator.Current.Type == Token.NewLine, enumerator.Current.Type + " Isnt Newline");
enumerator.MoveNext();
an.Lines = getLines(enumerator, tabIndex + 1, new evalInformation(inf)).ToArray();
StaticMethods.Assert(enumerator.Current.Type == Token.NewLine || enumerator.Current.Type == Token.EndOfCodez, enumerator.Current.Type + " Isnt Newline");
enumerator.MoveNext();
an.HasYield = linesHave(an.Lines, ISpokeLine.Yield);
an.HasReturn = linesHave(an.Lines, ISpokeLine.Return);
an.HasYieldReturn = linesHave(an.Lines, ISpokeLine.YieldReturn);
StaticMethods.Assert(enumerator.Current.Type == Token.Tab && ((TokenTab)enumerator.Current).TabIndex == tabIndex, "Bad tabindex");
if (enumerator.Current.Type == Token.Tab && inf.EatTab)
enumerator.MoveNext();
if (enumerator.PeakNext().Type != Token.CloseParen)
{
return an;
}
else
{
enumerator.MoveNext();
CurrentItem = an;
}
break;
case Token.OpenSquare:
CurrentItem = dyanmicArray(enumerator, tabIndex, inf);
break;
case Token.OpenCurly:
CurrentItem = new SpokeConstruct();
CurrentItem = dynamicObject(enumerator, tabIndex, inf);
break;
case Token.Create:
return createObject(enumerator, tabIndex, inf);
break;
case Token.Return:
enumerator.MoveNext();
var r = new SpokeReturn() { Return = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf)) };
enumerator.MoveNext();
return r;
case Token.Yield:
enumerator.MoveNext();
if (enumerator.Current.Type == Token.Return)
{
enumerator.MoveNext();
var y = new SpokeYieldReturn() { YieldReturn = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf)) };
enumerator.MoveNext();
return y;
}
else
{
var y = new SpokeYield() { Yield = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf)) };
enumerator.MoveNext();
return y;
}
}
#if DEBUGs
sb.AppendLine("Checking Eval 1" + enumerator.Current.Type);
#endif
switch (enumerator.Current.Type)
{
case Token.OpenSquare:
var ar = new SpokeArrayIndex();
ar.Parent = CurrentItem;
enumerator.MoveNext();
ar.Index = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = false, ResetCurrentVal = true });
StaticMethods.Assert(enumerator.Current.Type == Token.CloseSquare, enumerator.Current.Type + " Isnt closesquare");
enumerator.MoveNext();
if (enumerator.Current.Type == Token.OpenSquare)
{
}
CurrentItem = ar;
break;
case Token.OpenParen:
var meth = new SpokeMethodCall() { Parent = CurrentItem };
enumerator.MoveNext();
List<SpokeItem> param_ = new List<SpokeItem>();
param_.Add(new SpokeCurrent());
CurrentItem = null;
if (enumerator.Current.Type != Token.CloseParen)
{
g:
param_.Add((SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { ResetCurrentVal = true }));
if (enumerator.Current.Type == Token.Comma)
{
enumerator.MoveNext();
goto g;
}
}
enumerator.MoveNext();//closeparen
meth.Parameters = param_.ToArray();
CurrentItem = meth;
//loop params
break;
case Token.Period:
var t = CurrentItem;
enumerator.MoveNext();
SpokeParent g;
Spoke c;
CurrentItem = g = (SpokeParent)(c = eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEvaler = true }));
//g.Parent = t;
//enumerator.MoveNext();
break;
}
switch (enumerator.Current.Type)
{
case Token.Period:
var t = CurrentItem;
enumerator.MoveNext();
SpokeParent g;
Spoke c;
CurrentItem = g = (SpokeParent)(c = eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEvaler = true }));
//g.Parent = t;
//enumerator.MoveNext();
break;
}
#if DEBUGs
sb.AppendLine("Checking Eval 2" + enumerator.Current.Type);
#endif
forMethods:
switch (enumerator.Current.Type)
{
case Token.OpenParen:
var meth = new SpokeMethodCall() { Parent = CurrentItem };
enumerator.MoveNext();
List<SpokeItem> param_ = new List<SpokeItem>();
param_.Add(new SpokeCurrent());
g:
param_.Add((SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { ResetCurrentVal = true }));
if (enumerator.Current.Type == Token.Comma)
{
enumerator.MoveNext();
goto g;
}
enumerator.MoveNext();//closeparen
meth.Parameters = param_.ToArray();
CurrentItem = meth;
goto forMethods;
}
#if DEBUGs
sb.AppendLine("Checking Eval 3" + enumerator.Current.Type);
#endif
if (inf.BreakBeforeEvaler)
{
return CurrentItem;
}
if (!inf.DontEvalEquals)
{
if (enumerator.Current.Type == Token.Equal)
{
var equ = new SpokeEqual() { LeftSide = CurrentItem };
enumerator.MoveNext();
equ.RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { EatTab = false, ResetCurrentVal = true });
if (enumerator.Current.Type == Token.NewLine)
{
// enumerator.MoveNext(); //newline
}
return equ;
}
}
switch (enumerator.Current.Type)
{
case Token.AnonMethodStart:
//checkparams
//getlines
var an = new SpokeAnonMethod() { Parent = CurrentItem };
enumerator.MoveNext();
if (enumerator.Current.Type == Token.Bar)
{
enumerator.MoveNext();
StaticMethods.Assert(enumerator.Current.Type == Token.OpenParen, enumerator.Current.Type + " Isnt openparen");
List<ParamEter> parameters_ = new List<ParamEter>();
enumerator.MoveNext();
pback2:
bool byRe_f = false;
if (((TokenWord)enumerator.Current).Word.ToLower() == "ref")
{
byRe_f = true;
enumerator.MoveNext();
}
parameters_.Add(new ParamEter() { ByRef = byRe_f, Name = ((TokenWord)enumerator.Current).Word });
enumerator.MoveNext();
switch (enumerator.Current.Type)
{
case Token.CloseParen:
enumerator.MoveNext();
break;
case Token.Comma:
enumerator.MoveNext();
goto pback2;
break;
default:
throw new ArgumentOutOfRangeException();
}
an.Parameters = parameters_.ToArray();
}
else
{
an.RunOnVar = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { ResetCurrentVal = true, BreakBeforeEqual = false, BreakBeforeEvaler = true });
}
StaticMethods.Assert(enumerator.Current.Type == Token.NewLine, enumerator.Current.Type + " Isnt Newline");
enumerator.MoveNext();
CurrentItem = null;
an.Lines = getLines(enumerator, tabIndex + 1, new evalInformation(inf)).ToArray();
an.HasYield = linesHave(an.Lines, ISpokeLine.Yield);
an.HasReturn = linesHave(an.Lines, ISpokeLine.Return);
an.HasYieldReturn = linesHave(an.Lines, ISpokeLine.YieldReturn);
StaticMethods.Assert(enumerator.Current.Type == Token.NewLine || enumerator.Current.Type == Token.EndOfCodez, enumerator.Current.Type + " Isnt Newline");
enumerator.MoveNext();
if (enumerator.Current.Type == Token.Tab && inf.EatTab)
enumerator.MoveNext();
CurrentItem = an;
break;
}
// 5*6-7+8/9+10
switch (enumerator.Current.Type)
{
case Token.Plus:
enumerator.MoveNext();
CurrentItem = new SpokeAddition() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
break;
case Token.Minus:
enumerator.MoveNext();
CurrentItem = new SpokeSubtraction() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
break;
case Token.Divide:
enumerator.MoveNext();
CurrentItem = new SpokeDivision() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
break;
case Token.Mulitply:
enumerator.MoveNext();
CurrentItem = new SpokeMultiplication() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
break;
}
if (inf.BreakBeforeEqual)
{
return CurrentItem;
}
switch (enumerator.Current.Type)
{
case Token.DoubleOr:
enumerator.MoveNext();
CurrentItem = new SpokeOr() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { ResetCurrentVal = true }) };
break;
case Token.DoubleAnd:
enumerator.MoveNext();
CurrentItem = new SpokeAnd() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { ResetCurrentVal = true }) };
break;
}
#if DEBUGs
sb.AppendLine("Checking Eval 4" + enumerator.Current.Type);
#endif
SpokeItem e;
switch (enumerator.Current.Type)
{
case Token.DoubleEqual:
enumerator.MoveNext();
e = new SpokeEquality() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
CurrentItem = e;
break;
case Token.NotEqual:
enumerator.MoveNext();
e = new SpokeNotEqual() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
CurrentItem = e;
break;
case Token.Less:
enumerator.MoveNext();
if (enumerator.Current.Type == Token.Equal)
{
enumerator.MoveNext();
e = new SpokeLessThanOrEqual() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
CurrentItem = e;
break;
}
e = new SpokeLessThan() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
CurrentItem = e;
break;
case Token.Greater:
enumerator.MoveNext();
if (enumerator.Current.Type == Token.Equal)
{
enumerator.MoveNext();
e = new SpokeGreaterThanOrEqual() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
CurrentItem = e;
break;
}
e = new SpokeGreaterThan() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { BreakBeforeEqual = true, ResetCurrentVal = true }) };
CurrentItem = e;
break;
}
switch (enumerator.Current.Type)
{
case Token.DoubleOr:
enumerator.MoveNext();
CurrentItem = new SpokeOr() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { ResetCurrentVal = true }) };
break;
case Token.DoubleAnd:
enumerator.MoveNext();
CurrentItem = new SpokeAnd() { LeftSide = CurrentItem, RightSide = (SpokeItem)eval(enumerator, tabIndex, new evalInformation(inf) { ResetCurrentVal = true }) };
break;
}
return CurrentItem;
}
private SpokeType evaluateItem(SpokeItem condition, SpokeMethodParse currentObject, SpokeVariableInfo variables, bool parentIsNull = false)
{
SpokeVariable fyv = null;
SpokeType r;
SpokeType l;
switch (condition.IType)
{
case ISpokeItem.Current:
new SpokeInstruction(SpokeInstructionType.GetLocal, 0);
return currentObject.RunningClass;
break;
case ISpokeItem.Null:
new SpokeInstruction(SpokeInstructionType.Null);
return new SpokeType(ObjectType.Null);
break;
case ISpokeItem.String:
new SpokeInstruction(SpokeInstructionType.StringConstant, ((SpokeString)condition).Value);
return new SpokeType(ObjectType.String);
break;
case ISpokeItem.Bool:
new SpokeInstruction(SpokeInstructionType.BoolConstant, ((SpokeBool)condition).Value);
return new SpokeType(ObjectType.Bool);
break;
case ISpokeItem.Float:
new SpokeInstruction(SpokeInstructionType.FloatConstant, ((SpokeFloat)condition).Value);
return new SpokeType(ObjectType.Float);
break;
case ISpokeItem.Int:
new SpokeInstruction(SpokeInstructionType.IntConstant, ((SpokeInt)condition).Value);
return new SpokeType(ObjectType.Int);
break;
case ISpokeItem.Array:
var ar = new SpokeType(ObjectType.Array);
new SpokeInstruction(SpokeInstructionType.CreateArray);
foreach (var spokeItem in ((SpokeArray)condition).Parameters)
{
var grb = evaluateItem(spokeItem, currentObject, variables);
if (grb.Type == ObjectType.Array)
{
if (ar.ArrayItemType.CompareTo(grb.ArrayItemType, true))
{
if (ar.ArrayItemType.Type == ObjectType.Unset)
{
ar.ArrayItemType = grb.ArrayItemType;
}
}
else throw new AbandonedMutexException("bad array");
new SpokeInstruction(SpokeInstructionType.AddRangeToArray);
}
else
{
if (ar.ArrayItemType.CompareTo(grb, true))
{
if (ar.ArrayItemType.Type == ObjectType.Unset)
{
ar.ArrayItemType = grb;
}
}
else throw new AbandonedMutexException("bad array");
new SpokeInstruction(SpokeInstructionType.AddToArray);
}
}
return ar;
break;
case ISpokeItem.Variable:
SpokeType g;
SpokeVariable mv = ((SpokeVariable)condition);
if (mv.Parent != null)
{
var fs = forSet;
forSet = false;
var ca = evaluateItem(mv.Parent, currentObject, variables);
if (ca.Variables.TryGetValue(mv.VariableName, out g, mv))
{
if (fs && !g.ByRef)
{
mv.ForSet = true;
ca.Variables.Reset(mv.VariableName, g = new SpokeType(ObjectType.Unset), mv);
}
new SpokeInstruction(SpokeInstructionType.GetField, mv.VariableIndex) { DEBUG = mv.VariableName };
return g;
}
mv.VariableIndex = ca.Variables.Add(mv.VariableName, g = new SpokeType(ObjectType.Unset), mv);
new SpokeInstruction(SpokeInstructionType.GetField, mv.VariableIndex) { DEBUG = mv.VariableName };
return g;
}
if (mv.VariableName == "this")
{
new SpokeInstruction(SpokeInstructionType.GetLocal, 0) { DEBUG = "this" };
return currentObject.RunningClass;
}
if (currentObject.RunningClass.Variables.TryGetValue(mv.VariableName, out g, mv))
{
mv.This = true;
new SpokeInstruction(SpokeInstructionType.GetLocal, 0) { DEBUG = "this" };
if (forSet && g.ByRef == false)
{
forSet = false;
var ddd = currentObject.RunningClass.Variables.Get(mv.VariableName, mv);
mv.ForSet = true;
currentObject.RunningClass.Variables.Reset(mv.VariableName, g = new SpokeType(ddd), mv);
}
new SpokeInstruction(SpokeInstructionType.GetField, mv.VariableIndex) { DEBUG = mv.VariableName };
return g;
}
if (variables.TryGetValue(mv.VariableName, out g, mv))
{
if (forSet && g.ByRef == false)
{
forSet = false;
mv.ForSet = true;
variables.Reset(mv.VariableName, g = new SpokeType(ObjectType.Unset), mv);
}
new SpokeInstruction(SpokeInstructionType.GetLocal, mv.VariableIndex) { DEBUG = mv.VariableName };
return g;
}
if (forSet)
{
forSet = false;
mv.ForSet = true;
}
((SpokeVariable)condition).VariableIndex = variables.Add(((SpokeVariable)condition).VariableName,
g = new SpokeType(ObjectType.Unset), mv);
new SpokeInstruction(SpokeInstructionType.GetLocal, mv.VariableIndex) { DEBUG = mv.VariableName };
return g;
break;
case ISpokeItem.ArrayIndex:
var fs_ = forSet;
forSet = false;
var pa = evaluateItem(((SpokeArrayIndex)condition).Parent, currentObject, variables);
var ind = evaluateItem(((SpokeArrayIndex)condition).Index, currentObject, variables);
if (ind.ArrayItemType != null && ind.ArrayItemType.Type == ObjectType.Int)
{
/* var orig = new array();
var d = new array();
var dexes = new array();
int ind = 0;
while(true) {
if (ind < orig.length)
{
d.add(dexes[ind]);
}
else break;
}
*/
int dexes;
int orig;
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, dexes = variables.Add("_dexes" + condition.Guid, new SpokeType(ObjectType.Array) { ClassName = "Array", ArrayItemType = new SpokeType(ObjectType.Int) }, null));
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, orig = variables.Add("_orig" + condition.Guid, pa, null));
int arg;
new SpokeInstruction(SpokeInstructionType.CreateArray);
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, arg = variables.Add("_rev" + condition.Guid, pa, null));
int loc;
new SpokeInstruction(SpokeInstructionType.IntConstant, 0);
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, loc = variables.Add("__ind" + condition.Guid, new SpokeType(ObjectType.Int), null)) { DEBUG = "__ind" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.Label, "_topOfForeachback_" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.GetLocal, loc);
new SpokeInstruction(SpokeInstructionType.GetLocal, dexes);
new SpokeInstruction(SpokeInstructionType.CallMethodFunc, Methods.Select(a => a.Value).ToList().IndexOf(Methods.Select(a => a.Value).ToList().First(a => a.Class.Name == "Array" && a.MethodName == "length")), 0, 1) { DEBUG = "length" };
new SpokeInstruction(SpokeInstructionType.LessIntInt);
var ifTrdue = new SpokeInstruction(SpokeInstructionType.IfTrueContinueElse, "EndLoop" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.GetLocal, arg);
new SpokeInstruction(SpokeInstructionType.GetLocal, orig);
new SpokeInstruction(SpokeInstructionType.GetLocal, dexes);
new SpokeInstruction(SpokeInstructionType.GetLocal, loc);
new SpokeInstruction(SpokeInstructionType.ArrayElem);
new SpokeInstruction(SpokeInstructionType.ArrayElem);
new SpokeInstruction(SpokeInstructionType.CallMethodFunc, Methods.Select(a => a.Value).ToList().IndexOf(Methods.Select(a => a.Value).ToList().First(a => a.Class.Name == "Array" && a.MethodName == "add")), 0, 2) { DEBUG = "add" };
new SpokeInstruction(SpokeInstructionType.PopStack);
new SpokeInstruction(SpokeInstructionType.GetLocal, loc) { DEBUG = "__ind" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.IntConstant, 1);
new SpokeInstruction(SpokeInstructionType.AddIntInt);
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, loc) { DEBUG = "__ind" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.Goto, "_topOfForeachback_" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.Label, "EndLoop" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.GetLocal, arg);
// throw new AbandonedMutexException("ADSd");
if (fs_ && pa.ByRef == false)
{
throw new AbandonedMutexException("wat");
}
return pa;
}
else if (ind.Type != ObjectType.Int)
{
throw new AbandonedMutexException();
}
//new SpokeInstruction(SpokeInstructionType.FloatConstant, ((SpokeFloat)condition).Value);
new SpokeInstruction(SpokeInstructionType.ArrayElem);
if (fs_ && pa.ByRef == false)
{
((SpokeArrayIndex)condition).ForSet = true;
pa.ArrayItemType = new SpokeType(pa.ArrayItemType);
return pa.ArrayItemType;
}
if (pa.ByRef == true)
{
throw new AbandonedMutexException();
}
return pa.ArrayItemType;
break;
case ISpokeItem.AnonMethod:
if (((SpokeAnonMethod)condition).Parent != null)
{
SpokeMethodParse df = null;
if (((SpokeAnonMethod)condition).HasYield || ((SpokeAnonMethod)condition).HasYieldReturn)
{
var drf = new List<SpokeLine>(((SpokeAnonMethod)condition).Lines);
// drf.Insert(0, new SpokeEqual() { LeftSide = fyv = new SpokeVariable() { VariableName = "__" + condition.Guid }, RightSide = new SpokeArray() { Parameters = new SpokeItem[0] } });
fyv = new SpokeVariable() { VariableName = "__" + condition.Guid };
variables.Add("__" + condition.Guid, new SpokeType(ObjectType.Array) { ClassName = "Array" },
fyv);
// fyv.ForSet = true;
((SpokeAnonMethod)condition).ReturnYield = fyv;
new SpokeInstruction(SpokeInstructionType.CreateArray);
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, fyv.VariableIndex);
fuix(drf, fyv, false);
((SpokeAnonMethod)condition).Lines = drf.ToArray();
}
new SpokeInstruction(SpokeInstructionType.Label, "_topOfWhile_" + condition.Guid);
if (((SpokeAnonMethod)condition).RunOnVar == null)
{
df = new SpokeMethodParse() { RunningClass = currentObject.RunningClass };
if (((SpokeAnonMethod)condition).HasYield || ((SpokeAnonMethod)condition).HasYieldReturn)
{
df.ForYieldArray = new SpokeType(ObjectType.Unset);
}
}
if (((SpokeAnonMethod)condition).HasReturn)
{
df.ReturnType = new SpokeType(ObjectType.Unset);
}
var rl = evaluateItem(((SpokeAnonMethod)condition).Parent, currentObject, variables);
if (rl.Type == ObjectType.Array)
{
if (((SpokeAnonMethod)condition).RunOnVar != null)
{
var dmei = SpokeInstruction.ins;
df = new SpokeMethodParse()
{
RunningClass =
evaluateItem(((SpokeAnonMethod)condition).RunOnVar,
currentObject, variables)
};
if (df.RunningClass.AnonMethod.HasYield || df.RunningClass.AnonMethod.HasYieldReturn)
{
df.ForYieldArray = new SpokeType(ObjectType.Unset);
}
SpokeInstruction.ins = dmei;
if (((SpokeAnonMethod)condition).HasReturn)
{
df.ReturnType = new SpokeType(ObjectType.Unset);
}
for (int i = 0; i < df.RunningClass.AnonMethod.Parameters.Count(); i++)
{
df.RunningClass.AnonMethod.Parameters[i].Index =
variables.Add(df.RunningClass.AnonMethod.Parameters[i].Name, rl.ArrayItemType,
null);
if (df.RunningClass.AnonMethod.Parameters[i].ByRef)
{
throw new Exception("idk");
// spokeObject.ByRef = true;
}
}
anonMethodsEntered.Add("_anons1_" + condition.Guid, false);
foreach (var spokeLine in df.RunningClass.AnonMethod.Lines)
{
resetGuids(spokeLine);
}
var rme = evaluateLines(ref df.RunningClass.AnonMethod.Lines, df, variables);
new SpokeInstruction(SpokeInstructionType.Label, anonMethodsEntered.Last().Key);
if (anonMethodsEntered.Last().Key != "_anons1_" + condition.Guid)
{
throw new AbandonedMutexException("");
}
anonMethodsEntered.Remove(anonMethodsEntered.Last().Key);
if (rme != null)
if (df.RunningClass.AnonMethod.HasReturn)
{
for (int i = 0; i < df.RunningClass.AnonMethod.Parameters.Count(); i++)
{
variables.Remove(df.RunningClass.AnonMethod.Parameters[i].Name);
}
return rme;
}
if (df.RunningClass.AnonMethod.HasYield || df.RunningClass.AnonMethod.HasYieldReturn)
{
}
for (int i = 0; i < df.RunningClass.AnonMethod.Parameters.Count(); i++)
{
var c = df.RunningClass.AnonMethod.Parameters[i].Name;
variables[c, null].ByRef = false;
variables.Remove(c);
}
return new SpokeType(ObjectType.Array) { ClassName = "Array", ArrayItemType = df.ForYieldArray };
}
else
{
int loc;
int arr;
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, arr = variables.Add("__arr" + condition.Guid, rl, null)) { DEBUG = "__arr" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.IntConstant, 0);
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, loc = variables.Add("__ind" + condition.Guid, new SpokeType(ObjectType.Int), null)) { DEBUG = "__ind" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.Label, "_topOfForeach_" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.GetLocal, loc) { DEBUG = "__ind" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.GetLocal, arr) { DEBUG = "__arr" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.CallMethodFunc, Methods.Select(a => a.Value).ToList().IndexOf(Methods.Select(a => a.Value).ToList().First(a => a.Class.Name == "Array" && a.MethodName == "length")), 0, 1) { DEBUG = "length" };
new SpokeInstruction(SpokeInstructionType.LessIntInt);
var ifTrdue = new SpokeInstruction(SpokeInstructionType.IfTrueContinueElse, "EndLoop" + condition.Guid);
if (((SpokeAnonMethod)condition).Parameters != null)
{
((SpokeAnonMethod)condition).Parameters[0].Index = variables.Add(((SpokeAnonMethod)condition).Parameters[0].Name, rl.ArrayItemType, null);
new SpokeInstruction(SpokeInstructionType.GetLocal, arr) { DEBUG = "__arr" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.GetLocal, loc) { DEBUG = "__ind" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.ArrayElem);
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, ((SpokeAnonMethod)condition).Parameters[0].Index) { DEBUG = ((SpokeAnonMethod)condition).Parameters[0].Name };
if (((SpokeAnonMethod)condition).Parameters.Length == 2)
{
((SpokeAnonMethod)condition).Parameters[1].Index = variables.Add(((SpokeAnonMethod)condition).Parameters[1].Name, new SpokeType(ObjectType.Int), null);
new SpokeInstruction(SpokeInstructionType.GetLocal, loc) { DEBUG = "__ind" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, ((SpokeAnonMethod)condition).Parameters[1].Index) { DEBUG = ((SpokeAnonMethod)condition).Parameters[1].Name };
}
}
anonMethodsEntered.Add("_anons2_" + condition.Guid, false);
var rme = evaluateLines(ref ((SpokeAnonMethod)condition).@lines, df, variables);
new SpokeInstruction(SpokeInstructionType.Label, anonMethodsEntered.Last().Key);
if (anonMethodsEntered.Last().Key != "_anons2_" + condition.Guid)
{
}
anonMethodsEntered.Remove(anonMethodsEntered.Last().Key);
new SpokeInstruction(SpokeInstructionType.GetLocal, loc) { DEBUG = "__ind" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.IntConstant, 1);
new SpokeInstruction(SpokeInstructionType.AddIntInt);
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, loc) { DEBUG = "__ind" + condition.Guid };
new SpokeInstruction(SpokeInstructionType.Goto, "_topOfForeach_" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.Label, "EndLoop" + condition.Guid);
//yield return
if (rme != null)
if (((SpokeAnonMethod)condition).HasReturn)
{
if (((SpokeAnonMethod)condition).Parameters != null)
{
variables.Remove(((SpokeAnonMethod)condition).Parameters[0].Name);
if (((SpokeAnonMethod)condition).Parameters.Length == 2)
variables.Remove(((SpokeAnonMethod)condition).Parameters[1].Name);
}
if (df.ReturnType.CompareTo(rme, false))
{
if (rme.Type == ObjectType.Unset)
{
df.ReturnType = rme;
}
}
else
{
df.ForYieldArray = rme;
}
}
if (((SpokeAnonMethod)condition).Parameters != null)
{
variables.Remove(((SpokeAnonMethod)condition).Parameters[0].Name);
if (((SpokeAnonMethod)condition).Parameters.Length == 2)
variables.Remove(((SpokeAnonMethod)condition).Parameters[1].Name);
}
if (((SpokeAnonMethod)condition).HasYield ||
((SpokeAnonMethod)condition).HasYieldReturn)
{
var drf = new List<SpokeLine>(((SpokeAnonMethod)condition).Lines);
fuix(drf, fyv, true);
((SpokeAnonMethod)condition).Lines = drf.ToArray();
new SpokeInstruction(SpokeInstructionType.GetLocal, fyv.VariableIndex) { DEBUG = fyv.VariableName };
return new SpokeType(ObjectType.Array) { ClassName = "Array", ArrayItemType = df.ForYieldArray };
}
else if (((SpokeAnonMethod)condition).HasReturn)
{
return df.ReturnType;
}
}
}
else if (rl.Type == ObjectType.Bool)
{
var ifTrdue = new SpokeInstruction(SpokeInstructionType.IfTrueContinueElse, "EndLoop" + condition.Guid) { DEBUG = "while loop" };
anonMethodsEntered.Add("_anons3_" + condition.Guid, false);
var def = evaluateLines(ref ((SpokeAnonMethod)condition).@lines, df, variables);
new SpokeInstruction(SpokeInstructionType.Label, anonMethodsEntered.Last().Key);
if (anonMethodsEntered.Last().Key != "_anons3_" + condition.Guid)
{
}
anonMethodsEntered.Remove(anonMethodsEntered.Last().Key);
new SpokeInstruction(SpokeInstructionType.Goto, "_topOfWhile_" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.Label, "EndLoop" + condition.Guid);
if (def != null)
{
if (((SpokeAnonMethod)condition).HasReturn)
{
if (df.ReturnType.CompareTo(def, false))
{
if (def.Type == ObjectType.Unset)
{
currentObject.ReturnType = def;
}
}
else
{
df.ReturnType = def;
}
return df.ReturnType;
}
}
if (((SpokeAnonMethod)condition).HasYield || ((SpokeAnonMethod)condition).HasYieldReturn)
{
var drf = new List<SpokeLine>(((SpokeAnonMethod)condition).Lines);
fuix(drf, fyv, true);
((SpokeAnonMethod)condition).Lines = drf.ToArray();
new SpokeInstruction(SpokeInstructionType.GetLocal, fyv.VariableIndex) { DEBUG = fyv.VariableName };
//new SpokeInstruction(SpokeInstructionType.Return);
return new SpokeType(ObjectType.Array) { ClassName = "Array", ArrayItemType = df.ForYieldArray };
}
}
}
else
{
if (((SpokeAnonMethod)condition).HasYield || ((SpokeAnonMethod)condition).HasYieldReturn)
{
var drf = new List<SpokeLine>(((SpokeAnonMethod)condition).Lines);
//drf.Insert(0, new SpokeEqual() { LeftSide = fyv = new SpokeVariable() { VariableName = "__" + condition.Guid }, RightSide = new SpokeArray() { Parameters = new SpokeItem[0] } });
fyv = new SpokeVariable() { VariableName = "__" + condition.Guid };
variables.Add("__" + condition.Guid, new SpokeType(ObjectType.Array) { ClassName = "Array" },
fyv);
// fyv.ForSet = true;
((SpokeAnonMethod)condition).ReturnYield = fyv;
fuix(drf, fyv, false);
fuix(drf, fyv, true);
((SpokeAnonMethod)condition).Lines = drf.ToArray();
}
SpokeObjectMethod ce;
new SpokeInstruction(SpokeInstructionType.CreateMethod, ce = new SpokeObjectMethod()
{
Lines = ((SpokeAnonMethod)condition).Lines,
Parameters = ((SpokeAnonMethod)condition).Parameters,
HasReturn = ((SpokeAnonMethod)condition).HasReturn,
HasYield = ((SpokeAnonMethod)condition).HasYield,
HasYieldReturn = ((SpokeAnonMethod)condition).HasYieldReturn
});
return new SpokeType(ObjectType.Method)
{
Type = ObjectType.Method,
Variables = new SpokeVariableInfo(),
ClassName = currentObject.RunningClass.ClassName,
AnonMethod = ce
};
}
break;
case ISpokeItem.MethodCall:
var gf = ((SpokeMethodCall)condition);
if (gf.Parent is SpokeAnonMethod)
{
gf.Parent = new SpokeAnonMethod()
{
HasReturn = ((SpokeAnonMethod)gf.Parent).HasReturn,
HasYield = ((SpokeAnonMethod)gf.Parent).HasYield,
HasYieldReturn = ((SpokeAnonMethod)gf.Parent).HasYieldReturn,
Lines = ((SpokeLine[])((SpokeAnonMethod)gf.Parent).Lines.Clone()),
Parameters = ((ParamEter[])((SpokeAnonMethod)gf.Parent).Parameters.Clone()),
Parent = ((SpokeAnonMethod)gf.Parent).Parent,
RunOnVar = ((SpokeAnonMethod)gf.Parent).RunOnVar
};
for (int index = 1; index < gf.Parameters.Length; index++)
{
var spokeItem = gf.Parameters[index];
SpokeType eh;
var dims = new List<SpokeInstruction>(SpokeInstruction.ins);
((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index =
variables.Add(((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name,
eh = evaluateItem(spokeItem, currentObject, variables), null);
eh.ByRef = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].ByRef;
if (eh.ByRef)
{
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index) { DEBUG = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name };
}
else
switch (eh.Type)
{
case ObjectType.Null:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index) { DEBUG = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name };
break;
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index) { DEBUG = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name };
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.StoreLocalFloat, ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index) { DEBUG = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name };
break;
case ObjectType.String:
new SpokeInstruction(SpokeInstructionType.StoreLocalString, ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index) { DEBUG = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name };
break;
case ObjectType.Bool:
new SpokeInstruction(SpokeInstructionType.StoreLocalBool, ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index) { DEBUG = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name };
break;
case ObjectType.Array:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index) { DEBUG = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name };
break;
case ObjectType.Object:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index) { DEBUG = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name };
break;
case ObjectType.Method:
new SpokeInstruction(SpokeInstructionType.StoreLocalMethod, ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Index) { DEBUG = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name };
break;
case ObjectType.Void:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var df = new SpokeMethodParse() { RunningClass = currentObject.RunningClass };
SpokeType oldRF = null;
if (((SpokeAnonMethod)gf.Parent).HasYieldReturn || ((SpokeAnonMethod)gf.Parent).HasYield)
{
df.ForYieldArray = new SpokeType(ObjectType.Unset);
fyv = new SpokeVariable() { VariableName = "__" + condition.Guid };
variables.Add("__" + condition.Guid, new SpokeType(ObjectType.Array) { ClassName = "Array" },
fyv);
// fyv.ForSet = true;
((SpokeAnonMethod)condition).ReturnYield = fyv;
new SpokeInstruction(SpokeInstructionType.CreateArray) { DEBUG = "array for loop" };
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, fyv.VariableIndex) { DEBUG = fyv.VariableName };
}
else if (((SpokeAnonMethod)gf.Parent).HasReturn)
{
oldRF = df.ReturnType;
df.ReturnType = new SpokeType(ObjectType.Unset);
}
anonMethodsEntered.Add("_anonMethod_" + gf.Parent.Guid, true);
variables.IncreaseState();
var fd = evaluateLines(ref ((SpokeAnonMethod)gf.Parent).@lines, df, variables);
variables.DecreaseState();
new SpokeInstruction(SpokeInstructionType.Label, anonMethodsEntered.Last().Key);
if (anonMethodsEntered.Last().Key != "_anonMethod_" + gf.Parent.Guid)
{
}
anonMethodsEntered.Remove(anonMethodsEntered.Last().Key);
if (((SpokeAnonMethod)gf.Parent).SpecAnon && parentIsNull)
{
df.ReturnType = oldRF;
}
if (((SpokeAnonMethod)gf.Parent).HasYieldReturn || ((SpokeAnonMethod)gf.Parent).HasYield)
{
new SpokeInstruction(SpokeInstructionType.GetLocal, fyv.VariableIndex) { DEBUG = fyv.VariableName };
fd = new SpokeType(ObjectType.Array) { ArrayItemType = fd, ClassName = "Array" };
}
else
if (((SpokeAnonMethod)gf.Parent).HasReturn)
{
var fe = "_ret_" + ((SpokeAnonMethod)gf.Parent).Guid;
int de = variables.Add(fe, df.ReturnType, null);
switch (df.ReturnType.Type)
{
case ObjectType.Null:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, de) { DEBUG = fe };
break;
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, de) { DEBUG = fe };
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.StoreLocalFloat, de) { DEBUG = fe };
break;
case ObjectType.String:
new SpokeInstruction(SpokeInstructionType.StoreLocalString, de) { DEBUG = fe };
break;
case ObjectType.Bool:
new SpokeInstruction(SpokeInstructionType.StoreLocalBool, de) { DEBUG = fe };
break;
case ObjectType.Array:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, de) { DEBUG = fe };
break;
case ObjectType.Object:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, de) { DEBUG = fe };
break;
case ObjectType.Method:
new SpokeInstruction(SpokeInstructionType.StoreLocalMethod, de) { DEBUG = fe };
break;
case ObjectType.Void:
break;
default:
throw new ArgumentOutOfRangeException();
}
new SpokeInstruction(SpokeInstructionType.GetLocal, de) { DEBUG = fe };
}
for (int index = 1; index < gf.Parameters.Length; index++)
{
var m = ((SpokeAnonMethod)gf.Parent).Parameters[index - 1].Name;
variables[m, null].ByRef = false;
variables.Remove(m);
}
return fd;
}
else
{
var d = ((SpokeVariable)gf.Parent);
if (d.Parent == null)
{
SpokeMethod meth;
var parms = new SpokeType[gf.Parameters.Length];
if (Methods.TryGetValue(currentObject.RunningClass.ClassName + d.VariableName, out meth))
{
d.VariableIndex = Methods.Select(a => a.Value).ToList().IndexOf(meth);
for (int i = 0; i < parms.Length; i++)
{
parms[i] = evaluateItem(gf.Parameters[i], currentObject, variables);
}
var ii = new SpokeInstruction(SpokeInstructionType.CallMethod, d.VariableIndex) { DEBUG = d.VariableName };
d.VType = SpokeVType.MethodName;
var demf = evaluateMethod(meth, currentObject.RunningClass, parms);
ii.Index2 = meth.NumOfVars;
ii.Index3 = meth.Parameters.Length;
return demf;
}
else
{
if (currentObject.RunningClass.Variables.TryGetValue(d.VariableName, out g, d) &&
g.Type == ObjectType.Method)
{
for (int i = 0; i < g.AnonMethod.Parameters.Count(); i++)
{
var dims = new List<SpokeInstruction>(SpokeInstruction.ins);
SpokeType eh;
g.AnonMethod.Parameters[i].Index = variables.Add(
g.AnonMethod.Parameters[i].Name,
eh = evaluateItem(gf.Parameters[i + 1], currentObject, variables), null);
eh.ByRef = g.AnonMethod.Parameters[i].ByRef;
if (eh.ByRef)
{
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
}
else
switch (eh.Type)
{
case ObjectType.Null:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.StoreLocalFloat, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.String:
new SpokeInstruction(SpokeInstructionType.StoreLocalString, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Bool:
new SpokeInstruction(SpokeInstructionType.StoreLocalBool, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Array:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Object:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Method:
new SpokeInstruction(SpokeInstructionType.StoreLocalMethod, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Void:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var df = new SpokeMethodParse() { RunningClass = currentObject.RunningClass };
if (g.AnonMethod.HasYieldReturn || g.AnonMethod.HasYield)
{
df.ForYieldArray = new SpokeType(ObjectType.Unset);
}
else if (g.AnonMethod.HasReturn)
{
df.ReturnType = new SpokeType(ObjectType.Unset);
}
var ii = new SpokeInstruction(SpokeInstructionType.CallMethod, d.VariableIndex) { DEBUG = d.VariableName };
throw new AbandonedMutexException("ASD");
var rme = evaluateLines(ref g.AnonMethod.Lines, df, variables);
//gay if its an actual method not anon
ii.Index3 = g.AnonMethod.Parameters.Length;
for (int i = 0; i < g.AnonMethod.Parameters.Count(); i++)
{
var m = g.AnonMethod.Parameters[i].Name;
variables[m, null].ByRef = false;
variables.Remove(m);
}
d.VType = SpokeVType.ThisV;
return rme;
}
if (variables.TryGetValue(d.VariableName, out g, d) && g.Type == ObjectType.Method)
{
d.VType = SpokeVType.V;
for (int i = 0; i < g.AnonMethod.Parameters.Count(); i++)
{
SpokeType eh;
var dims = new List<SpokeInstruction>(SpokeInstruction.ins);
g.AnonMethod.Parameters[i].Index = variables.Add(
g.AnonMethod.Parameters[i].Name,
eh = evaluateItem(gf.Parameters[i + 1], currentObject, variables), null);
eh.ByRef = g.AnonMethod.Parameters[i].ByRef;
if (eh.ByRef)
{
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
}
else
switch (eh.Type)
{
case ObjectType.Null:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.StoreLocalFloat, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.String:
new SpokeInstruction(SpokeInstructionType.StoreLocalString, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Bool:
new SpokeInstruction(SpokeInstructionType.StoreLocalBool, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Array:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Object:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Method:
new SpokeInstruction(SpokeInstructionType.StoreLocalMethod, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Void:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var df = new SpokeMethodParse() { RunningClass = currentObject.RunningClass };
if (g.AnonMethod.HasYieldReturn || g.AnonMethod.HasYield)
{
df.ForYieldArray = new SpokeType(ObjectType.Unset);
}
else if (g.AnonMethod.HasReturn)
{
df.ReturnType = new SpokeType(ObjectType.Unset);
}
// new SpokeInstruction(SpokeInstructionType.CallMethod, d.VariableIndex, 0, g.AnonMethod.Parameters.Length);
// throw new AbandonedMutexException("ASD");
anonMethodsEntered.Add("__anonVar__" + condition.Guid, true);
foreach (var spokeLine in g.AnonMethod.Lines)
{
resetGuids(spokeLine);
}
var rme = evaluateLines(ref g.AnonMethod.Lines, df, variables);
new SpokeInstruction(SpokeInstructionType.Label, anonMethodsEntered.Last().Key);
if (anonMethodsEntered.Last().Key != "__anonVar__" + condition.Guid)
{
}
anonMethodsEntered.Remove(anonMethodsEntered.Last().Key);
for (int i = 0; i < g.AnonMethod.Parameters.Count(); i++)
{
var m = g.AnonMethod.Parameters[i].Name;
variables[m, null].ByRef = false;
variables.Remove(m);
}
if (g.AnonMethod.HasYieldReturn || g.AnonMethod.HasYield)
{
// new SpokeInstruction(SpokeInstructionType.Return);
}
else if (g.AnonMethod.HasReturn)
{
// new SpokeInstruction(SpokeInstructionType.Return);
}
return rme;
}
d.VType = SpokeVType.InternalMethodName;
d.VariableIndex =
InternalMethodsTypes.Select(a => a.Value).ToList().IndexOf(
InternalMethodsTypes[d.VariableName]);
for (int i = 0; i < parms.Length; i++)
{
parms[i] = evaluateItem(gf.Parameters[i], currentObject, variables);
}
new SpokeInstruction(SpokeInstructionType.CallInternal, d.VariableIndex, 0, parms.Length) { DEBUG = d.VariableName };
// return new SpokeType(ObjectType.Void);
return InternalMethodsTypes[d.VariableName];
}
}
else
{
var pp = evaluateItem(d.Parent, currentObject, variables);
if (pp == null)
{
Console.WriteLine("A");
}
var fm = Methods.First(a => a.Value.MethodName == d.VariableName && a.Value.Class.Name == pp.ClassName).Value;
if (Methods.Any(a => a.Value.MethodName == d.VariableName && a.Value.Class.Name == pp.ClassName))
{
d.VariableIndex = Methods.Select(a => a.Value).ToList().IndexOf(fm);
if (fm.MethodFunc != null)
{
var gm = new SpokeType[gf.Parameters.Length];
gm[0] = pp;
for (int index = 1; index < gf.Parameters.Length; index++)
{
gm[index] = evaluateItem(gf.Parameters[index], currentObject, variables);
}
if (fm.Class.Name == "Array" && fm.MethodName == "add")
{
pp.ArrayItemType = gm[1];
}
new SpokeInstruction(SpokeInstructionType.CallMethodFunc, d.VariableIndex, 0, gf.Parameters.Length) { DEBUG = d.VariableName };
//hmmm
if (fm.returnType.Type == ObjectType.Null)
{
return pp.ArrayItemType;
}
else return fm.returnType;
return fm.returnType;
// return new SpokeType(ObjectType.Void);
}
else
{
var parms = new SpokeType[gf.Parameters.Length];
parms[0] = pp;
//0 is evaluated up top
for (int i = 1; i < parms.Length; i++)
{
parms[i] = evaluateItem(gf.Parameters[i], currentObject, variables);
}
var deds = evaluateMethod(fm, pp, parms);
new SpokeInstruction(SpokeInstructionType.CallMethod, d.VariableIndex, fm.NumOfVars, parms.Length) { DEBUG = d.VariableName };
return deds;
}
}
if (pp.Variables.TryGetValue(d.VariableName, out g, d) && g.Type == ObjectType.Method)
{
for (int i = 0; i < g.AnonMethod.Parameters.Count(); i++)
{
var dims = new List<SpokeInstruction>(SpokeInstruction.ins);
SpokeType eh;
g.AnonMethod.Parameters[i].Index = variables.Add(g.AnonMethod.Parameters[i].Name, eh = evaluateItem(gf.Parameters[i + 1], currentObject, variables), null);
eh.ByRef = g.AnonMethod.Parameters[i].ByRef;
if (eh.ByRef)
{
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
}
else
switch (eh.Type)
{
case ObjectType.Null:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.StoreLocalInt, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.StoreLocalFloat, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.String:
new SpokeInstruction(SpokeInstructionType.StoreLocalString, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Bool:
new SpokeInstruction(SpokeInstructionType.StoreLocalBool, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Array:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Object:
new SpokeInstruction(SpokeInstructionType.StoreLocalObject, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Method:
new SpokeInstruction(SpokeInstructionType.StoreLocalMethod, g.AnonMethod.Parameters[i].Index) { DEBUG = g.AnonMethod.Parameters[i].Name };
break;
case ObjectType.Void:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var df = new SpokeMethodParse() { RunningClass = pp };
if (g.AnonMethod.HasYieldReturn || g.AnonMethod.HasYield)
{
df.ForYieldArray = new SpokeType(ObjectType.Unset);
}
else if (g.AnonMethod.HasReturn)
{
df.ReturnType = new SpokeType(ObjectType.Unset);
}
new SpokeInstruction(SpokeInstructionType.CallMethod, d.VariableIndex) { DEBUG = d.VariableName };
throw new AbandonedMutexException("ads");
anonMethodsEntered.Add("__anonVar__" + condition.Guid, true);
var rme = evaluateLines(ref g.AnonMethod.Lines, df, variables);
new SpokeInstruction(SpokeInstructionType.Label, anonMethodsEntered.Last().Key);
anonMethodsEntered.Remove(anonMethodsEntered.Last().Key);
for (int i = 0; i < g.AnonMethod.Parameters.Count(); i++)
{
var m = g.AnonMethod.Parameters[i].Name;
variables[m, null].ByRef = false;
variables.Remove(m);
}
return rme;
}
else
throw new AbandonedMutexException("no method: " + d.VariableName);
}
}
break;
case ISpokeItem.Construct:
var cons = new SpokeType(ObjectType.Object);
var rf = (SpokeConstruct)condition;
cons.Variables = new SpokeVariableInfo();
if (rf.ClassName != null)
{
cons.ClassName = rf.ClassName;
var drj = _cla.First(a => a.Name == rf.ClassName);
var fm =
Methods.First(
a =>
a.Value.MethodName == ".ctor" && a.Value.Class.Name == rf.ClassName &&
a.Value.Parameters.Length == rf.Parameters.Length + 1).Value;
if (fm.VariableRefs != null)
cons.Variables = fm.VariableRefs;
rf.MethodIndex = Methods.Select(a => a.Value).ToList().IndexOf(fm);
new SpokeInstruction(SpokeInstructionType.CreateReference, drj.Variables.Length, cons.ClassName) { DEBUG = rf.ClassName };
if (fm.VariableRefs == null)
{
foreach (var v in drj.Variables)
{
cons.Variables.Add(v, new SpokeType(ObjectType.Unset), null);
}
}
var parms = new SpokeType[rf.Parameters.Length + 1];
parms[0] = cons;
for (int i = 1; i < parms.Length; i++)
{
parms[i] = evaluateItem(rf.Parameters[i - 1], currentObject, variables);
}
new SpokeInstruction(SpokeInstructionType.CallMethod, rf.MethodIndex, fm.NumOfVars, parms.Length) { DEBUG = rf.ClassName + ".ctor" };
foreach (var spokeItem in rf.SetVars)
{
SpokeType st;
if (cons.Variables.TryGetValue(spokeItem.Name, out st, null))
{
spokeItem.Index = cons.Variables.Set(spokeItem.Name,
evaluateItem(spokeItem.Item, currentObject, variables),
null);
}
else
spokeItem.Index = cons.Variables.Add(spokeItem.Name,
evaluateItem(spokeItem.Item, currentObject, variables),
null);
new SpokeInstruction(SpokeInstructionType.StoreToReference, spokeItem.Index);
}
if (fm.Instructions == null)
{
evaluateMethod(fm, cons, parms);
var def = new List<SpokeInstruction>(fm.Instructions);
def.Add(new SpokeInstruction(SpokeInstructionType.GetLocal, 0));
def.Add(new SpokeInstruction(SpokeInstructionType.Return));
fm.Instructions = def.ToArray();
SpokeInstruction.ins.RemoveAt(SpokeInstruction.ins.Count - 1);
SpokeInstruction.ins.RemoveAt(SpokeInstruction.ins.Count - 1);
}
else
{
}
rf.NumOfVars = cons.Variables.index;
}
else
{
SpokeInstruction df = new SpokeInstruction(SpokeInstructionType.CreateReference, rf.SetVars.Length) { DEBUG = "{}" };
string name = "{";
foreach (var spokeItem in rf.SetVars)
{
name += spokeItem.Name + ",";
spokeItem.Index = cons.Variables.Add(spokeItem.Name,
evaluateItem(spokeItem.Item, currentObject, variables),
null);
new SpokeInstruction(SpokeInstructionType.StoreToReference, spokeItem.Index);
}
cons.ClassName = name.TrimEnd(',') + "}";
df.StringVal = cons.ClassName;
}
if (!variableLookup.ContainsKey(cons.ClassName))
{
variableLookup.Add(cons.ClassName, cons.Variables.allVariables.OrderBy(a => a.Item2).Select(a => a.Item1).ToArray());
}
return cons;
break;
case ISpokeItem.Addition:
l = evaluateItem(((SpokeAddition)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeAddition)condition).RightSide, currentObject, variables);
switch (l.Type)
{
case ObjectType.Int:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.AddIntInt);
return new SpokeType(l.Type);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.AddIntFloat);
return new SpokeType(r.Type);
break;
case ObjectType.String:
new SpokeInstruction(SpokeInstructionType.AddIntString);
return new SpokeType(r.Type);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ObjectType.Float:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.AddFloatInt);
return new SpokeType(l.Type);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.AddFloatFloat);
return new SpokeType(l.Type);
break;
case ObjectType.String:
new SpokeInstruction(SpokeInstructionType.AddFloatString);
return new SpokeType(r.Type);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ObjectType.String:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.AddStringInt);
return new SpokeType(l.Type);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.AddStringFloat);
return new SpokeType(l.Type);
break;
case ObjectType.String:
new SpokeInstruction(SpokeInstructionType.AddStringString);
return new SpokeType(l.Type);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ISpokeItem.Subtraction:
if (((SpokeSubtraction)condition).LeftSide == null) {
l = new SpokeType(ObjectType.Int);
new SpokeInstruction(SpokeInstructionType.IntConstant, 0);
}
else l = evaluateItem(((SpokeSubtraction)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeSubtraction)condition).RightSide, currentObject, variables);
switch (l.Type)
{
case ObjectType.Int:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.SubtractIntInt);
return new SpokeType(l.Type);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.SubtractIntFloat);
return new SpokeType(r.Type);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ObjectType.Float:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.SubtractFloatInt);
return new SpokeType(l.Type);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.SubtractFloatFloat);
return new SpokeType(l.Type);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ISpokeItem.Multiplication:
l = evaluateItem(((SpokeMultiplication)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeMultiplication)condition).RightSide, currentObject, variables);
switch (l.Type)
{
case ObjectType.Int:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.MultiplyIntInt);
return new SpokeType(l.Type);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.MultiplyIntFloat);
return new SpokeType(r.Type);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ObjectType.Float:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.MultiplyFloatInt);
return new SpokeType(l.Type);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.MultiplyFloatFloat);
return new SpokeType(l.Type);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ISpokeItem.Division:
l = evaluateItem(((SpokeDivision)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeDivision)condition).RightSide, currentObject, variables);
switch (l.Type)
{
case ObjectType.Int:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.DivideIntInt);
return new SpokeType(l.Type);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.DivideIntFloat);
return new SpokeType(l.Type);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ObjectType.Float:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.DivideFloatInt);
return new SpokeType(l.Type);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.DivideFloatFloat);
return new SpokeType(l.Type);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ISpokeItem.Greater:
l = evaluateItem(((SpokeGreaterThan)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeGreaterThan)condition).RightSide, currentObject, variables);
switch (l.Type)
{
case ObjectType.Int:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.GreaterIntInt);
return new SpokeType(ObjectType.Bool);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.GreaterIntFloat);
return new SpokeType(ObjectType.Bool);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ObjectType.Float:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.GreaterFloatInt);
return new SpokeType(ObjectType.Bool);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.GreaterFloatFloat);
return new SpokeType(ObjectType.Bool);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ISpokeItem.Less:
l = evaluateItem(((SpokeLessThan)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeLessThan)condition).RightSide, currentObject, variables);
switch (l.Type)
{
case ObjectType.Int:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.LessIntInt);
return new SpokeType(ObjectType.Bool);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.LessIntFloat);
return new SpokeType(ObjectType.Bool);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ObjectType.Float:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.LessFloatInt);
return new SpokeType(ObjectType.Bool);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.LessFloatFloat);
return new SpokeType(ObjectType.Bool);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ISpokeItem.And:
l = evaluateItem(((SpokeAnd)condition).LeftSide, currentObject, variables);
if (l.Type != ObjectType.Bool)
{
throw new AbandonedMutexException("Expected bool");
}
new SpokeInstruction(SpokeInstructionType.IfTrueContinueElse, "FakeShort" + condition.Guid);
r = evaluateItem(((SpokeAnd)condition).RightSide, currentObject, variables);
if (r.Type != ObjectType.Bool)
{
throw new AbandonedMutexException("Expected bool");
}
new SpokeInstruction(SpokeInstructionType.Goto, "EndShort" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.Label, "FakeShort" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.BoolConstant, false);
new SpokeInstruction(SpokeInstructionType.Label, "EndShort" + condition.Guid);
return new SpokeType(ObjectType.Bool);
break;
case ISpokeItem.Or:
new SpokeInstruction(SpokeInstructionType.Comment, "OR BEGIN");
l = evaluateItem(((SpokeOr)condition).LeftSide, currentObject, variables);
if (l.Type != ObjectType.Bool)
{
throw new AbandonedMutexException("Expected bool");
}
new SpokeInstruction(SpokeInstructionType.Not);
new SpokeInstruction(SpokeInstructionType.IfTrueContinueElse, "FakeShort" + condition.Guid);
r = evaluateItem(((SpokeOr)condition).RightSide, currentObject, variables);
if (r.Type != ObjectType.Bool)
{
throw new AbandonedMutexException("Expected bool");
}
new SpokeInstruction(SpokeInstructionType.Goto, "EndShort" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.Label, "FakeShort" + condition.Guid);
new SpokeInstruction(SpokeInstructionType.BoolConstant, true);
new SpokeInstruction(SpokeInstructionType.Label, "EndShort" + condition.Guid);
return new SpokeType(ObjectType.Bool);
break;
case ISpokeItem.GreaterEqual:
l = evaluateItem(((SpokeGreaterThanOrEqual)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeGreaterThanOrEqual)condition).RightSide, currentObject, variables);
switch (l.Type)
{
case ObjectType.Int:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.GreaterEqualIntInt);
return new SpokeType(ObjectType.Bool);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.GreaterEqualIntFloat);
return new SpokeType(ObjectType.Bool);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ObjectType.Float:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.GreaterEqualFloatInt);
return new SpokeType(ObjectType.Bool);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.GreaterEqualFloatFloat);
return new SpokeType(ObjectType.Bool);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ISpokeItem.LessEqual:
l = evaluateItem(((SpokeLessThanOrEqual)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeLessThanOrEqual)condition).RightSide, currentObject, variables);
switch (l.Type)
{
case ObjectType.Int:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.LessEqualIntInt);
return new SpokeType(ObjectType.Bool);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.LessEqualIntFloat);
return new SpokeType(ObjectType.Bool);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ObjectType.Float:
switch (r.Type)
{
case ObjectType.Int:
new SpokeInstruction(SpokeInstructionType.LessEqualFloatInt);
return new SpokeType(ObjectType.Bool);
break;
case ObjectType.Float:
new SpokeInstruction(SpokeInstructionType.LessEqualFloatFloat);
return new SpokeType(ObjectType.Bool);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
case ISpokeItem.Equality:
l = evaluateItem(((SpokeEquality)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeEquality)condition).RightSide, currentObject, variables);
if (!l.CompareTo(r, false))
{
throw new AbandonedMutexException(l.ToString() + " not equal to " + r.ToString());
}
new SpokeInstruction(SpokeInstructionType.Equal);
return new SpokeType(ObjectType.Bool);
break;
case ISpokeItem.NotEqual:
l = evaluateItem(((SpokeNotEqual)condition).LeftSide, currentObject, variables);
r = evaluateItem(((SpokeNotEqual)condition).RightSide, currentObject, variables);
if (!l.CompareTo(r, false))
{
throw new AbandonedMutexException(l.ToString() + " not equal to " + r.ToString());
}
new SpokeInstruction(SpokeInstructionType.Equal);
new SpokeInstruction(SpokeInstructionType.Not);
return new SpokeType(ObjectType.Bool);
default:
throw new ArgumentOutOfRangeException();
}
return null;
}
private void fuix(List<SpokeLine> lines, SpokeVariable vr, bool remove)
{
for (int index = lines.Count - 1; index >= 0; index--)
{
var e = lines[index];
if (e is SpokeYield)
{
if (remove)
{
// lines.Add(new SpokeReturn() { Return = vr });
lines.Remove(e);
}
else
lines.Insert(index, new SpokeMethodCall() { Parameters = new SpokeItem[] { new SpokeCurrent(), ((SpokeYield)e).Yield }, Parent = new SpokeVariable() { VariableName = "add", Parent = new SpokeVariable() { Parent = vr.Parent, VariableIndex = vr.VariableIndex, VariableName = vr.VariableName } } });
}
else if (e is SpokeYieldReturn)
{
if (remove)
{
// lines.Add(new SpokeReturn() { Return = vr });
lines.Remove(e);
}
else
lines.Insert(index, new SpokeMethodCall() { Parameters = new SpokeItem[] { new SpokeCurrent(), ((SpokeYieldReturn)e).YieldReturn }, Parent = new SpokeVariable() { VariableName = "add", Parent = new SpokeVariable() { Parent = vr.Parent, VariableIndex = vr.VariableIndex, VariableName = vr.VariableName } } });
}
if (e is SpokeLines && (!(e is SpokeAnonMethod)))
{
if (e is SpokeIf)
{
var df = new List<SpokeLine>(((SpokeIf)e).IfLines);
fuix(df, vr, remove);
((SpokeIf)e).IfLines = df.ToArray();
if (((SpokeIf)e).ElseLines != null)
{
df = new List<SpokeLine>(((SpokeIf)e).ElseLines);
fuix(df, vr, remove);
((SpokeIf)e).ElseLines = df.ToArray();
}
}
else
{
var df = new List<SpokeLine>(((SpokeLines)e).Lines);
fuix(df, vr, remove);
((SpokeLines)e).Lines = df.ToArray();
}
}
}
}
