public override string ToString()
{
if (Function is ArithmeticBinaryFunction)
{
return($"{LeftBracket.GetInstance()}{_terms[0]}{Function}{_terms[1]}{RightBracket.GetInstance()}");
}
return($"{Function}{LeftBracket.GetInstance()}{string.Join<Term>(Comma.GetInstance().ToString(), _terms)}{RightBracket.GetInstance()}");
}
/// <summary>
/// Check existence of referenced Column(s) and convert to 'legal' Statement
/// </summary>
/// <example>CheckStatement(DataTable, "Column1Exists = Red, Column2NotExists = £$"$""!!, Column3Exists = 5);</example>
/// <param name="table"></param>
/// <param name="statement"></param>
/// <param name="checktype"></param>
/// <returns></returns>
private static string CheckStatement(DataTable table, string statement, StatementType checktype)
{
// Initialise ..
const char Quote = '\'';
const char Comma = ',';
const char Equals = '=';
const string And = " and ";
string statementFinal = string.Empty;
// Set appropriate statement connector ..
string connector = string.Empty;
switch (checktype)
{
case StatementType.Set:
connector = Comma.ToString();
break;
case StatementType.Where:
connector = And;
break;
default:
connector = Comma.ToString();
break;
}
// Decompose multiple assignments into column(s) and value(s) ..
string[] assignments = statement.Split(Comma);
for (int assignmentIndex = 0; assignmentIndex < assignments.Length; assignmentIndex++)
{
string assignment = assignments[assignmentIndex].Trim();
string[] columnAndvalue = assignment.Split(Equals);
// Decompose further if assignment statement is valid ..
if (columnAndvalue.Length == 2)
{
string columnName = columnAndvalue[0].Trim();
string columnValue = columnAndvalue[1].Trim();
//Check column exists in DataTable ..
if (IsColumn(table, columnName))
{
// .. and get its datatype ..
if (GetType(table, columnName) == typeof(string))
{
columnValue = Quote + columnValue + Quote;
}
// Construct final set statement ...
statementFinal += columnName + Equals + columnValue + connector;
}
}
}
// Remove extra connector ..
return(statementFinal.Substring(0, statementFinal.Length - connector.ToString().Length));
}
public override string ToString()
{
if (Predicate is ArithmeticPredicate)
{
return($"{LeftBracket.GetInstance()}{_terms[0]}{Predicate}{_terms[1]}{RightBracket.GetInstance()}");
}
return($"{Predicate}{LeftBracket.GetInstance()}{string.Join<Term>(Comma.GetInstance().ToString(), _terms)}{RightBracket.GetInstance()}");
}
public static void RemoveExtraComma()
{
var first = new Comma();
var secondB = new ClosingBracket();
var secondT = new ClosingThread();
for (var i = 0; i < TokenzedProgram.Count - 2; i++)
{
if (TokenzedProgram[i].GetKeyWordName() == first.KeyWordName() &&
(TokenzedProgram[i + 1].GetKeyWordName() == secondB.KeyWordName() ||
TokenzedProgram[i + 1].GetKeyWordName() == secondT.KeyWordName()))
{
TokenzedProgram.RemoveAt(i);
}
}
}
private static void CheckOrder(Symbol left, Symbol right)
{
var err = left switch
{
Comma _ => (right is Comma),
ArithmeticBinaryFunction _ => (right is ArithmeticBinaryFunction),
ArithmeticPredicate _ => (right is ArithmeticPredicate),
ObjectVariable _ => (right is ObjectVariable),
IndividualConstant <BigInteger> _ => (right is IndividualConstant <BigInteger>),
Quantifier _ => (right is Quantifier),
BinaryPropositionalConnective _ => (right is BinaryPropositionalConnective),
_ => false
};
if (err)
{
throw new ArgumentException($"symbols {left} and {right} cannot be placed side by side");
}
}
private static NextToken ReadToken(this IEnumerable <CodeCharacter> code)
{
code = code.SkipWhile(c => c.IsWhitespace);
if (!code.Any())
{
var token = new EndOfFile();
return(new NextToken(token, () => ReadToken(code)));
}
var firstTokenChar = code.First();
if (firstTokenChar.IsStartOfIdentifier)
{
var identifier = code
.TakeWhile(c => c.IsBodyOfIdentifier)
.Aggregate("", (s, c) => s + c.Value);
code = code.SkipWhile(c => c.IsBodyOfIdentifier);
var token = KeywordTable.ContainsKey(identifier)
? KeywordTable[identifier].Invoke() as Token
: new Identifier();
token.Value = identifier;
token.LineNumber = firstTokenChar.LineNumber;
token.LinePosition = firstTokenChar.LinePosition;
return(new NextToken(token, () => ReadToken(code)));
}
if (firstTokenChar.IsDigit)
{
var number = code
.TakeWhile(c => c.IsDigit)
.Aggregate("", (s, c) => s + c.Value);
code = code.Skip(number.Length);
var token = new IntegerConstant();
token.Value = number;
token.LineNumber = firstTokenChar.LineNumber;
token.LinePosition = firstTokenChar.LinePosition;
return(new NextToken(token, () => ReadToken(code)));
}
if (firstTokenChar.IsStartOfStringLiteral)
{
var stringLiteral = code
.Skip(1)
.TakeWhile(c => c.Value != '"')
.Aggregate("\"", (s, c) => s + c.Value)
+ '"';
Debug.WriteLine(stringLiteral);
code = code.Skip(stringLiteral.Length);
var token = new StringLiteral();
token.Value = stringLiteral;
token.LineNumber = firstTokenChar.LineNumber;
token.LinePosition = firstTokenChar.LinePosition;
return(new NextToken(token, () => ReadToken(code)));
}
var t = new InvalidToken() as Token;
switch (firstTokenChar.Value)
{
case '(': t = new LeftParen(); break;
case ')': t = new RightParen(); break;
case '{': t = new LeftCurlyBrace(); break;
case '}': t = new RightCurlyBrace(); break;
case '[': t = new LeftSquareBracket(); break;
case ']': t = new RightSquareBracket(); break;
case ',': t = new Comma(); break;
case '*': t = new Asterisk(); break;
case ';': t = new Semicolon(); break;
}
code = code.Skip(1);
t.Value = firstTokenChar.Value.ToString();
t.LineNumber = firstTokenChar.LineNumber;
t.LinePosition = firstTokenChar.LinePosition;
return(new NextToken(t, () => ReadToken(code)));
}
internal protected virtual T Visit(Comma node)
{
return(Visit(node as Expression));
}
public static void Rule(AdditionalCompoundTerms lhs, Comma comma, CompoundTermMember compoundTermMember, AdditionalCompoundTerms additionalCompoundTerms)
{
}
private static IEnumerable <Symbol> ToSymbols(string str)
{
var index = 0;
var isLastForUnaryMinus = true;
while (index < str.Length)
{
switch (str[index])
{
case ' ':
++index;
continue;
case '(':
yield return(LeftBracket.GetInstance());
isLastForUnaryMinus = true;
++index;
continue;
case ')':
yield return(RightBracket.GetInstance());
isLastForUnaryMinus = false;
++index;
continue;
case ',':
yield return(Comma.GetInstance());
isLastForUnaryMinus = true;
++index;
continue;
case '\\':
yield return(SpecialSymbol(str, ref index));
isLastForUnaryMinus = true;
continue;
}
if (char.IsLetter(str[index]))
{
yield return(LetterSymbol(str, ref index));
isLastForUnaryMinus = false;
continue;
}
if (char.IsDigit(str[index]))
{
yield return(DigitSymbol(str, ref index));
isLastForUnaryMinus = false;
continue;
}
if (IsArithmeticPredicate(str[index]))
{
yield return(ArithmeticPredicateSymbol(str, ref index));
isLastForUnaryMinus = true;
continue;
}
if (str[index] == '-')
{
if (isLastForUnaryMinus)
{
yield return(UnaryMinus.GetInstance());
++index;
continue;
}
}
if (IsArithmeticBinaryFunction(str[index]))
{
yield return(ArithmeticBinaryFunctionSymbol(str, ref index));
isLastForUnaryMinus = true;
continue;
}
throw new ArgumentException($"the symbol {str[index]} with the number {index} is unexpected");
}
}
public static void Rule(AdditionalStatementElements lhs, Comma comma, StatementElement statementElement, AdditionalStatementElements additionalStatementElements)
{
lhs.CodeCompoundTerms.Add(statementElement.CodeCompoundTerm);
lhs.CodeCompoundTerms.AddRange(additionalStatementElements.CodeCompoundTerms);
}
public static void Rule(AdditionalCompoundTermMembers lhs, Comma comma, CompoundTermMember compoundTermMember, AdditionalCompoundTermMembers additionalCompoundTermMembers)
{
lhs.CodeTerms.Add(compoundTermMember.CodeTerm);
lhs.CodeTerms.AddRange(additionalCompoundTermMembers.CodeTerms);
}
public static void Rule(AdditionalListItems lhs, Comma comma, ListItem listItem, AdditionalListItems additionalListItems)
{
lhs.CodeTerms.Add(listItem.CodeTerm);
lhs.CodeTerms.AddRange(additionalListItems.CodeTerms);
}
public static void Rule(AdditionalStatementElements lhs, Comma comma, StatementElement statementElement, AdditionalStatementElements additionalStatementElements)
{
lhs.CodeCompoundTerms.Add(statementElement.CodeCompoundTerm);
lhs.CodeCompoundTerms.AddRange(additionalStatementElements.CodeCompoundTerms);
}
public void TestTerminals()
{
AssertSuccess(LBrace.Parse("{"), '{', true);
AssertSuccess(RBrace.Parse("}"), '}', true);
AssertSuccess(LParen.Parse("("), '(', true);
AssertSuccess(RParen.Parse(")"), ')', true);
AssertSuccess(Comma.Parse(","), ',', true);
AssertSuccess(UScore.Parse("_"), '_', true);
AssertSuccess(DQuote.Parse("\""), '"', true);
AssertSuccess(SQuote.Parse("'"), '\'', true);
AssertSuccess(Str.Parse("\"abc\""), "abc", true);
AssertSuccess(Chr.Parse("'a'"), "a", true);
AssertSuccess(ExprParser.Int.Parse("234"), "234", true);
AssertSuccess(Float.Parse("234.0"), "234.0", true);
AssertSuccess(Float.Parse(".0"), ".0", true);
AssertSuccess(Float.Parse("1e2"), "1e2", true);
AssertSuccess(Float.Parse("1E2"), "1E2", true);
AssertSuccess(Float.Parse("1E-2"), "1E-2", true);
AssertSuccess(Float.Parse("1E+2"), "1E+2", true);
AssertSuccess(Float.Parse("1.0E2"), "1.0E2", true);
AssertSuccess(Float.Parse("1.0E-2"), "1.0E-2", true);
AssertSuccess(Float.Parse("1.0E+2"), "1.0E+2", true);
AssertSuccess(IdStart.Parse("_"), '_', true);
AssertSuccess(IdStart.Parse("a"), 'a', true);
AssertSuccess(IdRest.Parse("_"), '_', true);
AssertSuccess(IdRest.Parse("1"), '1', true);
AssertSuccess(IdRest.Parse("_"), '_', true);
AssertSuccess(IdRest.Parse("a"), 'a', true);
AssertSuccess(Id.Parse("_"), "_", true);
AssertSuccess(Id.Parse("A"), "A", true);
AssertSuccess(Id.Parse("z"), "z", true);
AssertSuccess(Id.Parse("abc"), "abc", true);
AssertSuccess(Id.Parse("_abc"), "_abc", true);
AssertSuccess(Id.Parse("_1"), "_1", true);
AssertSuccess(Id.Parse("_1_a_zZ"), "_1_a_zZ", true);
AssertSuccess(Id.Parse("e"), "e", true);
AssertSuccess(Id.Parse("el"), "el", true);
AssertSuccess(Id.Parse("els"), "els", true);
AssertSuccess(Id.Parse("else1"), "else1", true);
AssertSuccess(Id.Parse("i"), "i", true);
AssertSuccess(Id.Parse("if1"), "if1", true);
AssertSuccess(Id.Parse("if_"), "if_", true);
AssertSuccess(Id.Parse("t"), "t", true);
AssertSuccess(Id.Parse("tr"), "tr", true);
AssertSuccess(True.Parse("true"), "true", true);
AssertSuccess(False.Parse("false"), "false", true);
AssertSuccess(If.Parse("if"), "if", true);
AssertSuccess(Else.Parse("else"), "else", true);
AssertSuccess(Then.Parse("then"), "then", true);
AssertSuccess(ExprParser.In.Parse("in"), "in", true);
AssertSuccess(Bool.Parse("true"), "true", true);
AssertSuccess(Bool.Parse("false"), "false", true);
AssertSuccess(Bool.Parse("\"true\""), "true", true);
AssertSuccess(Bool.Parse("\"false\""), "false", true);
AssertSuccess(KeyWords.Parse("else"), "else", true);
AssertSuccess(KeyWords.Parse("then"), "then", true);
AssertSuccess(KeyWords.Parse("if"), "if", true);
AssertSuccess(KeyWords.Parse("in "), "in", true);
}
protected override EP_VP1 Visit(Comma node)
{
return(Visit(node as Expression));
}
public Comma(MathItem prev, MathItem?next)
{
Content = prev;
Next = next switch { null => null, Comma c => c, _ => new Comma(next, null) };
}
protected override Comma VisitComma(Comma node)
{
visitedComma = true;
Assert.IsTrue(node.Value == ",");
return(base.VisitComma(node));
}
public Member(Lexer.Token name, Block body, Comma args)
{
Name = name;
Body = body;
Arguments = args;
}
protected virtual Comma VisitComma(Comma node)
{
return(VisitSyntaxNode(node) as Comma);
}
public static void Rule(AdditionalCompoundTerms lhs, Comma comma, CompoundTermMember compoundTermMember, AdditionalCompoundTerms additionalCompoundTerms)
{
}
public static void Rule(AdditionalCompoundTermMembers lhs, Comma comma, CompoundTermMember compoundTermMember, AdditionalCompoundTermMembers additionalCompoundTermMembers)
{
lhs.CodeTerms.Add(compoundTermMember.CodeTerm);
lhs.CodeTerms.AddRange(additionalCompoundTermMembers.CodeTerms);
}
public static void Rule(AdditionalListItems lhs, Comma comma, ListItem listItem, AdditionalListItems additionalListItems)
{
lhs.CodeTerms.Add(listItem.CodeTerm);
lhs.CodeTerms.AddRange(additionalListItems.CodeTerms);
}
