// public BinaryOperator Operator;
// public Expression Expression1;
// public Expression Expression2;
public override void Compile(GeneratorState state, Trac42Program program)
{
Expression1.Compile(state, program);
Expression2.Compile(state, program);
switch (Operator)
{
case BinaryOperator.Add:
program.Emit(new Instruction(Instruction.OPCODE.ADD));
break;
case BinaryOperator.Sub:
program.Emit(new Instruction(Instruction.OPCODE.SUB));
break;
case BinaryOperator.Eq:
switch (OperandType)
{
case Type.BoolType:
program.Emit(new Instruction(Instruction.OPCODE.EQBOOL));
break;
case Type.NumType:
program.Emit(new Instruction(Instruction.OPCODE.EQINT));
break;
}
break;
case BinaryOperator.Lt:
program.Emit(new Instruction(Instruction.OPCODE.LTINT));
break;
}
}
private VariableDeclaration ParseVariableDeclaration()
{
VariableDeclaration variableDeclaration = null;
if (_currentToken.TheTokenType.Equals(Token.TokenType.VARIABLE_TYPE))
{
var variableType = new VariableType(Accept(Token.TokenType.VARIABLE_TYPE));
var variableName = new UserCreatableID(Accept(Token.TokenType.USER_CREATABLE_ID));
Expression1 expression = null;
if (_currentToken.TheTokenType.Equals(Token.TokenType.ASSIGNMENT))
{
Accept(Token.TokenType.ASSIGNMENT);
expression = ParseExpression1();
}
variableDeclaration = new VariableDeclarationSimple(variableType, variableName, expression);
}
else if (Token.TokenType.COOK == _currentToken.TheTokenType)
{
variableDeclaration =
new VariableDeclarationStructVariableDeclaration(ParseStructVariableDeclaration());
}
Accept(Token.TokenType.SEMICOLON);
return(variableDeclaration);
}
public object VisitExpression1(Expression1 expression1, object o)
{
if (expression1.Operator1 == null)
{
expression1.Expression2.Visit(this);
return(null);
}
expression1.Expression2.Visit(this);
expression1.Expression1_.Visit(this);
int operatorAsDisplacement;
switch (expression1.Operator1.Spelling)
{
case "is":
operatorAsDisplacement = Machine.eqDisplacement;
break;
default:
throw new ArgumentException("Invalid operator");
}
Emit(Machine.LOADLop, 0, 0, 1);
Emit(Machine.CALLop, Machine.CB, Machine.PBr, operatorAsDisplacement);
_stackManager.DecrementOffset();
_stackManager.DecrementOffset();
return(null);
}
// public Expression Expression1;
// public Expression Expression2;
override public int Evaluate(EvaluationState state)
{
Expression1.Evaluate(state);
var result = Expression2.Evaluate(state);
return(result);
}
public void Interpret(Context context)
{
Console.WriteLine($"Nonterminal for {context.Name}.");
Expression1.Interpret(context);
Expression2.Interpret(context);
}
// public BinaryOperator Operator;
// public Expression Expression1;
// public Expression Expression2;
override public int Evaluate(EvaluationState state)
{
var value1 = Expression1.Evaluate(state);
var value2 = Expression2.Evaluate(state);
var result = 0;
switch (Operator)
{
case BinaryOperator.Add:
result = value1 + value2;
break;
case BinaryOperator.Sub:
result = value1 - value2;
break;
case BinaryOperator.Eq:
result = value1 == value2 ? 1 : 0;
break;
case BinaryOperator.Lt:
result = value1 < value2 ? 1 : 0;
break;
}
return(result);
}
private Primary ParsePrimary()
{
switch (_currentToken.TheTokenType)
{
case Token.TokenType.USER_CREATABLE_ID:
return(new PrimaryIdentifier(ParseIdentifier()));
case Token.TokenType.BOOLY_LITERAL:
return(new PrimaryBoolyLiteral(ParseBoolyLiteral()));
case Token.TokenType.INTY_LITERAL:
return(new PrimaryIntyLiteral(ParseIntyLiteral()));
case Token.TokenType.CALL:
return(new PrimaryFunctionCall(ParseFunctionCall()));
case Token.TokenType.LEFT_PAREN:
Accept(Token.TokenType.LEFT_PAREN);
Expression1 expression = ParseExpression1();
Accept(Token.TokenType.RIGHT_PAREN);
return(new PrimaryExpression(expression));
default:
throw new Exception("Generic exception");
}
}
public Value Eval()
{
var value1 = Expression1.Eval();
var value2 = Expression2.Eval();
switch (value1)
{
case IntegerValue:
{
var number1 = value1.AsInteger();
var number2 = value2.AsInteger();
var result = Conditional(number1, number2);
return(new BooleanValue(result));
}
case RealValue:
{
var number1 = value1.AsReal();
var number2 = value2.AsReal();
var result = Conditional(number1, number2);
return(new BooleanValue(result));
}
default: return(new BooleanValue(false));
}
}
public string ToExpression(AttributeValueManager valueManager)
{
var predicate = Predicate.ToExpression(valueManager);
var lowValue = Expression1.ToExpression(valueManager);
var highValue = Expression2.ToExpression(valueManager);
return($"{predicate} BETWEEN {lowValue} AND {highValue}");
}
public override void Dump(IndentWriter output)
{
output.Write("(");
Expression1.Dump(output);
output.Write(" - ");
Expression2.Dump(output);
output.Write(")");
}
internal override HashSet <char> GetUncompactableCharSet()
{
var result = Expression1.GetUncompactableCharSet();
result.UnionWith(Expression2.GetUncompactableCharSet());
return(result);
}
public int Interpret(Context context)
{
int newScore = 0;
int a = Expression1.Interpret(context);
int b = Expression2.Interpret(context);
return(newScore = a + b);
}
public FA GetFA()
{
var nfa1 = Expression1.GetFA();
var nfa2 = Expression2.GetFA();
var cross = nfa1.ToDfa().Difference(nfa2.ToDfa());
return(cross);
}
private Statement ParseStatement()
{
switch (_currentToken.TheTokenType)
{
case Token.TokenType.GIVE_BACK:
Accept(Token.TokenType.GIVE_BACK);
Expression1 expressionGiveBack = null;
if (CurrentTokenStartOfExpression())
{
expressionGiveBack = ParseExpression1();
}
Accept(Token.TokenType.SEMICOLON);
return(new StatementGiveBack(expressionGiveBack));
case Token.TokenType.STOP_THE_LOOP:
Accept(Token.TokenType.STOP_THE_LOOP);
Accept(Token.TokenType.SEMICOLON);
return(new StatementStopTheLoop());
case Token.TokenType.LOOP:
Accept(Token.TokenType.LOOP);
Expression1 loopCondition = ParseExpression1();
Accept(Token.TokenType.LEFT_SQUARE);
Statements loopStatements = ParseStatements();
Accept(Token.TokenType.RIGHT_SQUARE);
return(new StatementLoopStatement(loopCondition, loopStatements));
case Token.TokenType.IF: //if statement
Accept(Token.TokenType.IF);
Expression1 ifCondition = ParseExpression1();
Accept(Token.TokenType.LEFT_SQUARE);
Statements ifStatements = ParseStatements();
Accept(Token.TokenType.RIGHT_SQUARE);
return(new StatementIfStatement(ifCondition, ifStatements));
case Token.TokenType.CALL: // function call
FunctionCall functionCall = ParseFunctionCall();
Accept(Token.TokenType.SEMICOLON);
return(new StatementFunctionCall(functionCall));
case Token.TokenType.USER_CREATABLE_ID: // assignment
Identifier identifier = ParseIdentifier();
Accept(Token.TokenType.ASSIGNMENT);
Expression1 assignmentExpression = ParseExpression1();
Accept(Token.TokenType.SEMICOLON);
return(new StatementAssignment(identifier, assignmentExpression));
case Token.TokenType.VARIABLE_TYPE: // variable declaration
case Token.TokenType.COOK:
VariableDeclaration variableDeclaration = ParseVariableDeclaration();
return(new StatementVariableDeclaration(variableDeclaration));
default:
throw new Exception("Exception in parsing statement");
}
}
static void Main()
{
Context context = new Context("Context");
AbstractExpression exp = null;
exp = new Expression1();
exp.Interpret(context);
exp = new Expression2();
exp.Interpret(context);
Console.ReadKey();
}
public override IEnumerable <Tuple <string, VarType> > GetVars()
{
foreach (var s in Expression1.GetVars())
{
yield return(s);
}
foreach (var s in Expression2.GetVars())
{
yield return(s);
}
}
private Expression1 ParseExpression1()
{
Expression2 expression2 = ParseExpression2();
Operator1 operator1 = null;
Expression1 expression1 = null;
if (Token.TokenType.OPERATOR_1 == _currentToken.TheTokenType)
{
operator1 = new Operator1(Accept(Token.TokenType.OPERATOR_1));
expression1 = ParseExpression1();
}
return(new Expression1(expression2, operator1, expression1));
}
private Expression2 ParseExpression2()
{
Expression3 expression3 = ParseExpression3();
Operator2 operator2 = null;
Expression1 expression1 = null;
if (Token.TokenType.OPERATOR_2 == _currentToken.TheTokenType)
{
operator2 = new Operator2(Accept(Token.TokenType.OPERATOR_2));
expression1 = ParseExpression1();
}
return(new Expression2(expression3, operator2, expression1));
}
private Expression3 ParseExpression3()
{
Primary primary = ParsePrimary();
Operator3 operator3 = null;
Expression1 expression1 = null;
if (Token.TokenType.OPERATOR_3 == _currentToken.TheTokenType)
{
operator3 = new Operator3(Accept(Token.TokenType.OPERATOR_3));
expression1 = ParseExpression1();
}
return(new Expression3(primary, operator3, expression1));
}
public override string ToString(int level)
{
var outstr = "";
for (var i = 0; i < level; i++)
{
outstr += "-";
}
switch (operation)
{
case Op.Add:
outstr += "OP.ADD\n";
break;
case Op.Sub:
outstr += "OP.SUB\n";
break;
case Op.Mult:
outstr += "OP.MULT\n";
break;
case Op.Divide:
outstr += "OP.DIVIDE\n";
break;
case Op.Eq:
outstr += "RELOP.EQ\n";
break;
case Op.Grt:
outstr += "RELOP.GRT\n";
break;
case Op.Lst:
outstr += "RELOP.LST\n";
break;
case Op.Geq:
outstr += "RELOP.GEQ\n";
break;
case Op.Leq:
outstr += "RELOP.LEQ\n";
break;
}
outstr += Expression1.ToString(level + 1) + "\n";
outstr += Expression2.ToString(level + 1);
return(outstr);
}
public Value Eval()
{
var value1 = Expression1.Eval();
var value2 = Expression2.Eval();
return(value1 switch
{
IntegerValue => Operation switch
{
Operations.Plus => new IntegerValue(value1.AsInteger() + value2.AsInteger()),
Operations.Minus => new IntegerValue(value1.AsInteger() - value2.AsInteger()),
Operations.Multiply => new IntegerValue(value1.AsInteger() * value2.AsInteger()),
Operations.Divide => new IntegerValue(value1.AsInteger() / value2.AsInteger()),
_ => throw new ArgumentOutOfRangeException()
},
public override bool IsMatch(IRequestContext context)
{
var value1 = Expression1.Evaluate(context);
var value2 = Expression2.Evaluate(context);
if (string.IsNullOrEmpty(value1))
{
return(string.IsNullOrEmpty(value2));
}
if (string.IsNullOrEmpty(value2))
{
return(false);
}
return(string.Equals(value1, value2, StringComparison.OrdinalIgnoreCase));
}
override public void Pretty(PrettyBuilder builder, int outerPrecedence, bool opposite)
{
var precedence = Precedences[Operator];
var associativity = Associativities[Operator];
if (outerPrecedence > precedence || opposite && outerPrecedence == precedence)
{
builder.Append("(");
}
Expression1.Pretty(builder, precedence, associativity == Associativity.Right);
builder.Append(Strings[Operator]);
Expression2.Pretty(builder, precedence, associativity == Associativity.Left);
if (outerPrecedence > precedence || opposite && outerPrecedence == precedence)
{
builder.Append(")");
}
}
// public Expression Expression1;
// public Expression Expression2;
override public void Pretty(PrettyBuilder builder, int outerPrecedence, bool opposite)
{
if (outerPrecedence > 0)
{
builder.Append("(");
builder.Indent();
builder.NewLine();
}
Expression1.Pretty(builder, 0, false);
builder.Append(", ");
builder.NewLine();
Expression2.Pretty(builder, 0, false);
if (outerPrecedence > 0)
{
builder.Unindent();
builder.NewLine();
builder.Append(")");
builder.NewLine();
}
}
static void Main(string[] args)
{
var exp = new Expression1(new FileOutput("output.txt"));
exp.Evaluate();
var exp2 = new Expression1(30, 40, new ConsoleOutput());
exp2.Evaluate();
//var exp3 = new BubbleSort(new ConsoleOutput());
//var exp3 = new BubbleSort(new FileOutput("output.txt"));
var exp3 = new BubbleSort(
new CombinedOutput(
new FileOutput("output.txt"),
new FileOutput("output2.txt"),
new ConsoleOutput()
)
);
exp3.Evaluate();
Console.ReadKey();
}
public override Type Typecheck(TypecheckingState state)
{
var type1 = Expression1.Typecheck(state);
var type2 = Expression2.Typecheck(state);
OperandType = type1;
switch (Operator)
{
case BinaryOperator.Add:
if (type1 != Type.NumType && type2 != Type.NumType)
{
TypeError("+ expects number operands");
}
return(Type.NumType);
case BinaryOperator.Sub:
if (type1 != Type.NumType && type2 != Type.NumType)
{
TypeError("- expects number operands");
}
return(Type.NumType);
case BinaryOperator.Eq:
if (type1 != type2)
{
TypeError("== expects operands of the same type");
}
return(Type.BoolType);
case BinaryOperator.Lt:
if (type1 != Type.NumType && type2 != Type.NumType)
{
TypeError("- expects number operands");
}
return(Type.BoolType);
}
throw new ImpossibleException();
}
public object VisitExpression1(Expression1 expression1, object o)
{
if (expression1.Operator1 == null)
{
return(expression1.Expression2.Visit(this, o));
}
var t1 = (VariableType.ValueTypeEnum)expression1.Expression2.Visit(this, o);
var t2 = (VariableType.ValueTypeEnum)expression1.Expression1_.Visit(this, o);
if (t1 != t2)
{
throw new Exception("Value type for operands in 'is' operator not the same");
}
if (t1 == VariableType.ValueTypeEnum.NOTHING || t2 == VariableType.ValueTypeEnum.NOTHING)
{
throw new Exception("<Nothing> not a valid operand for 'is' operator");
}
return(VariableType.ValueTypeEnum.BOOLY);
}
public override int GetHashCode()
{
return(Expression1.GetHashCode() + Expression2.GetHashCode());
}
public override string Show()
{
return(string.Format("({0} + {1})", Expression1.Show(), Expression2.Show()));
}
public override int Eval()
{
return(Expression1.Eval() + Expression2.Eval());
}
