//GET TOKENS
public Boolean GetReservedWords(string txt)
{
LexicalConstants.ReservedWordsDelims rwd = new LexicalConstants.ReservedWordsDelims();
LexicalConstants.ReservedWords rw = new LexicalConstants.ReservedWords();
Tokens t = new Tokens();
List <String> words;
List <char> delims;
List <String> temp;
Boolean found = false, hastoken = false, exitfor = false, ifEnd = false, nodelim = true;
int tempctr = 0, limit = 0;
//rwd = td.AddRange(rwd);
if (txt.Length != 1)
{
Boolean iscomment = false;
Boolean foundComment = false;
int commentctr = 0;
while ((txt.Length - 1) > tempctr && !isEnd(txt[tempctr + 1], rwd) && !foundComment)
{
tempctr++;
if (commentctr == 0 && txt.ElementAt(0) == 'P')
{
iscomment = true;
commentctr++;
}
else if (iscomment && commentctr == 1 && txt.ElementAt(1) == 'S')
{
iscomment = true;
commentctr++;
tempctr = 1;
foundComment = true;
}
}
tempctr++;
}
for (int i = 0; i < 7; i++)
{
ctr = 0;
words = new List <String>();
delims = new List <char>();
found = true;
switch (i)
{
case 0:
words = rw.rw_whitespace;
delims = rwd.whitespace;
break;
case 1:
words = rw.rw_1;
delims = rwd.delim_1;
break;
case 2:
words = rw.rw_2;
delims = rwd.delim_2;
break;
case 3:
words = rw.rw_3;
delims = rwd.delim_3;
break;
case 4:
words = rw.rw_dtype;
delims = rwd.delim_dtype;
break;
case 5:
words = rw.rw_bool;
delims = rwd.delim_bool;
break;
case 6:
words.Add("PS");
break;
}
//Check Reserved Words
foreach (char c in txt)
{
limit = words.Count - 1;
temp = new List <string>();
found = false;
foreach (string w in words)
{
//IF NOT OUT OF RANGE
if ((w.Length - 1) >= ctr)
{
//IF LETTER MATCHED
if (c == w.ElementAt(ctr))
{
found = true;
//CHECK SIZE OF WORD AND INPUT
if (w.Length == tempctr)
{
//CHECK DELIMITER
if ((tempctr - 1) == ctr)
{
if (i != 6)
{
foreach (char delim in delims)
{
//IF NOT OUT OF RANGE
if ((txt.Length - 1) > ctr)
{
//IF FOUND DELIMITER
if (txt[ctr + 1] == delim)
{
hastoken = true;
nodelim = false;
if (w == "Yes" || w == "No")
{
t.setTokens("boollit");
}
else
{
t.setTokens(w);
}
t.setLexemes(w);
t.setAttributes(w);
token.Add(t);
valid++;
break;
}
}
else if (w == words[limit] && hastoken == false)
{
found = false;
}
}
if (hastoken == false)
{
hastoken = true;
nodelim = false;
found = true;
t.setTokens("NODELIM");
t.setLexemes(w);
t.setAttributes(w);
token.Add(t);
invalid++;
}
else if (nodelim)
{
hastoken = true;
found = true;
t.setTokens("INVALID");
t.setLexemes(w);
t.setAttributes(w);
token.Add(t);
invalid++;
break;
}
if (hastoken)
{
break;
}
}
//IF COMMENT
else
{
Boolean endcomment = false;
while (!endcomment)
{
if ((txt.Length - 1) > ctr)
{
//IF FOUND NEWLINE
if (txt[ctr + 1] == '\n')
{
hastoken = true;
nodelim = false;
endcomment = true;
}
}
else
{
hastoken = true;
endcomment = true;
}
if (!endcomment)
{
ctr++;
}
}
if (hastoken)
{
break;
}
lines++;
}
}
else
{
temp.Add(w);
}
}
}
}
}
ctr++;
words = temp;
if (found == false)
{
break;
}
if (hastoken)
{
exitfor = true;
break;
}
}
if (exitfor)
{
exitfor = false;
break;
}
}
//IF NOTHING FOUND
if (found == false)
{
hastoken = false;
foreach (var item in rwd.delim_end)
{
if (txt.ElementAt(ctr - 1) == item)
{
ifEnd = true;
}
}
while (ifEnd != true)
{
foreach (var item in rwd.delim_end)
{
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(hastoken);
}
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);
}
