public void GetList()
{
String actual = ReservedWord.GetList();
const String Expected = "GR0, GR1, GR2, GR3, GR4, GR5, GR6, GR7";
Assert.AreEqual(Expected, actual, "予約語のリストを取得する");
}
/**
* Constructeur de la classe.
* @param s: Chemin du fichier source à parser.
*/
public Parser(String s, String g)
{
inputPath = s;
grammarPath = g;
ReservedWord.initRW();
SpecialChar.initSC();
Grammar.initGrammar();
}
public override bool Transform(ReservedWord node)
{
if (node.OriginalValue.ToUpper() == "AS")
{
node.Value = string.Empty;
}
return(base.Transform(node));
}
public void AddReservedWord(ReservedWord word)
{
string text = word.text.ToLower();
if (!this.m_mapReservedWord.ContainsKey(text))
{
this.m_mapReservedWord.Add(text, text);
}
}
public override bool ParseDataFromNDT(TsDataReader dr)
{
foreach (TsDataReader.Row data in dr)
{
ReservedWord reservedWord = new ReservedWord();
reservedWord.SetData(data);
NrTSingleton <ReservedWordManager> .Instance.AddReservedWord(reservedWord);
}
return(true);
}
public static void LoadReservedWord([NotNull] ReservedWordAttribute reservedWordAttribute)
{
Assert.ArgumentNotNull(reservedWordAttribute, nameof(reservedWordAttribute));
var reservedWord = new ReservedWord
{
Attribute = reservedWordAttribute
};
reservedWords.Add(reservedWord);
}
void ReadReserved()
{
if (char.IsLetter(this.reader.Current))
{
this.ReadName();
ReservedWord word = ReservedWords.Lookup(this.TokenString);
if (null != word)
{
this.token = word.Token;
this.op = word.Operator;
}
}
}
/// <summary>
/// Método de equals para comparar o valor do ReservedWord com string ou outro ReservedWord
/// </summary>
/// <param name="word"></param>
/// <param name="obj"></param>
/// <returns></returns>
public static bool Equals(ReservedWord word, object obj)
{
if (obj is ReservedWord)
{
ReservedWord comparedWord = (ReservedWord)obj;
return(word.Equals(comparedWord));
}
if (obj is string)
{
string comparedWord = (string)obj;
return(word.ToString().Equals(comparedWord));
}
return(false);
}
public override bool Visit(ReservedWord node)
{
Regex regex = new Regex("^(AS|DESC|ASC)$", RegexOptions.IgnoreCase);
Match m = regex.Match(node.OriginalValue);
if (m.Success)
{
_currentLine = _tabTool.Pad(_currentLine, _LeftIndentSize.Peek());
}
//TODO CASE式のパターン実装が難しいので、ひとまずべた書き
if (node.Value.Equals("CASE", StringComparison.CurrentCultureIgnoreCase))
{
_Indents.Push(_tabTool.Pad(string.Empty, _currentLine.Length + 3));
AddResultSql(node.Value);
}
else if (node.Value.Equals("WHEN", StringComparison.CurrentCultureIgnoreCase) ||
node.Value.Equals("THEN", StringComparison.CurrentCultureIgnoreCase) ||
node.Value.Equals("ELSE", StringComparison.CurrentCultureIgnoreCase))
{
AddNewLineResultSql();
AddResultSql("\t");
AddResultSql(node.Value);
AddNewLineResultSql();
AddResultSql("\t\t\t");
}
else if (node.Value.Equals("END", StringComparison.CurrentCultureIgnoreCase))
{
AddNewLineResultSql();
AddResultSql(node.Value);
_Indents.Pop();
}
else
{
AddResultSql(node.Value);
}
return(base.Visit(node));
}
/// <summary>
/// Método para o não-terminal instrução, dado por:
///"instrução := PRINT listaprint |
/// INPUT var {,var} |
/// LET var = exp |
/// GOTO exp |
/// GOSUB exp |
/// RETURN |
/// IF exp oprel exp THEN exp |
/// REM string |
/// CLEAR |
/// RUN |
/// RUN exp {,exp} |
/// LIST |
/// LIST exp {,exp} "
/// </summary>
/// <param name="feedback"></param>
/// <returns></returns>
private bool Instruction(ref string feedback)
{
bool validation = true;
Token token = Lexic.NextToken();
if (token == null)
{
feedback += INSTRUCTION_INVALID + " , linha: " + line + "\r\n";
return(false);
}
if (token.Type != TokenType.RESERVED_WORD)
{
feedback += INSTRUCTION_INVALID + token.Value + " , linha: " + line + "\r\n";
return(false);
}
ReservedWord reservedWord = ReservedWordUtils.GetReservedEnum(token.Value);
switch (reservedWord)
{
case ReservedWord.PRINT:
{
validation &= PrintList(ref feedback);
break;
}
case ReservedWord.INPUT:
{
token = Lexic.NextToken();
if (token == null)
{
feedback += INCOMPLETE_TENSE_MISS + "variável, linha: " + line + "\r\n";
return(false);
}
if (token.Type != TokenType.VARIABLE)
{
feedback += PARAMETER_INVALID + token.Value + " , linha: " + line + "\r\n";
return(false);
}
while (true)
{
token = Lexic.NextToken();
if (token == null)
{
feedback += INCOMPLETE_TENSE_MISS + "variável, linha: " + line + "\r\n";
break;
}
if (token.Type == TokenType.SEPARATOR)
{
if (token.Value.Equals(","))
{
token = Lexic.NextToken();
if (token == null)
{
feedback += INCOMPLETE_TENSE_MISS + "variável, linha: " + line + "\r\n";
return(false);
}
if (token.Type != TokenType.VARIABLE)
{
feedback += PARAMETER_INVALID + token.Value + " , linha: " + line + "\r\n";
return(false);
}
}
else
{
feedback += SEPARATOR_INVALID + token.Value + " , linha: " + line + "\r\n";
return(false);
}
}
else
{
Lexic.Position--;
break;
}
}
break;
}
case ReservedWord.LET:
{
token = Lexic.NextToken();
if (token == null)
{
feedback += INCOMPLETE_TENSE_MISS + "variável, linha: " + line + "\r\n";
return(false);
}
if (token.Type == TokenType.VARIABLE)
{
token = Lexic.NextToken();
if (token == null)
{
feedback += INCOMPLETE_TENSE_MISS + "=";
return(false);
}
if (token.Type == TokenType.RELATIONAL_OPERATOR && token.Value.Equals("="))
{
validation &= Expression(ref feedback);
}
else
{
feedback += OPERATOR_INVALID + token.Value + " , linha: " + line + "\r\n";;
return(false);
}
}
else
{
feedback += PARAMETER_INVALID + token.Value + " , linha: " + line + "\r\n";
return(false);
}
break;
}
case ReservedWord.GOTO:
{
validation &= Expression(ref feedback);
break;
}
case ReservedWord.GOSUB:
{
//Casos análogos
goto case ReservedWord.GOTO;
}
case ReservedWord.IF:
{
validation &= Expression(ref feedback);
token = Lexic.NextToken();
if (token == null)
{
feedback += INCOMPLETE_TENSE_MISS + "variável, linha: " + line + "\r\n";
return(false);
}
if (token.Type == TokenType.RELATIONAL_OPERATOR)
{
validation &= Expression(ref feedback);
token = Lexic.NextToken();
if (token.Type == TokenType.RESERVED_WORD && token.Value.Equals(ReservedWord.THEN.ToString()))
{
token = Lexic.NextToken();
if (token == null)
{
feedback += INCOMPLETE_TENSE_MISS + "instrução";
return(false);
}
if (token.Type == TokenType.RESERVED_WORD && !token.Value.Equals(ReservedWord.RND.ToString()))
{
//Retorna uma posição
Lexic.Position--;
validation &= Instruction(ref feedback);
}
else
{
Lexic.Position--;
validation &= Expression(ref feedback);
}
}
else
{
feedback += INCOMPLETE_TENSE_MISS + ReservedWord.THEN.ToString() + INCOMPLETE_TENSE_FOUND + token.Value;
return(false);
}
}
else
{
feedback += OPERATOR_INVALID + token.Value;
return(false);
}
break;
}
case ReservedWord.REM:
{
token = Lexic.NextToken();
if (token.Type != TokenType.STRING)
{
feedback += PARAMETER_INVALID + token.Value + " , linha: " + line + "\r\n";
return(false);
}
break;
}
case ReservedWord.RUN:
{
validation &= Expression(ref feedback);
//Talvez se a gente deixar passar aqui, deixando o validation sempre true, ele servirá para os casos
//onde o RUN e o LIST são chamados sem parâmetro
while (true)
{
token = Lexic.NextToken();
if (token == null)
{
break;
}
if (token.Type == TokenType.SEPARATOR)
{
if (token.Value.Equals(","))
{
validation &= Expression(ref feedback);
}
else
{
feedback += SEPARATOR_INVALID + token.Value + " , linha: " + line + "\r\n";
return(false);
}
}
else
{
Lexic.Position--;
break;
}
}
break;
}
case ReservedWord.LIST:
{
//Casos análogos
goto case ReservedWord.RUN;
}
case ReservedWord.RETURN:
break;
case ReservedWord.CLEAR:
break;
case ReservedWord.THEN: return(false);
case ReservedWord.RND: return(false);
case ReservedWord.INVALID: return(false);
}
return(validation);
}
public virtual bool Visit(ReservedWord node)
{
return(true);
}
public override bool Transform(ReservedWord node)
{
node.Value = CaseFormatUtils.Convert(_entity.ReservedWordCase, node.Value);
return(base.Transform(node));
}
public virtual bool Transform(ReservedWord node)
{
return(true);
}
static int Compare(ReservedWord reserved1, ReservedWord reserved2)
{
return(string.Compare(reserved1.Word, reserved2.Word, false, CultureInfo.InvariantCulture));
}
private void CheckIsReserved(String str, Boolean expected, String message)
{
Boolean actual = ReservedWord.IsReserved(str);
Assert.AreEqual(expected, actual, message);
}
