protected ktValue HandleCompound(ktList Comp)
{
ktValue Value = ktValue.Null;
//ktDebug.WrapLevel++;
if (Comp == null)
{
return Value;
}
#if Debug
if (!ktDebug.Enabled) { ktDebug.D.Enable(); this.m_enabledDebug = true; this.m_enabledAt = ktDebug.WrapLevel; }
ktDebug.Log( "HCHCHCHCHCHCHCHCHHCHCHC:\n" + Comp.Get_R( ktDebug.GetPrefix(), true ) );
#endif
ktToken SToken= null;
ktToken First = null;
ktToken Last = null;
if ((Comp.Node != null) && (Comp.Node.Value != null))
{
SToken = (ktToken)(Comp.Node.Value);
}
if ((Comp.First != null) && (Comp.First.Node != null))
{
First = (ktToken)(Comp.First.Node.Value);
}
if ((Comp.Last != null) && (Comp.Last.Node != null))
{
Last = (ktToken)(Comp.Last.Node.Value);
}
if ((First == null) && (Last == null))
{
return Value;
}
ktDebug.Log("SEPV::" + First.Value + ";;" + Last.Value );
if ((SToken != null) && (SToken.Value == "§"))
{
#if Debug
ktDebug.Log("METHODCALL");
#endif
ktClass Class = null;
try
{
Value = GetObjectFor(First);
if (Value.IsNull())
{
throw new Exception();
}
Class = (ktClass)Value.Value;
}
catch (Exception)
{
#if Debug
ktDebug.Log("ID:" + Err.Message);
#endif
throw new ktError("Can't find the symbol '" + First.Value + "' on line " + First.LineNo.ToString() + " by character " + First.CharPos.ToString() + "!", ktERR._404);
}
First = (ktToken)Comp.First.Next.Node.Value;
Last = (ktToken)Comp.Last.First.Node.Value;
/*First = (ktToken)Comp.Last.First.Node.Value;
Last = (ktToken)Comp.Last.Last.Node.Value;*/
//ktDebug.Log(".." + First.Value + ";" + SToken.Value + "::\n" + Last.Value + "===----------====-===");
Value = Class.RunMethod(First.Value,GetArguments(Comp.Last.Last));
}
else if ((First.Type == ktTokenType.CompStatement) && (First.Value == "."))
{
#if Debug
ktDebug.Log( "SEP::" + Comp.First.Get_R( ktDebug.GetPrefix() ) );
#endif
Value = HandleCompound(Comp.First);
// ktDebug.Log("SLU:" + Value.ToString() + ";");
if (Value.Type == "ktFunction")
{
ktDebug.Log("WTF???");
if ((Value.Value.GetType() == typeof(ktFunction)) ||
(Value.Value.GetType() == typeof(ktDelegateFunction)))
{
ktDebug.Log("WTF!!!_" + Value.ToString() + "!|!" + Value.Value.GetType().ToString());
ktFunction Func = (ktFunction)Value.Value;
Value = Func.Run(GetArguments(Comp.Last));
}
else
{
ktDebug.Log("WTF???_" + Value.ToString() + "!|!" + Value.Value.GetType().ToString());
ktClass Class = (ktClass)Value.Value;
Value = Class.RunMethod("run", GetArguments(Comp.Last));
}
}
else
{
ktDebug.Log("HUM:" + Value.Type);
ktDebug.Log("HUM_T:" + Value.GetType() + ";" + Value.Value.GetType());
ktDebug.Log("HUM_T:" + Value.Value.GetStringType());
ktDebug.Log("Last:" + Comp.Last.Get_R(ktDebug.GetPrefix()));
ktDebug.Log("LastT:" + Last.Type);
if (Last.Type == ktTokenType.Id)
{
if (Value.Value.GetStringType() == "ktClass")
{
Value = ((ktClass)Value.Value).GetMember(Last.Value);
}
else
{
ktDebug.Log("__HUMMM??????????????");
}
}
}
/*if (Value.Type == "ktClass") {
ktClass Class = null;
try {;
if (Value.IsNull()) {
throw new Exception();
}
Class = (ktClass)Value.Value;
if (Last.Type == ktTokenType.Id) {
Value = Class.GetMember( Last.Value );
} else {
throw new ktError( "Unexpected '" + Last.ToString() + "' on line " + First.LineNo.ToString() + " by character " + First.CharPos.ToString() + "!", ktERR.UNEXP );
}
} catch (Exception Err) {
#if Debug
ktDebug.Log( Err.Message );
#endif
if (Err.GetType() == typeof( ktError )) {
throw Err;
}
throw new ktError( "Can't find the symmmmmmmmmmbol '" + First.Value + "' on line " + First.LineNo.ToString() + " by character " + First.CharPos.ToString() + "!", ktERR._404 );
}
}*/
}
else if ((First.Type == ktTokenType.CompStatement) && (First.Value == "::"))
{
ktClass Class = null;
ktDebug.Log("::::::::::::::::::::::::");
Value = HandleCompound(Comp.First);
if (Value.Type == "ktFunction")
{
if (Value.Value.GetType() == typeof(ktFunction))
{
ktDebug.Log("::WTF???_" + Value.ToString() + "!|!" + Value.Value.GetType().ToString());
ktFunction Func = (ktFunction)Value.Value;
Value = Func.Run(GetArguments(Comp.Last));
}
else
{
Class = (ktClass)Value.Value;
Value = Class.RunMethod("run", GetArguments(Comp.Last));
}
}
else ktDebug.Log("CHUM:" + Value.Type);
#if Debug
ktDebug.Log( "SEP.::::::::::." + Value.ToString() + "E;" + First.LineNo );
#endif
}
else if ((SToken != null) && (SToken.Value == "§"))
{
#if Debug
ktDebug.Log("METHODCALL");
#endif
ktClass Class = null;
try
{
Value = GetObjectFor(First);
if (Value.IsNull())
{
throw new Exception();
}
Class = (ktClass)Value.Value;
}
catch (Exception Err)
{
#if Debug
ktDebug.Log("ID:" + Err.Message);
#endif
throw new ktError("Can't find the symbol '" + First.Value + "' on line " + First.LineNo.ToString() + " by character " + First.CharPos.ToString() + "!", ktERR._404);
}
First = (ktToken)Comp.Last.First.Node.Value;
Last = (ktToken)Comp.Last.Last.Node.Value;
//ktDebug.Log(".." + First.Value + ";" + SToken.Value + "::\n" + Last.Value + "===----------====-===");
Value = Class.RunMethod(First.Value,GetArguments(Comp.Last.Last));
}
else if ((SToken != null) && (SToken.Value == "."))
{
ktClass Class = null;
try
{
Value = GetObjectFor(First);
ktDebug.Log("SLU!!!!!!!!!!");
if (Value.IsNull())
{
throw new Exception();
}
Class = (ktClass)Value.Value;
ktDebug.Log("SLU!!++++++!!");
// Class.GetM
}
catch (Exception Err)
{
#if Debug
ktDebug.Log( "ST.DOT.:" + Err.Message );
#endif
throw new ktError("Can't find the symbol '" + First.Value + "' on line " + First.LineNo.ToString() + " by character " + First.CharPos.ToString() + "!", ktERR._404);
} /*catch (NullReferenceException Err) {
#if Debug
ktDebug.Log( "ST.DOT.NULL:" + Err.Message );
#endif
throw new ktError( "Can't find the symbol '" + First.Value + "' on line " + First.LineNo.ToString() + " by character " + First.CharPos.ToString() + "!", ktERR._404 );
}*/
if (Class == null)
{
throw new ktError("A null value was found where an object instance was required, on line " + Last.LineNo.ToString() + " by character " + Last.CharPos.ToString() + "!", ktERR.NULL);
}
Value = Class.GetMember(Last.Value);
#if Debug
ktDebug.Log( "SEP......." + Value.ToString() + ";E:" + First.LineNo );
#endif
}
else if ((SToken != null) && (SToken.Value == "::"))
{
ktDebug.Log("CONFU::" + Last.Value + ";");
ktDebug.Log("SEPV::" + First.Value);
ktContext Con = kacTalk.Main.GetContext(First.Value);
ktDebug.Log("CON::" + ((Con == null) ? "NULL" : Con.Export()) + ";");
Value = Con.GetMember(Last.Value);
ktDebug.Log("CON_MEM::" + ((Value == null) ? "NULL" : Value.Export()) + ";");
}
else
{
// ktDebug.Log(".." + First.Value + ";" + SToken.Value + "::\n" + Comp.Node.Value + "===----------====-===");
if ((First.Type == ktTokenType.Id) && (Comp.GetCount() == 2))
{
#if Debug
ktDebug.Log("IDIDIDIDIDIDIDIDIDIDID");
#endif
ktClass Class = null;
try
{
Value = GetObjectFor(First);
if (Value.IsNull())
{
throw new Exception();
}
Class = (ktClass)Value.Value;
// Class.GetM
}
catch (Exception Err)
{
#if Debug
ktDebug.Log("ID:" + Err.Message);
#endif
throw new ktError("Can't find the symbol '" + First.Value + "' on line " + First.LineNo.ToString() + " by character " + First.CharPos.ToString() + "!", ktERR._404);
}
Value = Class.RunMethod("_func_call", GetArguments(Comp.Last));
/*
if (Comp.GetCount() == 2) {
Value = RunFunction( First.Value, GetArguments( Comp.Last ) );
}*/
}
}
#if Debug
ktDebug.Log( "- - - EO_HC - - -" );
if (this.m_enabledDebug && (this.m_enabledAt == ktDebug.WrapLevel)) { ktDebug.D.Disable(); }
#endif
// ktDebug.WrapLevel--;
return Value;
}
public ktValue RunMethod(ktString Name, ktList Arguments)
{
if (Name.IsEmpty())
{
throw new ktError("Didn't get the name of the method to run in class '" +
m_Name + "'.", ktERR.NOTSET);
}
ktDebug.Log("RunM Arg:" + Arguments.Get_R());
ktValue Value = ktValue.Null;
//ktDebug.Log( "ktClass::RM( " + Name + " );" );
try
{
Value = _RunMethod(Name, Arguments);
}
catch (Exception Err)
{
Value = (ktValue)Arguments.First.Node.Value;
if (Name == "Export")
{
return new ktValue("", "ktString", kacTalk.Main.MakeObjectOf("ktString", Export()), true, true);
}
else if (Name.AsLower() == "tostring")
{
return new ktValue("", "ktString", kacTalk.Main.MakeObjectOf("ktString", ToString()), true, true);
}
else if (Name.AsLower() == "operator~")
{
return new ktValue("", "ktString", kacTalk.Main.MakeObjectOf("ktString", ToString() + Value.ToString()), true, true);
}
else if (Name.AsLower().StartsWith("to", out Name))
{
}
throw Err;
}
return Value;
}
protected ktValue HandleCompAssignment(ktList Target, ktValue Value)
{
bool Constant = false, Hard = false;
ktString Name = new ktString(), ClassName = null;
ktToken Token = null;
ktClass Class = null;
#if Debug
ktDebug.Log( "HCAHCAHCAHCAHCAHCAHCAHCAHCAHCAHCAHCAHCAHCA" );
#endif
ktDebug.Log("HCA: V:" + Value.Export() + "\n" + Target.Get_R());
Target.Reset();
foreach (ktList L in Target)
{
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
Token = (ktToken)L.Node.Value;
#if Debug
ktDebug.Log( "HCA:" + Token.ToString() );
#endif
switch (Token.Type)
{
case ktTokenType.Const:
{
if (Constant)
{
throw new ktError("Unexpected " + Token.ToString() + " on line " +
Token.LineNo.ToString() + " by character " +
Token.CharPos.ToString() + "!",
ktERR.UNEXP);
}
Constant = true;
break;
}
case ktTokenType.Hard:
{
if (Hard)
{
throw new ktError("Unexpected " + Token.ToString() + " on line " +
Token.LineNo.ToString() + " by character " +
Token.CharPos.ToString() + "!",
ktERR.UNEXP);
}
Hard = true;
break;
}
case ktTokenType.Id:
{
if (!Name.IsEmpty())
{
try
{
Class = GetClass(Name);
ClassName = Name;
Hard = true;
} catch (Exception) {
throw new ktError("Unexpected " + Token.ToString() + " (" +
Token.Value + ") on line " +
Token.LineNo.ToString() + " by character " +
Token.CharPos.ToString() + "!",
ktERR.UNEXP);
}
}
Name = Token.Value;
break;
}
}
}
Value.Constant = Constant;
Value.HardType = Hard;
if (!Value.IsNull())
{
((ktClass)Value.Value).HardType = Hard;
((ktClass)Value.Value).IsConstant = Constant;
}
if (Class != null)
{
ktList Arg = new ktList();
ktClass Obj = Class.CreateObject();
Obj.HardType = Hard;
Obj.IsConstant = Constant;
if (!Value.IsNull())
{
Arg.Add(Value);
Obj.RunMethod("Assign", Arg);
}
Value = new ktValue(Name, ClassName, Obj, Hard, Constant);
}
SetVariable(Name, true, Value, true, true);
return Value;
}
public ktList GetArguments(ktList Arguments)
{
ktList Args = null;
ktToken Token = null;
#if Debug
ktDebug.Log( "GAGAGAGAGAGA:" + Arguments.Get_R( "\t", true ) );
#endif
if (Arguments == null)
{
return null;
}
else if ((Arguments.Node != null) && (Arguments.Node.Value != null) &&
((Token = (ktToken)(Arguments.Node.Value)).Type == ktTokenType.CompStatement))
{
Args = new ktList();
Args.Add(HandleCompound(Arguments).CopyValue());
return Args;
}
else if (((Arguments.First != null) && (Arguments.First.Node != null) &&
(Arguments.First.Node.Value != null) &&
((Token = (ktToken)(Arguments.First.Node.Value)).Type == ktTokenType.CompStatement)
) || ((Arguments.Node != null) && (Arguments.Node.Value != null) &&
((Token = (ktToken)(Arguments.Node.Value)).Type == ktTokenType.CompStatement)
)
)
{
#if Debug
ktDebug.Log( "GACSGACSGACSGACSGACSGACS:" + Arguments.Get_R() );
#endif
ktList Stat = new ktList();
Stat.Node = new ktNode("ktStatement", new ktToken(ktTokenType.Statement, "ktStatement",
Token.LineNo, Token.CharPos));
Args = new ktList();
Args.Node = new ktNode("ktList", new ktToken(ktTokenType.List, "ktList", Token.LineNo,
Token.CharPos));
Args.AddList(Stat);
Stat.AddList(Arguments);
return GetArguments(Args);
}
#if Debug
ktDebug.Log( "gQAGAGAGAGAGAGAGGAgA::::" + Arguments.Get_R( "\t", true ) );
#endif
if (Arguments.GetCount() == 0)
{
if (Arguments.Node == null)
{
return null;
}
Token = (ktToken)Arguments.Node.Value;
//ktDebug.Log( "GAGA111:" + Token.Name );
Args = new ktList();
if (Token.Type == ktTokenType.RunStatement)
{
Args.Add(TokenToValue(Token, null));
}
else
{
Args.Add(TokenToValue(Token, null).CopyValue());
}
}
else
{
ktValue Value = null;
Arguments.Reset();
foreach (ktList L in Arguments)
{
if ((L.Node == null) || (L.Node.Value == null))
{
continue;
}
if (Args == null)
{
Args = new ktList();
}
Token = (ktToken)L.Node.Value;
if (Token.Type == ktTokenType.RunStatement)
{
Value = TokenToValue(Token, L);
}
else
{
Value = TokenToValue(Token, L).CopyValue();
}
if (Value != null)
{
Args.Add(Value);
}
}
}
#if Debug
ktDebug.Log( "EOFGA" );
ktDebug.Log( Args.Get_R( "\t", true ) );
#endif
return Args;
}
protected ktValue HandleNew(ktList Statement)
{
ktValue NewValue = ktValue.Null;
ktClass NewObj = null;
#if Debug
ktDebug.Log( "HandleNew:" + Statement.Get_R() );
#endif
if ((Statement == null) || (Statement.GetCount() == 0) ||
(Statement.First == null) || (Statement.First.Node == null) ||
(Statement.First.Node.Value == null) ||
((Statement.First.First != null) && (
(Statement.First.First.Node == null) || (Statement.First.First.Node.Value == null)))
)
{
throw new ktError("ktBlock::HandleNew: Didn't get enough information to create a new object!", ktERR.MISSING);
}
ktToken Token = (ktToken)Statement.First.Node.Value;
ktString Name = new ktString();
ktList Arguments = null;
if (Token.Type == ktTokenType.Id)
{
Name = Token.Value;
}
else if ((Token.Type == ktTokenType.CompStatement) ||
(Token.Type == ktTokenType.Statement))
{
Token = (ktToken)Statement.First.First.Node.Value;
Name = Token.Value;
Arguments = GetArguments(Statement.First.Last);
}
NewObj = (ktClass)MakeObjectOf(Name, (object)null);
if (Arguments != null)
{
ktDebug.Log("NO: " + NewObj.Export() + ";;Args:" + Arguments.Get_R());
try
{
NewObj.RunMethod("constructor", Arguments);
}
catch (ktError Err)
{
ktDebug.Log("NEW_CONS:ERR:" + Err.ToString());
if (Err.ErrorNumber == ktERR.NOTFOUND)
{
throw new ktError("The class " + Name + " is missing an constructor!", ktERR.NOTFOUND);
}
else
{
throw Err;
}
}
}
NewValue = new ktValue("", Name, NewObj, false, false);
ktDebug.Log("NV: " + NewValue.ToString());
return NewValue;
}
protected ktValue HandleOperator(ktList OpTree)
{
ktValue Value = ktValue.Null;
ktValue SecondValue = ktValue.Null;
if (OpTree == null)
{
ktDebug.Log("NOOOOOOOHO!!O!!!!!!!");
return Value;
}
#if Debug
ktDebug.Log( "HOHOHOHOHOHOHOHOHOHOHOHOHOHO:" + OpTree.Get_R( " ", true ) );
#endif
ktToken Op = null;
ktToken First = null;
ktToken Last = null;
if ((OpTree.Node != null) && (OpTree.Node.Value != null))
{
Op = (ktToken)(OpTree.Node.Value);
}
if ((OpTree.First != null) && (OpTree.First.Node != null))
{
if (OpTree.First.Node.Value is ktToken)
{
First = (ktToken)(OpTree.First.Node.Value);
}
else if (OpTree.First.Node.Value is ktValue)
{
Value = (ktValue)(OpTree.First.Node.Value);
First = new ktToken(ktTokenType.NULLTOKEN, "Value", 0, 0);
}
}
if ((OpTree.Last != null) && (OpTree.Last.Node != null))
{
Last = (ktToken)(OpTree.Last.Node.Value);
}
if ((First == null) && (Last == null) || (Op == null))
{
return Value;
}
if (Op.Type == ktTokenType.Operator)
{
ktClass Class = null;
if (First.Type == ktTokenType.NULLTOKEN)
{
//ktDebug.Log( "000000000000000000000000000000" );
}
else
{
Value = TokenToValue(First, OpTree.First);
}
SecondValue = TokenToValue(Last, OpTree.Last);
if (Value.IsNull() || SecondValue.IsNull())
{
throw new ktError("The " + (Value.IsNull() ? "left-hand" : "right-hand") +
" operand can not be a null value!", ktERR.NULL);
}
try
{
//ktDebug.Log("111:" + ((ktClass)Value.Value).Name + "!!!!222:" + ((ktClass)SecondValue.Value).Name + "#####");
Class = (ktClass)(Value.Value);
//ktDebug.Log( "?????????????????????????????????????" );
ktList Args = null;
if (((ktClass)SecondValue.Value).Name == "ktList")
{
ktDebug.Log("!!!!!!!!!");
Args = (ktList)(((ktClass)SecondValue.Value).GetProperty("___").Value);
}
else
{
Args = new ktList();
Args.Add(SecondValue);
}
ArrayList MethNames = new ArrayList(4);
MethNames.Add("operator" + Op.Value.ToString());
MethNames.Add("op" + Op.Value.ToString());
switch (Op.Value)
{
case "+":
{
MethNames.Add("_add");
break;
}
case "-":
{
MethNames.Add("_subtract");
break;
}
case "*":
{
MethNames.Add("_multiply");
MethNames.Add("_times");
break;
}
case "/":
{
MethNames.Add("_divide");
break;
}
case "^":
{
if (kacTalk.Main.MathMode)
{
MethNames.Add("_pow");
}
break;
}
}
foreach (string Meth in MethNames)
{
try
{
Value = Class.RunMethod(Meth, Args);
#if Debug
ktDebug.Log( "AFTREOP:" + Value.Export() + ";" );
#endif
return Value;
}
catch (ktError Err)
{
// ktDebug.Log("ASSMETHERR:" + Err.ToString());
if ((Err.ErrorNumber != ktERR._404) &&
(!Err.Message.StartsWith("Couldn't find the method ")))
{
throw Err;
}
}
}
throw new ktError("-", ktERR._404);
}
catch (ktError Err)
{
#if Debug
ktDebug.Log( "##############" + Err.ToString() + "\n" + Err.StackTrace ); //ktDebug.Log
#endif
if (Err.ErrorNumber != ktERR._404)
{
throw Err;
}
else if (Class == null)
{
throw new ktError("The variable '" + Value.Value + "' is not set", ktERR.NOTSET);
}
else if (Class.Name == "ktList")
{
ktList L = new ktList();
L.Node = OpTree.Node;
ktDebug.Log("HANDLELIST:::" + ((ktList)(Class.GetProperty("_FirstObject").Value)).Get_R() + " ==");
L.AddList((ktList)(Class.GetProperty("_FirstObject").Value));
L.AddList(OpTree.Last);
return HandleOperator(L);
}
else
{
throw new ktError("The operator '" + Op.Value + "' isn't handled by the class " +
Class.Name, ktERR.NOTIMP);
}
}
// ktDebug.Log( "111:" + Value.Value.Export( ) + "!!!!222:" + SecondValue.Value.Export() + "#####" );
//break;
}
else if (Op.Type == ktTokenType.AssignmentOperator)
{
Value = TokenToValue(Last, OpTree.Last);
if ((First.Type == ktTokenType.Id) || (First.Type == ktTokenType.CompStatement))
{
Value.Constant = false;
#if Debug
ktDebug.Log( "HO:AO: " + First.Value + ";" );
#endif
Value = HandleAssignment(Op, OpTree.First, First, Value);
// SetVariable( First.Value, Value, true, true );
}
else if (First.Type == ktTokenType.VarStatement)
{
if (Op.Value != "=")
{
throw new ktError("Expected a simple assignment operator (=) on line " + Op.LineNo.ToString() +
" by character " + Op.CharPos.ToString() + ", but found " +
Op.Value + "!", ktERR.UNEXP);
}
Value = HandleCompAssignment(OpTree.First, Value);
}
else
{
throw new ktError("Can't assign a value to an " + First.Name + " (" + First.Value + ") on line " + Op.LineNo.ToString() +
", character " + Op.CharPos.ToString() + "!", ktERR.UNKNOWN);
}
//break;
}
else
{
throw new ktError("Unrecognized operator (" + Op.Value + ") on line " + Op.LineNo.ToString() +
", character " + Op.CharPos.ToString() + "!", ktERR.UNKNOWN);
}
#if Debug
ktDebug.Log( "END OF HO!!!" );
#endif
return Value;
}
protected ktValue HandleRunStatement(ktList Statement)
{
#if Debug
ktDebug.Log( "HrSHRSHRSHRSHRSHRSHRSHRSHRSHRSHRSHRSHRSHRSHRS" );
#endif
ktValue Value = ktValue.Null;
if ((Statement == null) || (Statement.IsEmpty()))
{
return Value;
}
#if Debug
ktDebug.Log( Statement.Get_R() );
#endif
ktRunStatement RunStatement = new ktRunStatement(Statement, this);
Value = RunStatement.AsValue();
#if Debug
ktDebug.Log( "EOHRS" );
#endif
return Value;
}
/// <summary>
/// Parse the tokens and create a optree
/// </summary>
protected ktList MakeAOpTree(ktList List, int RunNumb)
{
ktList Tree = new ktList(), Prev = null, Temp = null;
ktToken Token = null, PrevToken = null;
bool result = false, SkipNext = false, ReturnTree = false;
// ktDebug.Log("MAOT!! [" + RunNumb + "]\n" + List.Get_R("\t") );
// null is null..
if (List == null)
{
return null;
}
ktDebug.WrapLevel++;
// Same, same, same...
Tree.Node = List.Node;
if ((Tree.Node == null) || (Tree.Node.Value == null) ||
(Tree.Node.Value.GetType() != typeof(ktToken)))
{
if (Tree.Node == null)
{
Tree.Node = new ktNode("ktBlock");
}
Tree.Node.Value = new ktToken(ktTokenType.Block, "ktBlock", 0, 0);
}
((ktToken)Tree.Node.Value).RunnedStep = RunNumb;
//#if ParseDebug
ktDebug.Log("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\nMAOT(" + RunNumb + "):" + List.Get_R());
//#endif
List.Reset();
foreach (ktList L in List)
{
SkipNext = false;
// Check so we don't try to work on nothing!
if ((L.Node != null) && (L.Node.Value != null))
{
// Get Token and previous...
Token = (ktToken)L.Node.Value;
Prev = Tree.Last;
// Get previous token if possible
if ((Prev != null) && (Prev.Node != null) && (Prev.Node.Value != null))
{
PrevToken = (ktToken)Prev.Node.Value;
}
else
{
PrevToken = new ktToken(ktTokenType.NULLTOKEN, ":null", 0, 0);
}
// Nothing here??
}
// Nothing there? ...
else
{
// ... Lets continue!
continue;
}
//ktDebug.Log("LLLLLLLLLL:::\n" + L.Get_R());
//ktDebug.Log("LiLiLiLiLiLiLiLiLiLi:::\n" + List.Get_R());
//#if ParseDebug3
ktDebug.Log("opTT:" + Token.Type.ToString() + "(" + Token.Value + ")");
ktDebug.Log("opPTT:" + PrevToken.Type.ToString() + "(" + PrevToken.Value + ")");
//#endif
// On run/pass 1
if (RunNumb == 1)
{
// Handle run 1
result = MakeAOpTree_Run1(PrevToken, Prev, Token, L, ref Tree, ref List, out SkipNext, out ReturnTree);
}
// On run/pass 2
else if (RunNumb == 2)
{
result = MakeAOpTree_Run2(PrevToken, Prev, Token, L, ref Tree, ref List, out SkipNext, out ReturnTree);
}
// On run/pass 3
else if (RunNumb == 3)
{
result = MakeAOpTree_Run3(PrevToken, Prev, Token, L, ref Tree, ref List, out SkipNext, out ReturnTree);
}
// If nothing was done ...
if (!result)
{
if ((Token.Type == ktTokenType.Id) || (Token.Type == ktTokenType.Null) ||
(Token.Type == ktTokenType.Number) || (Token.Type == ktTokenType.Float) ||
(Token.Type == ktTokenType.Boolean) ||
(Token.Type == ktTokenType.String)/* ||
(Token.Type == ktTokenType.If)*/ )
{
//ktDebug.Log("Constant etc!!(" + Token.Value + ")");
Temp = new ktList();
Temp.Node = L.Node;
((ktToken)Temp.Node.Value).RunnedStep = RunNumb;
Tree.AddList(Temp);
}
else if (Token.Type == ktTokenType.If)
{
//ktDebug.Log("IF-TOKEN!");
Tree.AddList(new ktList(L));
}
else
{
if ((Token.Type == ktTokenType.Statement) && (L.Count == 0))
{
//ktDebug.Log("MAOT(" + RunNumb + "): SKIP(Statement)");
continue;
}
Temp = MakeAOpTree(L, RunNumb);
ktDebug.Log("MAOT(" + RunNumb + "): TEMP:\n" + Temp.Get_R());
if ((Token.Type == ktTokenType.Statement) && (((ktToken)Temp.FirstNode.Value).Type == ktTokenType.If))
{
Temp = Temp.First;
}
if ((Token.Type == ktTokenType.Line) &&
(!PrevToken.HasBlock) &&
((PrevToken.Type == ktTokenType.If) ||
(PrevToken.Type == ktTokenType.Else) ||
(PrevToken.Type == ktTokenType.ElseIf)
))
{
/*ktDebug.Log("ISLINE:PREVIF!");
ktDebug.Log("TEMP: " + Temp.Get_R());*/
Prev.AddList(Temp);
}
else
{
Tree.AddList(Temp);
}
}
}
//ktDebug.Log("MAOT(" + RunNumb + "): TREE:\n" + Tree.Get_R());
// Should we return the tree we have created??
if (ReturnTree)
{
// Return the tree and be done with this part!
return Tree;
}
// Should we skip this one?
if (SkipNext)
{
SkipNext = false;
List.MoveNext();
}
continue;
// OLD CODE FOR REFERENCE:
if ((RunNumb == 1) && (Token.Type == ktTokenType.Block))
{
if (((PrevToken.Type == ktTokenType.If) ||
(PrevToken.Type == ktTokenType.Else) ||
(PrevToken.Type == ktTokenType.ElseIf)
) &&
(!PrevToken.HasBlock))
{
/*Tree.Last.AddList(new ktList(L));
((ktToken)Tree.Last.Node.Value).HasBlock = true;*/
Prev.AddList(new ktList(L));
PrevToken.HasBlock = true;
}
else
{
Tree.AddList(new ktList(L));
}
}
else if ((Token.Type == ktTokenType.Id) || (Token.Type == ktTokenType.Null) ||
(Token.Type == ktTokenType.Number) || (Token.Type == ktTokenType.Float) ||
(Token.Type == ktTokenType.Boolean) ||
(Token.Type == ktTokenType.String)/* ||
(Token.Type == ktTokenType.If)*/ )
{
//ktDebug.Log("Constant etc!!(" + Token.Value + ")");
Temp = new ktList();
Temp.Node = L.Node;
((ktToken)Temp.Node.Value).RunnedStep = RunNumb;
if (L.GetCount() != 0)
{
Temp.AddList(MakeAOpTree(L, RunNumb));
}
Tree.AddList(Temp);
}
else if (Token.Type == ktTokenType.If)
{
//ktDebug.Log("IF-TOKEN!");
Tree.AddList(new ktList(L));
}
else if ((RunNumb == 1) && (PrevToken.Type == ktTokenType.If) && (!PrevToken.HasBlock) && (RunNumb == 1) &&
((Token.Type == ktTokenType.Statement) || (Token.Type == ktTokenType.List)) )
{
ktList ifL = Tree.Pop();
Temp = new ktList();
Temp.Node = ifL.Node;
((ktToken)Temp.Node.Value).RunnedStep = RunNumb;
Temp.AddList(MakeAOpTree(L, RunNumb));
#if ParseDebug
ktDebug.Log("MAOT(" + RunNumb + "): IF-statement: " + Temp.Get_R());
#endif
Tree.AddList(Temp);
#if ParseDebug
ktDebug.Log("MAOT(" + RunNumb + "): IF TREE: " + Tree.Get_R());
#endif
}
}
#if ParseDebug
ktDebug.Log( "MAOTREE(" + RunNumb + "):\n" + Tree.Get_R( "\t", true ) );
ktDebug.WrapLevel--;
if (this.m_enabledDebug && (this.m_enabledAt == ktDebug.WrapLevel)) { ktDebug.D.Disable(); }
#endif
return Tree;
}
public ktValue RunLine(ktList Line)
{
ktValue Ret = ktValue.Null;
ktToken Token = null;
ktToken LToken = null;
if (Line == null)
{
throw new ktError("ktBlock::RunLine() : Didn't get a line to run!", ktERR.NOTSET);
}
//#if Debug
ktDebug.Log( "RL:" + Line.Get_R( " ", true ) );
//#endif
/*if (Token.LineNo == 3)
{
//ktDebug.Log("L3T: ");
ktDebug.Log("L3: " + Line.Get_R(" ", true));
}*/
try
{
Token = (ktToken)Line.Node.Value;
if (Line.GetCount() == 0)
{
if (Line.Node != null)
{
if (Token.Type == ktTokenType.String)
{
Ret = new ktValue(":ktString", "ktString", MakeObjectOf("ktString", Token.Value),
true, true);
}
else if (Token.Type == ktTokenType.Number)
{
Ret = new ktValue(":ktInt", "ktInt", MakeObjectOf("ktInt", Token.Value),
true, true);
}
else if (Token.Type == ktTokenType.Float)
{
Ret = new ktValue(":ktFloat", "ktFloat", MakeObjectOf("ktFloat", Token.Value),
true, true);
}
else if (Token.Type == ktTokenType.Id)
{
Ret = GetVariable(Token.Value);
}
}
else
{
//throw new ktError( "ktBlock::RunLine() : Didn't get a line to run!", ktERR.NOTSET );
return Ret;
}
}
switch (Token.Type)
{
case ktTokenType.If:
{
bool r = CheckLogicStatement(Line.First,Token, ref Ret);
if (r)
{
// m_skipNextLine = true;
ktList Next = Line.First.Next;
ktToken IfToken = (ktToken)Next.Node.Value;
switch (IfToken.Type)
{
case ktTokenType.Block:
{
IfToken.Block.SetParent(this);
Ret = IfToken.Block.Run();
break;
}
default:
{
Ret = RunLine(Next);
break;
}
};
}
return Ret;
}
case ktTokenType.For:
{
break;
}
case ktTokenType.Foreach:
{
break;
}
case ktTokenType.While:
{
break;
}
}
Line.Reset();
foreach (ktList TL in Line)
{
if ((TL.Node == null) || (TL.Node.Value == null))
{
continue;
}
LToken = Token;
Token = (ktToken)TL.Node.Value;
switch (Token.Type)
{
case ktTokenType.CompStatement:
{
Ret = HandleCompound(TL);
break;
}
case ktTokenType.AssignmentOperator:
{
Ret = HandleOperator(TL);
break;
}
case ktTokenType.Operator: {
Ret = HandleOperator(TL);
break;
}
/*case ktTokenType.If: {
break;
}*/
case ktTokenType.Number:
case ktTokenType.String:
case ktTokenType.Id:
{
ktList L = new ktList();
L.AddList(TL);
Ret = HandleStatement(L);
break;
}
default:
{
throw new ktError("ktBlock::RunLine(): Unexpected " + Token.Name +
" on line " + Token.LineNo.ToString() +
" (by character " + Token.CharPos.ToString() + ")",
ktERR.UNEXP);
}
}
#if Debug
ktDebug.Log( "New Line!!!!!!!!!!!!" );
#endif
}
}
catch (ktError Err)
{
//ktDebug.Log("SL:SC:" + Err.ToString() + ";" + Line.Get_R());
if (Token == null)
{
if (LToken != null)
{
Token = LToken;
}
else if (Line.Node != null)
{
Token = (ktToken)Line.Node.Value;
}
else if (Line.FirstNode != null)
{
Token = (ktToken)Line.FirstNode.Value;
}
else if (Line.LastNode != null)
{
Token = (ktToken)Line.LastNode.Value;
}
}
if (Token != null)
{
Err.SetLine(Token.LineNo);
Err.SetChar(Token.CharPos);
ktDebug.Log(Err.ToString());
}
else ktDebug.Log("NOOOOOOOO!!");
throw Err;
}
#if Debug
ktDebug.Log( "EORL" );
#endif
/* if (Ret == null) {
Ret = Value;
}*/
return Ret;
}
protected ktValue HandleStatement(ktList Statement)
{
#if Debug
ktDebug.Log( "HSHSHSHSHSHSHSHSHSHSHSHSHSHSHS" );
#endif
ktValue Value = ktValue.Null;
ktDebug.Log(Statement.Get_R());
if ((Statement == null) || (Statement.IsEmpty()) ||
(Statement.First.Node == null) || (Statement.First.Node.Value == null))
{
ktDebug.Log(Statement.Get_R());
return Value;
}
#if Debug
ktDebug.Log( Statement.Get_R() );
#endif
ktToken Token = (ktToken)Statement.First.Node.Value;
Value = TokenToValue(Token, Statement.First);
#if Debug
ktDebug.Log( "EOHS" );
#endif
return Value;
}
/// <summary>
/// Handle a "compound satement"
/// </summary>
/// <param name="Token"></param>
/// <param name="L"></param>
/// <param name="Tree"></param>
/// <param name="List"></param>
/// <param name="SkipNext"></param>
/// <param name="ReturnTree"></param>
/// <returns></returns>
private bool HandleCompStatement(ktToken Token, ktList L, ref ktList Tree, ref ktList List, out bool SkipNext, out bool ReturnTree, int RunNumb = 1)
{
ktList First = null, Second = null, SecondChild = null, Temp = null;
ktToken FirstToken = null, SecondToken = null, SecondChildToken = null;
SkipNext = false;
ReturnTree = false;
ktDebug.Log("HandleComp:\n" + L.Get_R());
First = L.First;
Second = L.First.Next;
SecondChild = Second.First;
FirstToken = (ktToken)First.Node.Value;
SecondToken = (ktToken)Second.Node.Value;
if (FirstToken.Type != ktTokenType.Id)
{
First = MakeAOpTree(First, RunNumb);
}
if (SecondChild != null)
{
SecondChildToken = (ktToken)SecondChild.Node.Value;
if (SecondChildToken.Type == ktTokenType.List)
{
SecondChild = MakeAOpTree(SecondChild, RunNumb);
Second.Clear();
Second.AddList(SecondChild);
}
}
else if (SecondToken.Type != ktTokenType.Id)
{
Second = MakeAOpTree(Second, RunNumb);
}
Temp = new ktList();
Temp.Node = L.Node;
((ktToken)Temp.Node.Value).RunnedStep = RunNumb;
Temp.AddList(First);
Temp.AddList(Second);
Tree.AddList(Temp);
/*ktDebug.Log("HandleComp__:\n" + Temp.Get_R());
ktDebug.Log("HandleComp Tree:\n" + Tree.Get_R());*/
return true;
}
/// <summary>
/// Parse the tokens and create a tree/* (mainly for operators)*/
/// </summary>
protected ktList MakeATree()
{
if (m_Lines == null)
{
m_Lines = new ktList();
//m_Lines.Node = new ktNode( m_Name, new ktToken( ktTokenType.Program, m_Name, 0, 0 ) );
}
ktList Tree = MakeATree(m_LineStack, true, false);
#if ParseDebug
ktDebug.Log( "MAT_TREE1:" + Tree.Get_R( " ", true ) );
#endif
/*
Tree = MakeATree( Tree, false, false );
ktDebug.Log( "MAT_TREE2:" + Tree.Get_R( "\t", true ) );*/
Tree = MakeATree(Tree, false, true);
#if ParseDebug
ktDebug.Log( "MAT_TREEEEEEEE:\n" + Tree.Get_R( " ", true ) );
#endif
/**/
m_Lines = Tree;/*/
m_Lines.AddList( Tree );/**/
#if ParseDebug
ktDebug.Log( "MAT_LINES:" + m_Lines.Get_R( " ", true ) );
#endif
return m_Lines;
}
/// <summary>
/// React on the "token" in Word
/// </summary>
protected bool ReactOnToken(ktString Word, int Line, ref int CharPos)
{
/* In the C++/"original" version of this method, it didn't do what
* it's called (_React_ On Token), instead it just added the token to the list.
* This method, hovever, does react properly to the given token
* This also reduces the number of steps for scanning/parsering (creating the op. tree)
* from three to two (we could probably just do it all in one step, but it would be messy
* and a bit complex..)
*/
#if ParseDebug
ktDebug.Log( "ReactOnToken(" + Word + ")" );
ktDebug.Log( "BS:" + ktXML.FromList(m_BlockStack).AsXML() );
#endif
ktToken Token = new ktToken(Word, Line, CharPos);
ktToken LastToken = null;
ktToken LastAddedToken = null;
ktToken.OnlyExportValue = true;
if ((m_TokenStack != null) && (m_TokenStack.Last != null) &&
(m_TokenStack.Last.Node != null) && (m_TokenStack.Last.Node.Value != null))
{
LastToken = (ktToken)m_TokenStack.Last.Node.Value;
}
if ((m_Tokens != null) && (m_Tokens.Last != null) &&
(m_Tokens.Last.Node != null) && (m_Tokens.Last.Node.Value != null))
{
LastAddedToken = (ktToken)m_Tokens.Last.Node.Value;
}
if (m_CurToken != null)
{
// React differentely deppendig on "current token/'state'"
switch (m_CurToken.Type)
{
// If it's an comment...
case ktTokenType.MLComment:
{
// ... Check if the token is EOC? ...
if (Token.Type == ktTokenType.EOC)
{
m_CurToken = (ktToken)(m_TokenStack.Pop().Node.Value);
}
// ... ignore...
return true;
}
// If it's an comment...
case ktTokenType.OLComment:
{
// ... Check if the token is EOC? ...
if (Word == "\n")
{
m_CurToken = (ktToken)(m_TokenStack.Pop().Node.Value);
}
// ... ignore...
return true;
}
// If it's a string...
case ktTokenType.String:
case ktTokenType.StringQuot:
case ktTokenType.StartString:
{
// If we are at end of the string?
if ((Token.Type == ktTokenType.StringQuot) &&
(m_CurToken.Value.Last() != '\\'))
{
ktList Temp = null;
// Add string...
m_Tokens.Add("ktTString", m_CurToken);
// If we can, put back the previous token...
if ((m_TokenStack != null) && ((Temp = m_TokenStack.Pop()) != null) &&
(Temp.Node != null))
{
m_CurToken = (ktToken)Temp.Node.Value;
}
else
{
m_CurToken = null;
}
return true;
}
m_CurToken.Value += Word;
return true;
}
}
}
#if ParseDebug2
/*Debug || */
// if (Line == 4) {
ktDebug.Log( "Token:" + Token.Type.ToString() + " (" + Token.Value + ")" );
ktDebug.Log( "CurToken:" + m_CurToken.Type.ToString() );
ktDebug.Log( "BS:" + ktXML.FromList(m_BlockStack).AsXML() );
ktDebug.Log( "Ts:" + ((m_TokenStack == null) ? "null" : m_TokenStack.Get_R().ToString() ));
ktDebug.Log( "LS:" + ((m_LineStack == null) ? "null" : m_LineStack.Get_R( "\t", true ).ToString() ));
ktDebug.Log( "Ls:" + ((m_Lines == null) ? "null" : m_Lines.Get_R( "\t", true ).ToString() ));
ktDebug.Log( "ts:" + ((m_Tokens == null) ? "null" : m_Tokens.Get_R().ToString() ));
// }
#endif
// Check the token..
switch (Token.Type)
{
// Is it a whitespage??
case ktTokenType.WhiteSpace:
{
// ... ignore...
return true;
}
// Is it an id (var/function)?
case ktTokenType.Id:
{
AddToken(Token);
return true;
}
// Is it a number?
case ktTokenType.Number:
{
AddToken(Token);
return true;
}
// Is it a boolean (true/false)?
case ktTokenType.Boolean:
{
AddToken(Token);
return true;
}
// Is it an separator (. or ::)?
case ktTokenType.Separator:
{
if ((LastAddedToken != null) && (LastAddedToken.Value == ":") &&
(Token.Value == ":"))
{
LastAddedToken.Value = "::";
}
else
{
AddToken(Token);
}
return true;
}
// Is it an operator?????
case ktTokenType.Operator:
case ktTokenType.AssignmentOperator:
{
// We should perhaps do some more here??
AddToken(Token);
return true;
}
// Is it an const/hard?????
case ktTokenType.Const:
case ktTokenType.Hard:
{
AddToken(Token);
return true;
}
// Create a new object?
case ktTokenType.New:
{
AddToken(Token);
return true;
}
// Null?
case ktTokenType.Null:
{
AddToken(Token);
return true;
}
// Is it a If-statement?
case ktTokenType.If:
{
AddToken(Token);
return true;
}
// Is it a quot (")?
case ktTokenType.StringQuot:
{
// No Token stack??
if (m_TokenStack == null)
{
// Create it...
m_TokenStack = new ktList();
}
// Add the current token to the stack
m_TokenStack.Add(m_CurToken);
// And Replace it with this "string token"
m_CurToken = new ktToken(ktTokenType.String, "", m_CurLine, m_CharPos);
return true;
}
// Is it an start par. [(]?
case ktTokenType.StartPar:
{
// No Token stack??
if (m_TokenStack == null)
{
// Create it...
m_TokenStack = new ktList();
}
// No Line Stack?
if (m_LineStack == null)
{
// Create it...
m_LineStack = new ktList();
}
// Add the current token to the stack
m_TokenStack.Add(m_CurToken);
// And Replace it with this "list token"
m_CurToken = new ktToken(ktTokenType.List, "ktList", m_CurLine, m_CharPos);
// Put the current ""line"" onto the stack
m_LineStack.AddList(m_Tokens);
// Create a new list...
m_Tokens = new ktList();
m_Tokens.Node = new ktNode("ktList", m_CurToken);
// Put the current ""list"" onto the stack
m_LineStack.AddList(m_Tokens);
// Create a new list...
m_Tokens = new ktList();
m_Tokens.Node = new ktNode("ktTStatement",
new ktToken(ktTokenType.Statement, "", m_CurLine, m_CharPos));
return true;
}
// Is it an comma (,)?
case ktTokenType.Comma:
{
if (m_CurToken.Type != ktTokenType.List)
{
throw new ktError("Unexpected " + ktToken.TokenToString(Token.Type) + " on line " +
Line.ToString() + " by character " + CharPos.ToString() + ".", ktERR.UNEXP);
}
// get the last list
ktList List = m_LineStack.Last;
// Put the current ""statement"" onto the stack
List.AddList(m_Tokens);
// Create a new list...
m_Tokens = new ktList();
m_Tokens.Node = new ktNode("ktStatement",
new ktToken(ktTokenType.Statement, "", m_CurLine, m_CharPos));
return true;
}
// Is it an end par. [)]?
case ktTokenType.EndPar:
{
if (m_CurToken.Type != ktTokenType.List)
{
throw new ktError("Unexpected " + ktToken.TokenToString(Token.Type) + " on line " +
Line.ToString() + " by character " + CharPos.ToString() + ".", ktERR.UNEXP);
}
// Get the last "statement"
ktList Temp = m_LineStack.Pop();
// Add Current "statement"/"post" to the list and then switch them
Temp.AddList(m_Tokens);
m_Tokens = Temp;
// Get the "last statement" (where the list was "defined")
Temp = m_LineStack.Pop();
Temp.AddList(m_Tokens);
// "Switch"
m_Tokens = Temp;
// If we can, put back the previous token...
if ((m_TokenStack != null) && ((Temp = m_TokenStack.Pop()) != null) &&
(Temp.Node != null))
{
m_CurToken = (ktToken)Temp.Node.Value;
}
else
{
m_CurToken = null;
}
return true;
}
// Is it an End-of-line (semicolon). (;)?
case ktTokenType.EOL:
{
// Should we use m_Lines instead???
if (m_LineStack == null)
{
m_LineStack = new ktList();
}
// KacTalk special, runnable arguments!
// If we are in a list and finds a semicolon, it means
// that that "post" should be treated as "runnable"
if (m_CurToken.Type == ktTokenType.List)
{
ktToken T = (ktToken)m_Tokens.Node.Value;
// Mark as "runnable"
T.Name = m_Tokens.Node.Name = "ktTRunStatement";
T.Type = ktTokenType.RunStatement;
// NOTE: basically the same as for comma (,) (see above)
// get the last list
ktList List = m_LineStack.Last;
// Put the current ""statement"" onto the stack
List.AddList(m_Tokens);
// Create a new list...
m_Tokens = new ktList();
m_Tokens.Node = new ktNode("ktTStatement",
new ktToken(ktTokenType.Statement, "", m_CurLine, m_CharPos));
return true;
}
((ktToken)m_Tokens.Node.Value).Type = ktTokenType.Line;
((ktToken)m_Tokens.Node.Value).Name = m_Tokens.Node.Name = "ktTLine";
m_LineStack.AddList(m_Tokens);
// Create a new list...
m_Tokens = new ktList();
m_Tokens.Node = new ktNode("ktTStatement_",
new ktToken(ktTokenType.Statement, "", m_CurLine, m_CharPos));
return true;
}
// Is it a block ({)!?
case ktTokenType.Block:
{
// No Token stack??
if (m_TokenStack == null)
{
// Create it...
m_TokenStack = new ktList();
}
/*/ No Line Stack?
if (m_LineStack == null) {
// Create it...
m_LineStack = new ktList();
} else {
if (m_BlockStack == null) {
m_BlockStack = new ktList();
}
m_BlockStack.AddList( m_LineStack );
}*/
#if ParseDebug
ktDebug.Log("BLOCK!!!");
#endif
if (m_BlockStack == null)
{
#if ParseDebug
ktDebug.Log( "NEW_BLOCK_STACK" );
#endif
m_BlockStack = new ktList();
if (m_MainBlock == null)
{
m_MainBlock = new ktBlock();
m_MainBlock.SetMain(this);
}
m_BlockStack.Add(m_MainBlock);
}
// Put the current ""line"" onto the stack
m_LineStack.AddList(m_Tokens);
LastBlock.SetLines(m_LineStack);
ktBlock Block = new ktBlock(new ktList());
Block.SetMain(this);
m_BlockStack.Add("ktTBlock", Block);
m_LineStack = new ktList();
// Add the current token to the stack
m_TokenStack.Add(m_CurToken);
// And Replace it with this "block token"
m_CurToken = new ktToken(ktTokenType.Block, "ktTBlock", m_CurLine, m_CharPos);
// Create a new list...
m_Tokens = new ktList();
m_Tokens.Node = new ktNode("ktTStatement.",
new ktToken(ktTokenType.Statement, "", m_CurLine, m_CharPos));
// Start a "new block"
/*m_LineStack = new ktList();
// Put the current ""line"" onto the stack
m_LineStack.AddList( m_Tokens );
// Create a new block...
m_Tokens = new ktList();
m_Tokens.Node = new ktNode( "ktTBlock", m_CurToken );
// Put the current ""list"" onto the stack
m_LineStack.AddList( m_Tokens );
// Create a new list...
m_Tokens = new ktList();
m_Tokens.Node = new ktNode( "ktTLine",
new ktToken( ktTokenType.Line, "", m_CurLine, m_CharPos ) );*/
return true;
}
// Is it an end of a block (})?
case ktTokenType.EOB:
case ktTokenType.End:
{
#if ParseDebug
ktDebug.Log( "EOB;EOB;EOB;EOB;EOB;EOB;EOB;EOB;EOB;EOB;EOB;EOB;EOB;" );
ktDebug.Log("CurrToken:" + m_CurToken.ToString());
#endif
if ((m_CurToken.Type != ktTokenType.Block) ||
(m_BlockStack == null) || (m_BlockStack.Last == null) ||
(m_BlockStack.Last.Node == null) || (m_BlockStack.Last.Node.Value == null))
{
throw new ktError("Unexpected " + ktToken.TokenToString(Token.Type) + " on line " +
Line.ToString() + " by character " + CharPos.ToString() + ".", ktERR.UNEXP);
}
#if ParseDebug2
ktDebug.Log( "ROT::B::BLS:" + ktXML.FromList(m_BlockStack).AsXML() );
#endif
ktBlock Block = (ktBlock)(m_BlockStack.Pop().Node.Value);
#if ParseDebug2
ktDebug.Log( "ROT::B::BLS2:" + ktXML.FromList(m_BlockStack).AsXML() );
ktDebug.Log( "ROT::B::Tokens:" + m_Tokens.Get_R() );
ktDebug.Log( "ROT::B::LineStack:" + m_LineStack.Get_R( "\t", true ) );
#endif
MakeATree();
#if ParseDebug2
ktDebug.Log( "ROT::B::Lines:" + m_Lines.Get_R() );
#endif
Block.Lines = MakeAOpTree();
#if ParseDebug2
ktDebug.Log( "ROT::Block:" + Block.ToString() );
ktDebug.Log( "ROT::Block:Lines:" + Block.Lines.Get_R() );
#endif
m_LineStack.Clear();
m_LineStack = LastBlockLines;
// m_Lines.Clear();
m_Lines = null;
#if ParseDebug2
ktDebug.Log( "ROT::B::LineStack22:" + m_LineStack.Get_R( "\t", true ) );
#endif
/*Block.Lines = MakeATree( MakeATree( m_LineStack, true, false ), false, true );
Block.Lines = MakeAOpTree( MakeAOpTree( MakeAOpTree( Block.Lines, 1 ), 2 ), 3 )*/
m_Tokens.Node.Name = "ktTBlock";
((ktToken)m_Tokens.Node.Value).Name = "ktTBlock";
((ktToken)m_Tokens.Node.Value).Type = ktTokenType.Block;
// Add Current "statement"/"post" to the block and then switch them
//Temp.AddList( m_Tokens );
//m_Tokens = Temp;
ktList Temp = null;
if (LastBlockLines == null)
{
throw new ktError("No Last Block Lines!", ktERR.MISSING);
}
LastBlockLines.Add("ktTBlock", new ktToken(Block, m_CurToken.LineNo, m_CurToken.CharPos));
// "Switch"
//m_Tokens = Temp;
#if ParseDebug2
ktDebug.Log( "ROT::B::LastBlockLines:" + LastBlockLines.Get_R( "\t", true ) );
#endif
// If we can, put back the previous token...
if ((m_TokenStack != null) && ((Temp = m_TokenStack.Pop()) != null) &&
(Temp.Node != null))
{
m_CurToken = (ktToken)Temp.Node.Value;
}
else
{
m_CurToken = null;
}
return true;
}
// Comments...
// One line comment??
// (bash only indicates comments if it's the first thing on the line...)
case ktTokenType.Bash:
{
// If it's the first thing on the line!?
if (m_CharPos <= 1)
{
// Indicate one line comment...
// No Token stack??
if (m_TokenStack == null)
{
// Create it...
m_TokenStack = new ktList();
}
// Add the current token to the stack
m_TokenStack.Add(m_CurToken);
// And Replace it with this "commeent token"
m_CurToken = new ktToken(ktTokenType.OLComment, "ktTOLComment", m_CurLine, m_CharPos);
return true;
// Not First at the line...
}
else
{
// What should we do??
// Exception, AddToken or somee magic for ids!???
// Unexpected...
throw new ktError("Unexpeected " + ktToken.TokenToString(Token.Type) + " on line " +
m_CurLine.ToString() + " by character " + m_CharPos.ToString(), ktERR.UNEXP);
}
}
// One line comment
case ktTokenType.OLComment:
{
// No Token stack??
if (m_TokenStack == null)
{
// Create it...
m_TokenStack = new ktList();
}
// Add the current token to the stack
m_TokenStack.Add(m_CurToken);
// And Replace it with this "commeent token"
m_CurToken = new ktToken(ktTokenType.OLComment, "ktTOLComment", m_CurLine, m_CharPos);
return true;
}
// Multi line comment
case ktTokenType.MLComment:
{
// No Token stack??
if (m_TokenStack == null)
{
// Create it...
m_TokenStack = new ktList();
}
// Add the current token to the stack
m_TokenStack.Add(m_CurToken);
// And Replace it with this "Comment token"
m_CurToken = new ktToken(ktTokenType.MLComment, "ktTMLComment", m_CurLine, m_CharPos);
return true;
}
// If it's an End of comment
case ktTokenType.EOC:
{
// Unexpected...
throw new ktError("Unexpeected " + ktToken.TokenToString(Token.Type) + " on line " +
m_CurLine.ToString() + " by character " + m_CharPos.ToString(), ktERR.UNEXP);
}
}
// To see if we missed any tokens...
ktToken.OnlyExportValue = false;
ktDebug.Log("IGNmORED:" + Token.Export() + "\n");
return true;
}
/// <summary>
/// Parse the tokens and create a tree /*(mainly for operators)**/
/// </summary>
protected ktList MakeATree(ktList List, bool FirstRun, bool ThirdRun)
{
//ktDebug.Log( "MAT!" + List.Get_R( "\t", true ));
ktList Tree = new ktList(), Prev = null, Next = null, Temp = null, Temp2 = null;
ktToken Token = null, PrevToken = null;
/*/ If the list are the "root"
if (List == m_LineStack) {
Tree.Node = new ktNode( "ktTBlock", new ktToken( ktTokenType.Block, "", 0, 0 ) );
} else/**/
{
Tree.Node = List.Node;
}
List.Reset();
foreach (ktList L in List)
{
//ktDebug.Log( "\nLLL: "+ List.Get_R() /*+ " :" +L.Export() */);
if ((L.Node != null) && (L.Node.Value != null))
{
Token = (ktToken)L.Node.Value;
Prev = Tree.Last;
if ((Prev != null) && (Prev.Node != null) && (Prev.Node.Value != null))
{
PrevToken = (ktToken)Prev.Node.Value;
}
else
{
PrevToken = new ktToken(ktTokenType.NULLTOKEN, ":null", 0, 0);
}
}
else
{
continue;
}
//#if ParseDebug
ktDebug.Log( "TT:" + Token.Type.ToString() + "(" + Token.Value + ")" );
ktDebug.Log( "PTT:" + PrevToken.Type.ToString() + "(" + PrevToken.Value + ")" );
//#endif
if ((FirstRun) && (
((PrevToken.Type == ktTokenType.Const) || (PrevToken.Type == ktTokenType.Hard)) ||
((Token.Type == ktTokenType.Const) || (Token.Type == ktTokenType.Hard)) ||
((PrevToken.Type == ktTokenType.VarStatement) && (
(Token.Type != ktTokenType.AssignmentOperator)/* ||
(Token.Type != ktTokenType.)*/
)
)))
{
//ktDebug.Log( "CONSTCONSTCONSTCONSTCONSTCONSTCONSTCONSTCONST" );
if (PrevToken.Type == ktTokenType.VarStatement)
{
if ((Token.Type != ktTokenType.Id) && (Token.Type != ktTokenType.Hard) &&
(Token.Type != ktTokenType.Const))
{
throw new ktError("Unexpected " + Token.Name + " on line " + Token.LineNo.ToString() +
" by character " + Token.CharPos.ToString() + "!", ktERR.UNEXP);
}
Prev.Add(Token);
}
else
{
Temp = new ktList();
Temp.Node = new ktNode("ktTVarStatement", new ktToken(ktTokenType.VarStatement, "", Token.LineNo, Token.CharPos));
Temp.Add(Token);
// Temp.AddList( MakeATree( L, FirstRun ) );
Tree.AddList(Temp);
}
}
else if (
(
((PrevToken.Type == ktTokenType.Id) && (ThirdRun)) ||
((/*!*/FirstRun) && (
(PrevToken.Type == ktTokenType.CompStatement) &&
(
(PrevToken.Value == ".") ||
(PrevToken.Value == "::")
)
)
)) && (
(Token.Type == ktTokenType.List) ||
(Token.Type == ktTokenType.Statement) ||
// (Token.Type == ktTokenType.CompStatement) ||
(Token.Type == ktTokenType.Const) ||
(Token.Type == ktTokenType.Hard) ||
(Token.Type == ktTokenType.String) ||
(Token.Type == ktTokenType.Boolean) ||
(Token.Type == ktTokenType.Number) ||
(Token.Type == ktTokenType.Float) ||
(Token.Type == ktTokenType.Null) ||
(Token.Type == ktTokenType.Id) // ?? Not shure on how this actually will work!?
))
{
ktDebug.Log("Tree:" + Tree.Get_R());
Tree.Pop(false);
/* ktDebug.Log("TToxen:" + Token.ToString());
ktDebug.Log("PToxen:" + PrevToken.ToString());*/
if ( (PrevToken.Value == ".") ) {
if (Token.Type == ktTokenType.List)
{
Temp = MakeATree(L, FirstRun, ThirdRun);
Prev.Last.AddList(Temp);
}
else
{
Prev.Last.AddList(new ktList(L));
}
((ktToken)Prev.Node.Value).Value = "§";
Tree.AddList(Prev);
//((ktToken)Tree.Node.Value).Value = "§";
ktDebug.Log("Tree:" + Tree.Get_R());
}
else if ((Prev.Prev == null) || ((Prev.Prev.Node != null) && (Prev.Prev.Node.Value != null) && (((ktToken)Prev.Prev.Node.Value).Type != ktTokenType.Id)))
{
Temp = new ktList();
Temp.Node = new ktNode("ktCompStatement", new ktToken(ktTokenType.CompStatement, "F", PrevToken.LineNo, PrevToken.CharPos));
if (Token.Type == ktTokenType.List)
{
Temp2 = MakeATree(L, FirstRun, ThirdRun);
//Temp2.Node.Value = Token;
Temp.AddList(Prev); // Add function name
Temp.AddList(Temp2); // Add arguments
#if ParseDebug
ktDebug.Log("FComp_List:\n" + Temp.Get_R());
ktDebug.Log("FComp_List T2:\n" + Temp2.Get_R());
#endif
}
else
{
Temp.AddList(Prev); // Add function name
Temp.AddList(new ktList(L)); // Add argument
#if ParseDebug
ktDebug.Log("FComp_NoList:\n" + Temp.Get_R());
#endif
}
Tree.AddList(Temp);
#if ParseDebug
ktDebug.Log("FComp Tree:\n" + Tree.Get_R());
#endif
}
else
{
Temp = new ktList();
Temp.Node = new ktNode("ktTCompStatement", new ktToken(ktTokenType.CompStatement, "§", PrevToken.LineNo, PrevToken.CharPos));
//ktDebug.Log("§§§§§§§§§§§§§§§§§§§§§§§§§§§");
if (Token.Type == ktTokenType.List)
{
Temp2 = new ktList();
Temp2.Node = new ktNode("ktTCompStatement", new ktToken(ktTokenType.CompStatement, ".", PrevToken.LineNo, PrevToken.CharPos));
Temp2.AddList(Prev.Last); // Add Method
Temp2.AddList(MakeATree(L, FirstRun, ThirdRun)); // Add Arguments
Temp.AddList(Prev.First); // Add object
Temp.AddList(Temp2); // Add Method call
Tree.AddList(Temp);
#if Debug
ktDebug.Log("L_Temp2:\n" + Temp2.Get_R());
ktDebug.Log("L_Temp:\n" + Temp.Get_R());
ktDebug.Log("L_Tree:\n" + Tree.Get_R());
#endif
}
else
{
//Temp.AddList(Prev);
//Temp.AddList(MakeATree(L, FirstRun, ThirdRun));
Prev.AddList(MakeATree(L, FirstRun, ThirdRun));
/* ktDebug.Log("Temp:" + Temp.Get_R());
ktDebug.Log("Prev:" + Prev.Get_R());*/
// Tree.AddList(Temp);
Tree.AddList(Prev);
//ktDebug.Log("Tree:" + Tree.Get_R());
}
}
}
else if (
(ThirdRun) &&
(
(PrevToken.Type == ktTokenType.Id) ||
(PrevToken.Type == ktTokenType.CompStatement)
) &&
(Token.Type == ktTokenType.CompStatement)
)
{
#if ParseDebug2
ktDebug.Log( "PREV:"+ PrevToken.Value );
ktDebug.Log( "LLLL:"+ L.Get_R() );
ktDebug.Log( "NNN:"+ ((Next == null) ? "nulL" : Next.Get_R().ToString()) );
#endif
Tree.Remove((uint)(Tree.Count - 1));
Temp = new ktList();
Temp.Node = new ktNode("ktTCompStatement", new ktToken(ktTokenType.CompStatement, "$", PrevToken.LineNo, PrevToken.CharPos));
Temp.AddList(Prev);
Tree.AddList(new ktList(L));
Tree.AddList(Temp);
}
else if ((Token.Type == ktTokenType.Line) ||
(Token.Type == ktTokenType.List) ||
(Token.Type == ktTokenType.Statement) ||
(Token.Type == ktTokenType.RunStatement) /*||
(Token.Type == ktTokenType.New)*/)
{
#if ParseDebug2
ktDebug.Log( "\nMAT::MAT::MAT::MAT::MAT::MAT::MAT::MAT::\n" +L.Get_R() );
#endif
/*if ((!FirstRun) && (PrevToken != null) && (
(PrevToken.Type == ktTokenType.Id) ||
(PrevToken.Type == ktTokenType.CompStatement) ||
(PrevToken.Type == ktTokenType.Statement))) {
Tree.Remove( (uint)(Tree.Count - 1) );
Temp = new ktList( );
Temp.Node = new ktNode( "ktTCompStatement", new ktToken( ktTokenType.CompStatement, Token.Value, Token.LineNo, Token.CharPos ) );
Temp.AddList( Prev );
Temp.AddList( MakeATree( L, FirstRun ) );
Tree.AddList( Temp );
} else {*/
Tree.AddList(MakeATree(L, FirstRun, ThirdRun));
/*}*/
}
else if ((Token.Type == ktTokenType.Separator) && FirstRun)
{
Prev = L.Prev;
Next = L.Next;
// Tree.Remove( (uint)(Tree.Count - 1) );
if ((Next != null) && (Next.Node != null) && (Next.Node.Value != null) &&
(Token.Value == ":") &&
(((ktToken)Next.Node.Value).Type == ktTokenType.Null))
{
Token = (ktToken)Next.Node.Value;
Token.Value = ":null";
Tree.Add("ktTNull", Token);
List.MoveNext();
List.MoveNext();
continue;
}
#if ParseDebug2
ktDebug.Log( "MakeATree calling HandleSep!" );
#endif
HandleSep(Prev, Next, ref Tree, Token);
List.MoveNext();
}
else if ((FirstRun) && (
(Token.Type == ktTokenType.Operator) ||
(Token.Type == ktTokenType.AssignmentOperator)
) && (
(PrevToken.Type == ktTokenType.Operator) ||
(PrevToken.Type == ktTokenType.AssignmentOperator)
))
{
if ( (Token.Value == "=") || (PrevToken.Value == "=") )
{
switch (PrevToken.Value)
{
case "=": case "!": case ">": case "<":
{
// PrevToken.Value = "==";
if (PrevToken.Value == "=")
PrevToken.Value.Append(Token.Value);
else
PrevToken.Value.Append("=");
PrevToken.Type = ktTokenType.ComparisonOperator;
Prev.Node.Name = PrevToken.Name = ktToken.TokenToString(ktTokenType.ComparisonOperator);
break;
}
case "+": case "-": case "*": case "/": case "%":
case "&": case "|": case "~": case "^":
{
if (PrevToken.Value == "=")
PrevToken.Value.Append(Token.Value);
else
PrevToken.Value.Append("=");
PrevToken.Type = ktTokenType.AssignmentOperator;
Prev.Node.Name = PrevToken.Name = ktToken.TokenToString(ktTokenType.AssignmentOperator);
break;
}
default:
{
throw new ktError("Unknown operator '" + PrevToken.Value + Token.Value +
"' on line " + PrevToken.LineNo.ToString() +
" by character " + PrevToken.CharPos.ToString() + "!",
ktERR.UNKNOWN);
}
}
} else if ( PrevToken.Value == Token.Value )
{
PrevToken.Value.Append(Token.Value);
PrevToken.Type = ktTokenType.Operator;
Prev.Node.Name = PrevToken.Name = ktToken.TokenToString(ktTokenType.Operator);
}
else
{
throw new ktError("Unknown operator '" + PrevToken.Value + Token.Value +
"' on line " + PrevToken.LineNo.ToString() +
" by character " + PrevToken.CharPos.ToString() + "!",
ktERR.UNKNOWN);
}
/*Prev = L.Prev;
Next = L.Next;
HandleSep( Prev, Next, ref Tree, Token );
List.MoveNext();*/
}
else if ((ThirdRun) && (PrevToken.Type == ktTokenType.New))
{
#if ParseDebug2
ktDebug.Log( "NEW_PREV:"+ PrevToken.Value );
ktDebug.Log( "NEW_LLLL:"+ L.Get_R() );
ktDebug.Log( "NEW_NNN:" + ((Next == null) ? "null" : Next.Get_R().ToString()) );
#endif
Tree.Remove((uint)(Tree.Count - 1));
Temp = new ktList();
Temp.Node = new ktNode("ktTNewStatment", PrevToken);
// Temp.AddList( Prev );
Temp.AddList(GetTheRest(List));
Tree.AddList(Temp);
break;
}
else
{
Tree.AddList(new ktList(L));
}
}
//#if ParseDebug2
ktDebug.Log( "+++++++++++++++++++++" + Tree.Get_R( "\t", true ) + "-----------__");
//#endif
if (List == m_LineStack)
{
Tree = MakeATree(Tree, false, false);
}
return Tree;
}
public override ktValue _RunMethod(ktString Name, ktList Arguments)
{
if (Name.IsEmpty())
{
throw new ktError("Didn't get the name of the method to run in class '" +
m_Name + "'.", ktERR.NOTSET);
}
//ktDebug.Log( ";Name::"+ Name + ";;;;_\n" );
if (Name == "_PropertyChanged")
{
if ((Arguments == null) || (Arguments.GetCount() != 2))
{
throw new ktError("kactalk::_PropertyChanged() : Didn't get the two nnede arguments!",
ktERR.MISSING);
}
#if Debug
ktDebug.Log( "Args::" + Arguments.Get_R( "\t", true ) );
#endif
Name = Arguments.Get("Name").Node.Value.ToString();
ktValue Value = (ktValue)Arguments.Get("Value").Node.Value;
SetProperty(Name, Value);
return ktValue.Null;
}
else /*if (Name.StartsWith( "operator", out Name )) {
return HandleOperator( Name, Arguments );
} else */
{
throw new ktError("Couldn't find the method '" +
Name + "' in class '" + m_Name + "'.", ktERR._404);
}
}
protected ktValue HandleList(ktList List)
{
ktValue Value = ktValue.Null;
if (List == null)
{
return Value;
}
#if Debug
ktDebug.Log( "HandleList:::" + List.Get_R() );
#endif
ktClass ListClass = kacTalk.Main.MakeObjectOf("ktList", GetArguments(List));
Value = new ktValue("ktList", "ktList", ListClass, true, true);
#if Debug
ktDebug.Log( "EOHL" );
#endif
return Value;
}
public void Initiate()
{
if (m_Channel == null)
{
throw new ktError("ktTalker::Initiate failed due to the lack of a Channel!");
}
m_AvailableObjects = new ktList();
m_Channel.Initiate( m_URI, m_APIKey );
Console.WriteLine(m_AvailableObjects.Get_R());
}
/// <summary>
/// Add a token to the tokenlist
/// </summary>
protected bool AddToken(ktToken Token)
{
/**/
if (m_Tokens == null)
{
m_Tokens = new ktList();
}
return m_Tokens.Add(Token.Name, Token);
/*/
if (LastBlockLines == null) {
if (LastBlock == null) {
throw new ktError( "No Last Block!", ktERR.MISSING );
}
LastBlock.SetLines( new ktList() );
}
return LastBlockLines.Add( Token.Name, Token );/**/
}
/// <summary>
/// Handle "separators"
/// </summary>
protected void HandleSep(ktList First, ktList Second, ref ktList Tree, ktToken Token)
{
ktDebug.Log("HASEP: T:" + Token.ToString() + "; F:" + First.ToString());
if ((First == null) || (First.Node == null) || (First.Node.Value == null) ||
(Second == null) || (Second.Node == null) || (Second.Node.Value == null))
{
throw new ktError("Unexpected ktTSeparator (" + Token.Value +
") on line " + Token.LineNo.ToString() +
" by character " + Token.CharPos.ToString() + ".",
ktERR.UNEXP);
}
ktList Temp = null;
ktList Last = Tree.Last;
ktToken FirstToken = (ktToken)First.Node.Value;
ktToken SecondToken = (ktToken)Second.Node.Value;
ktToken LastToken = null;
ktDebug.Log( "HASEP:" + SecondToken.ToString() );/*
if ((Token.Value == ":") && (SecondToken.Value == ":") ) {
//T
} else */
//ktDebug.Log( "HASEP:: FT:" + FirstToken.ToString() + "; ST:" + SecondToken.ToString() );
if ( (FirstToken.Type == ktTokenType.Id) &&
( SecondToken.Type == ktTokenType.AssignmentOperator ) &&
( Token.Value == ":" ) ) {
LastToken = new ktToken(ktTokenType.AssignmentOperator, ":=", FirstToken.LineNo, FirstToken.CharPos, ktToken.TokenToString(ktTokenType.AssignmentOperator));
Tree.Remove((uint)(Tree.Count - 1));
Tree.AddList(Temp);
ktDebug.Log("TREE:" + Tree.Get_R("\t", true));
return;
} else if ((FirstToken.Type != ktTokenType.Id) && (FirstToken.Type != ktTokenType.List) &&
(FirstToken.Type != ktTokenType.CompStatement) && (FirstToken.Type != ktTokenType.Boolean) &&
(FirstToken.Type != ktTokenType.Float) && (FirstToken.Type != ktTokenType.Number) &&
(FirstToken.Type != ktTokenType.String) ||
(
(SecondToken.Type != ktTokenType.Id) &&
(SecondToken.Type != ktTokenType.CompStatement) &&
(SecondToken.Type != ktTokenType.Number)
))
{
throw new ktError("Unexpected ktTSeparator (" + Token.Value +
") on line " + Token.LineNo.ToString() +
" by character " + Token.CharPos.ToString() + ".",
ktERR.UNEXP);
}
#if DeepDebug
#if ControlDebug
Console.ReadLine();
#endif
#endif
if ((Last != null) && (Last.Node != null) && (Last.Node.Value != null) &&
(Last.Node.Value.GetType() == typeof(ktToken)))
{
LastToken = (ktToken)Last.Node.Value;
}
//#if ParseDebug2
ktDebug.Log( "FIRST(" + FirstToken.ToString() + "):\n" + First.Get_R( "\t", true ) + "\nSECOND(" + SecondToken.ToString() + "):\n" + Second.Get_R( "\t", true ) );
ktDebug.Log( "TREE:\n" + Tree.Get_R( "\t", true ) );
if (LastToken != null) {
ktDebug.Log( "LAST(" + LastToken.ToString() + "):\n" + Last.Get_R( "\t", true ) );
}
//#endif
if ((FirstToken.Type == ktTokenType.Number) && (SecondToken.Type == ktTokenType.Number))
{
//((ktToken)Tree.Last.Node.Value).Value += "." + SecondToken.Value;
Tree.Remove((uint)(Tree.Count - 1));
FirstToken.Value += "." + SecondToken.Value;
FirstToken.Type = ktTokenType.Float;
FirstToken.Name = "ktTFloat";
Tree.Add(FirstToken);
}
else if ((Last != null) && (LastToken.Type == ktTokenType.CompStatement))
{
Tree.Pop();
Temp = new ktList();
Temp.Node = new ktNode("ktTCompStatement", new ktToken(ktTokenType.CompStatement, Token.Value, Token.LineNo, Token.CharPos));
Temp.AddList(new ktList(Last));
Temp.AddList(new ktList(Second));
#if DeepDebug
ktDebug.Log( "LCT:" + Temp.Get_R( "\t", true ) );
#endif
Tree.AddList(Temp);
}
else
{
Tree.Pop();
Temp = new ktList();
Temp.Node = new ktNode("ktTCompStatement", new ktToken(ktTokenType.CompStatement, Token.Value, Token.LineNo, Token.CharPos));
Temp.AddList(new ktList(First));
Temp.AddList(new ktList(Second));
//#if DeepDebug
ktDebug.Log( "T:" + Temp.Get_R( "\t", true ) );
//#endif
Tree.AddList(Temp);
}
#if DeepDebug
ktDebug.Log( "=========================================" );
#if ControllDebug
Console.ReadLine();
#endif
#endif
}
