//GET CTRS
private int GetCtr(string txt)
{
LexicalConstants.ReservedWordsDelim rwd = new LexicalConstants.ReservedWordsDelim();
Boolean ifEnd = false;
int ctr = 0;
foreach (var item in rwd.whitespace)
{
if (txt.ElementAt(ctr) == item)
{
ifEnd = true;
}
}
while (ifEnd != true)
{
foreach (var item in rwd.whitespace)
{
if ((txt.Length) > ctr)
{
if (txt.ElementAt(ctr) == item)
{
ifEnd = true;
break;
}
}
else
{
ifEnd = true;
}
}
if (ifEnd != true)
{
ctr++;
}
}
if (!(txt.Length >= ctr))
{
ctr--;
}
return(ctr);
}
public Boolean ReservedWords(string txt)
{
LexicalConstants.ReservedWords resWord = new LexicalConstants.ReservedWords();
LexicalConstants.ReservedWordsDelim resWordDelim = new LexicalConstants.ReservedWordsDelim();
Tokens token = new Tokens();
List <string> words = new List <string>();
List <char> delims = new List <char>();
List <string> temp = new List <string>();
Boolean hasReservedWord = false, hasToken = false, exit = false;
int limit = 0, flag = -1, ctr = 0;
string wordComp;
// Gets the size of the entered word
// Separate it from other words
for (int a = 0; a < txt.Length; a++)
{
foreach (char end in resWordDelim.rw_ender)
{
if (end == txt.ElementAt(a))
{
if (a == 0)
{
if (txt.ElementAt(a) == '!')
{
break;
}
}
if (a == 3)
{
if (txt.ElementAt(0) == 'E' && txt.ElementAt(1) == 'N' && txt.ElementAt(2) == 'D' && txt.ElementAt(a) == '!')
{
break;
}
}
hasToken = true;
}
}
if (hasToken == true)
{
break;
}
flag++;
}
hasToken = false;
for (int i = 0; i < 6; i++)
{
ctr = 0;
switch (i)
{
case 0:
words = resWord.rw_whitespace;
delims = resWordDelim.whitespace;
break;
case 1:
words = resWord.rw_1;
delims = resWordDelim.delim_1;
break;
case 2:
words = resWord.rw_2;
delims = resWordDelim.delim_2;
break;
case 3:
words = resWord.rw_3;
delims = resWordDelim.delim_3;
break;
case 4:
words = resWord.rw_4;
delims = resWordDelim.delim_4;
break;
case 5:
words = resWord.rw_boolean;
delims = resWordDelim.delim_boolean;
break;
default:
break;
}
foreach (char t in txt)
{
hasReservedWord = false;
limit = words.Count - 1;
foreach (string word in words.ToList())
{
if ((word.Length - 1) >= ctr)
{
if (t == word.ElementAt(ctr))
{
hasReservedWord = true;
if (word.Length == flag + 1)
{
if ((flag) == ctr)
{
wordComp = txt.Substring(0, ctr + 1);
if (word == wordComp)
{
foreach (char delim in delims)
{
if ((txt.Length - 1) > ctr)
{
if (txt[flag + 1] == delim)
{
hasToken = true;
if ((word == "true") || (word == "false"))
{
token.setTokens("booleanlit");
}
else
{
token.setTokens(word);
}
token.setLexemes(word);
token.setDescription(word);
tokens.Add(token);
}
}
else if (word == words[limit] && hasToken == false)
{
hasReservedWord = false;
}
else if (hasToken)
{
break;
}
}
if (hasToken == false)
{
hasToken = true;
hasReservedWord = true;
token.setTokens("No Delimiter");
token.setLexemes(word);
token.setDescription(word);
tokens.Add(token);
break;
}
if (hasToken)
{
break;
}
}
}
else
{
temp.Add(word);
}
}
}
}
}
ctr++;
words = temp;
if (!hasReservedWord)
{
break;
}
if (hasToken)
{
exit = true;
break;
}
}
if (exit)
{
break;
}
}
ctra = ctr;
return(hasToken);
}
public Boolean ReservedSymbols(string txt)
{
LexicalConstants.ReservedWordsDelim resWordDelim = new LexicalConstants.ReservedWordsDelim();
LexicalConstants.ReservedSymbols resSym = new LexicalConstants.ReservedSymbols();
LexicalConstants.ReservedSymbolsDelims resSymDelim = new LexicalConstants.ReservedSymbolsDelims();
Tokens token = new Tokens();
List <string> sym = new List <string>();
List <char> delims = new List <char>();
List <string> temp = new List <string>();
Boolean hasReservedSymbol, hasToken = false, exit = false;
int flag = -1, limit, ctr = 0;
for (int a = 0; a < txt.Length; a++)
{
foreach (char end in resSymDelim.rs_ender)
{
if (end == txt.ElementAt(a))
{
hasToken = true;
}
}
if (hasToken)
{
break;
}
flag++;
}
if (flag < 0)
{
foreach (char one in resSymDelim.rs_one)
{
if (txt.ElementAt(0) == one)
{
flag++;
break;
}
}
}
if (txt.Length > 1)
{
if (flag == 0)
{
if (txt.ElementAt(1) == '=')
{
foreach (char repeat in resSymDelim.rs_repeat)
{
if (txt.ElementAt(0) == repeat)
{
flag++;
break;
}
}
}
else if (txt.ElementAt(1) == '+')
{
if (txt.ElementAt(0) == '+')
{
flag++;
}
}
if (txt.ElementAt(1) == '-')
{
if (txt.ElementAt(0) == '-')
{
flag++;
}
}
}
}
hasToken = false;
for (int i = 0; i < 13; i++)
{
ctr = 0;
switch (i)
{
case 0:
sym = resSym.rs_2;
delims = resWordDelim.delim_2;
break;
case 1:
sym = resSym.rs_5;
delims = resSymDelim.delim_5;
break;
case 2:
sym = resSym.rs_7;
delims = resSymDelim.delim_7;
break;
case 3:
sym = resSym.rs_8;
delims = resSymDelim.delim_8;
break;
case 4:
sym = resSym.rs_9;
delims = resSymDelim.delim_9;
break;
case 5:
sym = resSym.rs_whitespace;
delims = resWordDelim.whitespace;
break;
case 6:
sym = resSym.rs_arithop;
delims = resSymDelim.delim_arithop;
break;
case 7:
sym = resSym.rs_incop;
delims = resSymDelim.delim_incop;
break;
case 8:
sym = resSym.rs_lower;
delims = resSymDelim.delim_lower;
break;
case 9:
sym = resSym.rs_11;
delims = resSymDelim.delim_11;
break;
case 10:
sym = resSym.rs_12;
delims = resSymDelim.delim_12;
break;
case 11:
sym = resSym.rs_13;
delims = resSymDelim.delim_13;
break;
case 12:
sym = resSym.rs_14;
delims = resSymDelim.delim_14;
break;
default:
break;
}
foreach (char t in txt)
{
hasReservedSymbol = false;
limit = sym.Count - 1;
foreach (string symbol in sym.ToList())
{
if ((symbol.Length - 1) >= ctr)
{
if (t == symbol.ElementAt(ctr))
{
hasReservedSymbol = true;
if (symbol.Length == (flag + 1))
{
if (flag == ctr)
{
foreach (char delim in delims)
{
if ((txt.Length - 1) > ctr)
{
if (txt[flag + 1] == delim)
{
hasToken = true;
token.setTokens(symbol);
token.setLexemes(symbol);
token.setDescription(symbol);
tokens.Add(token);
}
}
else if (symbol == sym[limit] && hasToken == false)
{
hasReservedSymbol = false;
}
else if (hasToken)
{
break;
}
}
}
else
{
temp.Add(symbol);
}
}
}
}
}
ctr++;
sym = temp;
if (!hasReservedSymbol)
{
break;
}
if (hasToken)
{
exit = true;
break;
}
}
if (exit)
{
break;
}
}
ctra = ctr;
return(hasToken);
}
