public LexTree(eLex _token, string _text)
{
Text = _text;
Token = _token;
Name = "";
anon = false;
}
private void DoPassThree(List <LexTree> _tokenlist, int _count)
{
for (int i = 0; i < _tokenlist.Count; i++)
{
LexTree lexTree = _tokenlist[i];
eLex eLex = eLex.None;
if (i + 1 < _tokenlist.Count)
{
eLex = _tokenlist[i + 1].Token;
}
if (_count == 0 && lexTree.Node != null)
{
i = RemoveFunctions(_tokenlist, i, _count);
}
if (lexTree.Token == eLex.SemiColon && eLex == eLex.RCB)
{
_tokenlist.RemoveRange(i, 1);
i--;
}
if (lexTree.Children != null)
{
DoPassThree(lexTree.Children, _count + 1);
}
}
}
public void AddCommand(string _cmd, eLex _token)
{
eLex value;
if (!m_CommandLookup.TryGetValue(_cmd, out value))
{
m_CommandLookup.Add(_cmd, _token);
}
}
public eLex yylex()
{
if (m_Tail != m_Head)
{
m_Tail++;
if (m_Tail == 100)
{
m_Tail = 0;
}
return(m_LexToken[m_Tail]);
}
while (m_Index < m_Text.Length)
{
char c = NextChar();
eLex eLex = eLex.ID;
if (c >= '\0' && c <= 'ÿ')
{
eLex = m_TokenLookup[c];
}
switch (eLex)
{
case eLex.WhiteSpace:
continue;
case eLex.Divide:
return(CheckForComments());
case eLex.None:
return(ReadID());
case eLex.Quotes:
return(ReadString1());
case eLex.SingleQuotes:
return(ReadString2());
case eLex.Decimal:
return(ReadDec());
}
if (m_SymbolLookup1[c] != 0)
{
return(MultiReadToken(c, eLex));
}
EnqueueLex(eLex, new string(new char[1]
{
c
}), 0.0);
return(eLex);
}
EnqueueLex(GMAssetCompiler.eLex.EOF, null, 0.0);
return(GMAssetCompiler.eLex.EOF);
}
public void EnqueueLex(eLex _token, string _text, double _value)
{
m_Head++;
if (m_Head == 100)
{
m_Head = 0;
}
m_Tail++;
if (m_Tail == 100)
{
m_Tail = 0;
}
m_LexToken[m_Head] = _token;
m_LexText[m_Head] = _text;
m_LexValue[m_Head] = _value;
}
public eLex MultiReadToken(char _c, eLex _token)
{
if (m_Index < m_Text.Length)
{
char c = NextChar();
eLex eLex = m_SymbolLookup2[c];
if (eLex != 0)
{
EnqueueLex(eLex, new string(new char[2]
{
_c,
c
}), 0.0);
return(eLex);
}
m_Index--;
}
EnqueueLex(_token, new string(new char[1]
{
_c
}), 0.0);
return(_token);
}
public void AddSymbol(string _s, eLex _token)
{
m_SymbolLookup1[_s[0]] = m_TokenLookup[_s[0]];
m_SymbolLookup2[_s[1]] = _token;
}
private eLex CheckForComments()
{
m_Index--;
if (m_Index < m_Text.Length)
{
char c = NextChar();
char c2 = NextChar();
eLex eLex = m_TokenLookup[c];
eLex eLex2 = m_TokenLookup[c2];
if (eLex == eLex.Divide && eLex2 == eLex.Divide)
{
while (m_Index < m_Text.Length)
{
c = NextChar();
eLex = eLex.ID;
if (c >= '\0' && c <= 'ÿ')
{
eLex = m_TokenLookup[c];
}
if (eLex == eLex.EOF || eLex == eLex.NewLine)
{
c = NextChar();
if (eLex != eLex.EOF && eLex != eLex.NewLine)
{
m_Index--;
}
break;
}
}
return(eLex.Comment);
}
if (eLex == eLex.Divide && eLex2 == eLex.Star)
{
int num = 1;
while (m_Index < m_Text.Length)
{
c = NextChar();
c2 = NextChar();
eLex = eLex.ID;
eLex2 = eLex.ID;
if (c >= '\0' && c <= 'ÿ')
{
eLex = m_TokenLookup[c];
}
if (c2 >= '\0' && c2 <= 'ÿ')
{
eLex2 = m_TokenLookup[c2];
}
if (eLex == eLex.Divide && eLex2 == eLex.Star)
{
num++;
}
if (eLex == eLex.Star && eLex2 == eLex.Divide)
{
num--;
if (num == 0)
{
break;
}
}
m_Index--;
}
return(eLex.Comment);
}
m_Index--;
EnqueueLex(eLex.Divide, "/", 0.0);
return(eLex.Divide);
}
return(GMAssetCompiler.eLex.Divide);
}
public void WriteNodeList(List <LexTree> _nodelist, StreamWriter oFile)
{
int i = 0;
LexTree lexTree = new LexTree(eLex.None, " ");
for (; i < _nodelist.Count; i++)
{
LexTree lexTree2 = _nodelist[i];
GMAssetCompiler.eLex eLexVar = lexTree2.Token;
if (PrettyPrint)
{
if (eLexVar != eLex.NewLine && eLexVar != eLex.Comment)
{
if (m_WriteSpace && eLexVar != eLex.LeftBracket && eLexVar != eLex.SemiColon)
{
oFile.Write(" ");
}
m_WriteSpace = false;
if (eLexVar == eLex.reserved3)
{
oFile.Write(" ");
eLexVar = eLex.reserved2;
}
if (eLexVar == eLex.reserved2 && lexTree2.Text == "function" && lexTree.Text != "return")
{
oFile.WriteLine();
}
if (eLexVar == eLex.LCB)
{
oFile.WriteLine();
for (int j = 0; j < m_tabcount; j++)
{
oFile.Write('\t');
}
}
if (eLexVar == eLex.RCB)
{
m_tabcount--;
m_WriteTabs = m_tabcount;
}
if (m_WriteTabs > 0)
{
for (int k = 0; k < m_WriteTabs; k++)
{
oFile.Write('\t');
}
m_WriteTabs = 0;
}
oFile.Write(lexTree2.Text);
if (lexTree2.Text == "for" || lexTree2.Text == "while")
{
bool flag = false;
int num = 0;
while (!flag && i < _nodelist.Count)
{
i++;
LexTree lexTree3 = _nodelist[i];
eLex token = lexTree3.Token;
if (token == eLex.LeftBracket)
{
num++;
}
if (token == eLex.RightBracket)
{
num--;
if (num == 0)
{
flag = true;
}
}
if (token == eLex.reserved3)
{
oFile.Write(" ");
}
oFile.Write(lexTree3.Text);
if (token == eLex.reserved3 || token == eLex.reserved2)
{
oFile.Write(" ");
}
}
}
if (eLexVar == eLex.SemiColon || eLexVar == eLex.LCB || eLexVar == eLex.RCB)
{
if (eLexVar == eLex.LCB)
{
m_tabcount++;
}
oFile.WriteLine();
m_WriteTabs = m_tabcount;
}
}
if (eLexVar == eLex.reserved2)
{
m_WriteSpace = true;
}
}
else
{
if (m_WriteSpace && eLexVar != eLex.LeftBracket && eLexVar != eLex.SemiColon)
{
oFile.Write(" ");
}
m_WriteSpace = false;
if (eLexVar == eLex.reserved3)
{
oFile.Write(" ");
eLexVar = eLex.reserved2;
}
if (eLexVar != eLex.NewLine && eLexVar != eLex.Comment && lexTree2.Text != null)
{
oFile.Write(lexTree2.Text);
m_LineWidth += lexTree2.Text.Length;
}
if (eLexVar == eLex.reserved2)
{
m_WriteSpace = true;
}
if (m_LineWidth >= UglyWidth)
{
bool flag2 = true;
if (eLexVar != eLex.SemiColon && eLexVar != eLex.Comma && eLexVar != eLex.RCB && eLexVar != eLex.LCB)
{
flag2 = false;
}
if (flag2)
{
m_LineWidth = 0;
oFile.WriteLine();
m_WriteSpace = false;
}
}
}
lexTree = _nodelist[i];
if (lexTree2.Node != null && lexTree2.Children != null)
{
WriteNodeList(lexTree2.Children, oFile);
}
}
}
