/// <summary>
/// Scan/Parse the script into tokens
/// </summary>
public bool Scan(ktString Script, ktString Name)
{
bool Ret = true;
Script.Replace("\r\n", "\n",true);
// Initiate the lineno.
m_CurLine = 1;
m_CharPos = 1;
// .. and name
m_Name = Name;
if (m_Tokens != null)
{
m_Tokens.Clear();
m_Tokens = null;
}
// Init...
ktString Line = new ktString();
int Pos = 0;
Script.Trim();
ktRegEx RE = new ktRegEx(ktToken.Separators);
// ... the block-stack
if (m_BlockStack != null)
{
m_BlockStack.Clear();
m_BlockStack = null;
}
m_BlockStack = new ktList();
// ... the token-list
if (m_Tokens != null)
{
m_Tokens.Clear();
m_Tokens = null;
}
m_Tokens = new ktList();
m_Tokens.Node = new ktNode("ktTStatement", new ktToken(ktTokenType.Statement, "", 0, 0));
// ... the token-stack
if (m_TokenStack != null)
{
m_TokenStack.Clear();
m_TokenStack = null;
}
m_TokenStack = new ktList();
// ... the lines (??)
if (m_Lines != null)
{
m_Lines.Clear();
m_Lines = null;
}
m_Lines = new ktList();
m_Lines.Node = new ktNode(Name, m_CurToken = new ktToken(ktTokenType.Program, Name, 0, 0));
// ... the line-stack
if (m_LineStack != null)
{
m_LineStack.Clear();
m_LineStack = null;
}
m_LineStack = new ktList();
if (m_MainBlock == null)
{
m_MainBlock = new ktBlock(new ktList());
}
else
{
if (m_MainBlock.Lines != null)
{
m_MainBlock.Lines.Clear();
}
m_MainBlock.ClearKTSymbols();
}
m_MainBlock.SetMain(this);
m_BlockStack.Add("ktTBlock", m_MainBlock);
/* In the "original scanner" (C++), we took one line (terminated by \n)
* at a time and worked on, now we just go through the line.
* And We hope that it will be much "leaner"!
*/
// Go on until the there's nothing left...
while (!Script.IsEmpty())
{
// Get the position for the next separator
Pos = RE.Find(Script);
// If there was none...
if (Pos < 0)
{
// Take it to the end...
Pos = Script.Len();
}
else if (Pos == 0)
{
Pos++;
}
// Get the next "token"
Line = Script.SubStr(0, Pos);
// If it's the start of a comment
if ((Line == "/") && (Script.StartsWith("//") || Script.StartsWith("/*")))
{
Line = Script.SubStr(0, 2);
Pos++;
}
else if ((Line == "*") && (Script.StartsWith("*/")))
{
Line = "*/";
Pos++;
}
ReactOnToken(Line, m_CurLine, ref m_CharPos);
if (Line == "\n")
{
m_CurLine++;
m_CharPos = 1;
}
else
{
m_CharPos += Line.Len();
}
// Remove the "token", we just worked on...
Script.Remove(0, Pos);
}
#if ParseDebug || DebugXML
ktDebug.Log("XML111111:");
ktDebug.Log(ktXML.FromList(m_TokenStack).AsXML());
ktDebug.Log("==================");
ktDebug.Log(ktXML.FromList(m_Tokens).AsXML());
#endif
if (!m_Tokens.IsEmpty())
{
if (m_AllowMissingEOL)
{
((ktToken)m_Tokens.Node.Value).Type = ktTokenType.Line;
((ktToken)m_Tokens.Node.Value).Name = m_Tokens.Node.Name = "ktTLine";
m_LineStack.AddList(m_Tokens);
m_Tokens = null;
}
else
{
throw new ktError("Expected a ktTEOL at line " + m_CurLine.ToString() + " but didn't find one!",
ktERR.MISSING);
}
}
if (m_BlockStack.Count > 1)
{
throw new ktError("Expecting ktTEOB (}) at " + m_CharPos.ToString() + ", line " +
m_CurLine.ToString() + ".", ktERR.MISSING);
}
//ktToken.OnlyExportValue = false;
//ktDebug.Log( m_LineStack.Get_R( ) );
//ktToken.OnlyExportValue = false;
#if ParseDebug || DebugXML
ktDebug.Log( "XML:" );
ktDebug.Log( ktXML.FromList(m_LineStack).AsXML() );
ktDebug.Log( "==================" );
ktDebug.Log( ktXML.FromList(m_Lines).AsXML() );
#endif
/* ktDebug.Log( "?+++++\n" + m_Tokens.Get_R( "\t", true ) );
ktDebug.Log( "?+++++\n" + m_CurToken.Export
if (m_CurToken != null) {
if (m_CurToken.Type == ktTokenType.List) {
throw new ktError( "Expected a ktTEndPar at line " + m_CurLine.ToString() + " but didn't find one!",
ktERR.MISSING );
} else if (m_CurToken.Type == ktTokenType.String) {
throw new ktError( "Expected a ktTStringQuot at line " + m_CurLine.ToString() + " but didn't find one!",
ktERR.MISSING );
} else if (m_CurToken.Type == ktTokenType.Block) {
throw new ktError( "Expected a ktTEndOfBlock at line " + m_CurLine.ToString() + " but didn't find one!",
ktERR.MISSING );
}
} else if ((m_Tokens != null) && (!m_Tokens.IsEmpty())) {
throw new ktError( "Expected a ktTEOL at line " + m_CurLine.ToString() + " but didn't find one!",
ktERR.MISSING );
}
*/
// MakeATree( );
// MakeAOpTree( );
if ((m_BlockStack == null) || (m_BlockStack.IsEmpty()))
{
return Ret;
}
ktBlock Block = (ktBlock)(m_BlockStack.Pop().Node.Value);
#if ParseDebug
ktDebug.Log( "BLOCK1:" + ktXML.FromList(Block.Lines).AsXML() );r
#endif
MakeATree();
#if ParseDebug
ktDebug.Log("BLOCK2:" + ktXML.FromList(m_Lines).AsXML());
#endif
Block.Lines = MakeAOpTree();
m_LineStack.Clear();
m_LineStack = null;
// Add Current "statement"/"post" to the block and theń switch them
//Temp.AddList( m_Tokens );
//m_Tokens = Temp;
#if ParseDebug
ktDebug.Log( "BLOCK:" + ((Block == m_MainBlock) ? "MAIN":"NOT_MAIN") );
#endif
/*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 ) );*/
#if ParseDebug || DebugXML
ktDebug.Log( "XML_After Tree:" + ktXML.FromList(Block.Lines).AsXML() );
ktDebug.Log( "XML_After Tree:" + Block.Lines.Get_R( "\t", true ) );
#endif
//ktDebug.Log( m_Lines.Export() );
return Ret;
}
/// <summary>
/// Handle a operator in the tree
/// </summary>
private bool HandleOperator(ktToken PrevToken, ktList Prev, ktToken Token, ktList L, ref ktList Tree,
int RunNumb, out bool SkipNext, bool OneSided = false )
{
ktList Next = null;
ktList Temp = null;
SkipNext = false;
// Create a new "subtree"(/operator) and assign appropriate data
Temp = new ktList();
Temp.Node = L.Node;
((ktToken)Temp.Node.Value).RunnedStep = RunNumb;
// If the left part of the "operator tree" hasn't been parsed on this level ...
if (PrevToken.RunnedStep < RunNumb)
{
// ... parse it!
Prev = MakeAOpTree(Prev, RunNumb);
}
else
{
Prev = new ktList(Prev);
}
// Add the first part to the op tree
Temp.AddList(Prev);
// Is it a operator with two "sides"
if (!OneSided)
{
// Parse the right part of the "operator tree"
Next = MakeAOpTree(L.Next, RunNumb);
// And add it to the op tree
Temp.AddList(Next);
SkipNext = true;
}
/*ktDebug.Log("HO: Temp:\n" + Temp.Get_R());
ktDebug.Log("HO: Tree:\n" + Tree.Get_R());*/
// Remove the last leaf(/item) in the tree (it will now become a leaf under this operator)
Tree.Pop(false); // .Pop() is more efficient than .Remove() and 'false' as an argument means that it will "fail" gracefully in the event of an empty list!
//ktDebug.Log("HO: TreeP:\n" + Tree.Get_R());
// Add the new subtree/operator to the main tree
Tree.AddList(Temp);
//ktDebug.Log("HO: TreeA:\n" + Tree.Get_R());
// Hey! That went well!
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;
}
private bool HandleAssignmentOperator(ktToken PrevToken, ktList Prev, ktToken Token, ktList L, ref ktList Tree, ref ktList List, out bool SkipNext, out bool ReturnTree)
{
ktList Next = null;
ktList Temp = null;
SkipNext = false;
ReturnTree = false;
/*ktDebug.Log("Tree::\n" + Tree.Get_R());
ktDebug.Log("Prev: T:\n" + Prev.Node.Value.ToString());
ktDebug.Log("Prev::\n" + Prev.Get_R());*/
// Remove the last leaf(/item) in the tree (it will now become a leaf under this operator)
Tree.Pop(false); // .Pop() is more efficient than .Remove() and 'false' as an argument means that it will "fail" gracefully in the event of an empty list!
// Take a step forward
List.MoveNext();
// If the previous token has childs
if (Prev.Count > 0) {
if ( (((ktToken)Prev.First.Node.Value).Type == ktTokenType.Id) &&
(Prev.First.Next != null) &&
(((ktToken)Prev.First.Next.Node.Value).Type == ktTokenType.Id)
)
{
Prev.Node = new ktNode("ktTVarStatement", new ktToken(ktTokenType.VarStatement, "", ((ktToken)Prev.Node.Value).LineNo, ((ktToken)Prev.Node.Value).CharPos)); ;
}
else
{
// Parse the left part of the op tree
Prev = MakeAOpTree(Prev, 1);
}
}
// Get the right part of the op tree
Next = GetTheRest(List);
// Parse the right part of the tree
Next = MakeAOpTree(Next, 1);
// Create a new "subtree"(/operator) and assign appropriate data
Temp = new ktList();
Temp.Node = L.Node;
((ktToken)Temp.Node.Value).RunnedStep = 1;
// Add the parts of op tree
Temp.AddList(Prev);
Temp.AddList(Next);
// Add the operator to the tree
Tree.AddList(Temp);
// ktDebug.Log("Tree::\n" + Tree.Get_R());
ktDebug.WrapLevel--;
ReturnTree = true;
// Hey! That went well!
return true;
}
/// <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;
}
