public override Object Visit(IntLiteralExpression node, Object obj)
{
var clonedIntLiteral = new IntLiteralExpression(node.IntValue, node.Location);
clonedIntLiteral.ExpressionType = node.ExpressionType;
return(clonedIntLiteral);
}
public static void ExpressionSplittingTestCore(
bool keepAll,
IntLiteralExpression parameter,
Action <LambdaExpression> action)
{
Pragma.KeepAll = keepAll;
var expr = new FunctionCallExpression(MetaData.Empty,
new VariableExpression(MetaData.Empty, "id"),
new List <Expression>(new[]
{
new FunctionCallExpression(MetaData.Empty,
new VariableExpression(MetaData.Empty, "id"),
new List <Expression>(new[]
{
new FunctionCallExpression(MetaData.Empty,
new VariableExpression(MetaData.Empty, "id"),
new List <Expression>(new[] { parameter })
)
}))
}));
var core = new Core();
var lambdaExpression = new LambdaExpression(MetaData.Empty,
new StatementList(MetaData.Empty,
new ReturnStatement(MetaData.Empty,
expr)));
core.Analyze(
IdDeclaration(),
new VariableDeclaration(MetaData.Empty, "_", lambdaExpression));
// Assert.IsNotNull(expr.ConvertedResult);
Errors.PrintErrorInfo();
action(lambdaExpression);
}
protected override IEnumerable <SyntaxTree> CreateOptimalSolutions()
{
IList <SyntaxTree> trees = new List <SyntaxTree>();
var i = new IntIdentifierExpression("i0");
var values = new IntArrayIdentifier("values")
{
Children =
{
i
}
};
var n = new IntIdentifierExpression("length");
var ret = new IntIdentifierExpression("ret");
var zero = new IntLiteralExpression(1);
/**
* Solution:
* for (int i = 0; i < n; i++) {
* if (values[i] == 1) {
* ret = i;
* }
* }
*/
trees.Add(new SyntaxTree(new ForLoopTimesStatement()
{
Children =
{
n,
new IfStatement()
{
HasElseClause = false,
Children =
{
new BoolEqualIntExpression()
{
Children =
{
values,
zero
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
i
}
}
}
},
}
}));
return(trees);
}
public override object Visit(IntLiteralExpression node, object obj)
{
base.Visit(node, obj);
if (node.Location == ((AstNode)obj).Location || found)
{
found = true;
}
return(this.table);
}
public void TypeTest1()
{
var example = new IntLiteralExpression(MetaData.DefaultMetaData, "123456789", true, 64);
Assert.AreEqual("i64", example.Type.ToString());
example = new IntLiteralExpression(MetaData.DefaultMetaData, "123456789", true);
Assert.AreEqual("i32", example.Type.ToString());
example = new IntLiteralExpression(MetaData.DefaultMetaData, "123456789", false, 64);
Assert.AreEqual("u64", example.Type.ToString());
example = new IntLiteralExpression(MetaData.DefaultMetaData, "123456789", false, 64);
Assert.AreEqual("u64", example.Type.ToString());
}
public void TypeTest1()
{
LiteralExpression example = new IntLiteralExpression(MetaData.Empty, "123456789", true, 64);
example.PrintDumpInfo();
Assert.AreEqual("i64", example.Type.ToString());
example = new IntLiteralExpression(MetaData.Empty, "123456789", true);
example.PrintDumpInfo();
Assert.AreEqual("i32", example.Type.ToString());
example = new IntLiteralExpression(MetaData.Empty, "123456789", false, 64);
example.PrintDumpInfo();
Assert.AreEqual("u64", example.Type.ToString());
example = new IntLiteralExpression(MetaData.Empty, "123456789", false, 64);
example.PrintDumpInfo();
Assert.AreEqual("u64", example.Type.ToString());
var example2 = new StringLiteralExpression(MetaData.Empty, "\"boy \\ next \\ door\n\t\"");
example2.PrintDumpInfo();
Assert.AreEqual(PrimaryType.StringType, example2.GetExpressionType().ToString());
// var type = new SecondaryType(MetaData.Empty, "vec", new PrimaryType(MetaData.Empty, "i8"), example.Type);
// type.SurroundWith(Environment.TopEnvironment);
// type.PrintDumpInfo();
}
public override Object Visit(IntLiteralExpression node, Object obj)
{
return(node.ILValue);
}
public virtual TReturn Visit(IntLiteralExpression node, TParam param) => throw new NotImplementedException();
public virtual TReturn Visit(IntLiteralExpression node, TParam param)
{
return(DefaultReturn);
}
protected override IEnumerable <SyntaxTree> CreateOptimalSolutions()
{
IList <SyntaxTree> trees = new List <SyntaxTree>();
var n = new IntIdentifierExpression("n");
var ret = new IntIdentifierExpression("ret");
var one = new IntLiteralExpression(1);
var two = new IntLiteralExpression(2);
var three = new IntLiteralExpression(3);
var thousand = new IntLiteralExpression(1000);
var twoThousand = new IntLiteralExpression(2000);
/**
* Solution 1:
* if (n < 1000) {
* ret = 1;
* } else {
* if (n < 2000) {
* ret = 2;
* } else {
* ret = 3;
* }
* }
*/
trees.Add(new SyntaxTree(new IfStatement()
{
Children =
{
new BoolLessThanIntExpression()
{
Children =
{
n, thousand
}
},
new IntAssignmentStatement()
{
Children =
{
ret, one
}
},
new IfStatement()
{
Children =
{
new BoolLessThanIntExpression()
{
Children =
{
n, twoThousand
}
},
new IntAssignmentStatement()
{
Children =
{
ret, two
}
},
new IntAssignmentStatement()
{
Children =
{
ret, three
}
}
}
}
}
}));
/**
* Solution 2:
* if (n >= 1000) {
* if (n >= 2000) {
* ret = 3;
* } else {
* ret = 2;
* }
* } else {
* ret = 1;
* }
*/
trees.Add(new SyntaxTree(new IfStatement()
{
Children =
{
new BoolGreaterEqualIntExpression()
{
Children =
{
n, thousand
}
},
new IfStatement()
{
Children =
{
new BoolGreaterEqualIntExpression()
{
Children =
{
n, twoThousand
}
},
new IntAssignmentStatement()
{
Children =
{
ret, three
}
},
new IntAssignmentStatement()
{
Children =
{
ret, two
}
}
}
},
new IntAssignmentStatement()
{
Children =
{
ret, one
}
}
}
}));
return(trees);
}
public abstract Object Visit(IntLiteralExpression node, Object obj);
protected override IEnumerable <SyntaxTree> CreateOptimalSolutions()
{
IList <SyntaxTree> trees = new List <SyntaxTree>();
var a = new IntIdentifierExpression("a");
var b = new IntIdentifierExpression("b");
var c = new IntIdentifierExpression("c");
var d = new IntIdentifierExpression("d");
var ret = new IntIdentifierExpression("ret");
var one = new IntLiteralExpression(1);
var two = new IntLiteralExpression(2);
var three = new IntLiteralExpression(3);
var four = new IntLiteralExpression(4);
/**
* Solution 1 (for 3 parameters):
* if (a == 1) {
* ret = ret + 1;
* } else {
* ret = ret;
* }
* if (b == 1) {
* ret = ret + 1;
* } else {
* ret = ret;
* }
* if (c == 1) {
* ret = ret + 1;
* } else {
* ret = ret;
* }
*/
if (ParameterCount == 3)
{
trees.Add(new SyntaxTree(new IfStatement()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
new IntAdditionExpression()
{
Children =
{
ret, one
}
}
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
ret
}
}
}
},
new IfStatement()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
b, one
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
new IntAdditionExpression()
{
Children =
{
ret, one
}
}
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
ret
}
}
}
},
new IfStatement()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
c, one
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
new IntAdditionExpression()
{
Children =
{
ret, one
}
}
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
ret
}
}
}
}));
}
else if (ParameterCount == 4)
{
trees.Add(new SyntaxTree(new IfStatement()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
new IntAdditionExpression()
{
Children =
{
ret, one
}
}
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
ret
}
}
}
},
new IfStatement()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
b, one
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
new IntAdditionExpression()
{
Children =
{
ret, one
}
}
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
ret
}
}
}
},
new IfStatement()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
c, one
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
new IntAdditionExpression()
{
Children =
{
ret, one
}
}
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
ret
}
}
}
},
new IfStatement()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
d, one
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
new IntAdditionExpression()
{
Children =
{
ret, one
}
}
}
},
new IntAssignmentStatement()
{
Children =
{
ret,
ret
}
}
}
}));
}
return(trees);
}
public override Object Visit(IntLiteralExpression node, Object obj)
{
this.printIndentation(Convert.ToInt32(obj));
this.output.WriteLine("{0} Type: {1} [{2}:{3}]", node.IntValue, printType(node.ExpressionType), node.Location.Line, node.Location.Column);
return(null);
}
protected override IEnumerable <SyntaxTree> CreateOptimalSolutions()
{
IList <SyntaxTree> trees = new List <SyntaxTree>();
var a = new IntIdentifierExpression("a");
var b = new IntIdentifierExpression("b");
var c = new IntIdentifierExpression("c");
var d = new IntIdentifierExpression("d");
var ret = new IntIdentifierExpression("ret");
var trueVal = new BoolTrueExpression();
var falseVal = new BoolFalseExpression();
var one = new IntLiteralExpression(1);
var two = new IntLiteralExpression(2);
var three = new IntLiteralExpression(3);
var four = new IntLiteralExpression(4);
/**
* Solution 1 (for 3 parameters):
* if (a > b) {
* if (a > c) {
* ret = a;
* } else {
* ret = c;
* }
* } else {
* if (b > c) {
* ret = b;
* } else {
* ret = c;
* }
* }
*/
if (ParameterCount == 3)
{
trees.Add(new SyntaxTree(new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
a, b
}
},
new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
a, c
}
},
new IntAssignmentStatement()
{
Children =
{
ret, a
}
},
new IntAssignmentStatement()
{
Children =
{
ret, c
}
}
}
},
new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
b, c
}
},
new IntAssignmentStatement()
{
Children =
{
ret, b
}
},
new IntAssignmentStatement()
{
Children =
{
ret, c
}
}
}
}
}
}));
}
/**
* Solution 1 (for 4 parameters):
* if (a > b) {
* if (a > c) {
* if (a > d) {
* ret = a;
* } else {
* ret = d;
* }
* } else {
* if (c > d) {
* ret = c;
* } else {
* ret = d;
* }
* }
* } else {
* if (b > c) {
* if (b > d) {
* ret = b;
* } else {
* ret = d;
* }
* } else {
* if (c > d) {
* ret = c;
* } else {
* ret = d;
* }
* }
* }
*/
trees.Add(new SyntaxTree(new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
a, b
}
},
new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
a, c
}
},
new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
a, d
}
},
new IntAssignmentStatement()
{
Children =
{
ret, a
}
},
new IntAssignmentStatement()
{
Children =
{
ret, d
}
}
}
},
new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
c, d
}
},
new IntAssignmentStatement()
{
Children =
{
ret, c
}
},
new IntAssignmentStatement()
{
Children =
{
ret, d
}
}
}
},
}
},
new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
b, c
}
},
new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
b, d
}
},
new IntAssignmentStatement()
{
Children =
{
ret, b
}
},
new IntAssignmentStatement()
{
Children =
{
ret, d
}
}
}
},
new IfStatement()
{
Children =
{
new BoolGreaterThanIntExpression()
{
Children =
{
c, d
}
},
new IntAssignmentStatement()
{
Children =
{
ret, c
}
},
new IntAssignmentStatement()
{
Children =
{
ret, d
}
}
}
},
}
}
}
}));
return(trees);
}
protected override IEnumerable <SyntaxTree> CreateOptimalSolutions()
{
IList <SyntaxTree> trees = new List <SyntaxTree>();
var a = new IntIdentifierExpression("a");
var b = new IntIdentifierExpression("b");
var c = new IntIdentifierExpression("c");
var d = new IntIdentifierExpression("d");
var ret = new BoolIdentifierExpression("ret");
var trueVal = new BoolTrueExpression();
var falseVal = new BoolFalseExpression();
var one = new IntLiteralExpression(1);
var two = new IntLiteralExpression(2);
var three = new IntLiteralExpression(3);
var four = new IntLiteralExpression(4);
/**
* Solution 1 (for 3 parameters):
* if (((a == 1 && b == 1) || (b == 1 && c == 1)) || (a == 1 && c == 1)) {
* ret = true;
* } else {
* ret = false;
* }
*/
if (ParameterCount == 3)
{
trees.Add(new SyntaxTree(new IfStatement()
{
Children =
{
new BoolOrExpression()
{
Children =
{
new BoolOrExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
b, one
}
}
}
},
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
b, one
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
}
}
},
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
}
}
},
new BoolAssignmentStatement()
{
Children =
{
ret, trueVal
}
},
new BoolAssignmentStatement()
{
Children =
{
ret, falseVal
}
}
}
}));
}
/**
* Solution 1 (for 4 parameters):
* if (((a == 1 && b == 1) && c == 1) || (a == 1 && b == 1) && d == 1)) ||
* ((a == 1 && c == 1) && d == 1) || (b == 1 && c == 1) && d == 1))) {
* ret = true;
* else {
* ret = false;
* }
*/
if (ParameterCount == 4)
{
trees.Add(new SyntaxTree(new IfStatement()
{
Children =
{
new BoolOrExpression()
{
Children =
{
new BoolOrExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
b, one
}
}
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
},
new BoolAndExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
b, one
}
}
}
},
new BoolEqualIntExpression()
{
Children =
{
d, one
}
}
}
}
}
},
new BoolOrExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
},
new BoolEqualIntExpression()
{
Children =
{
d, one
}
}
}
},
new BoolAndExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
b, one
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
},
new BoolEqualIntExpression()
{
Children =
{
d, one
}
}
}
}
}
}
}
},
new BoolAssignmentStatement()
{
Children =
{
ret, trueVal
}
},
new BoolAssignmentStatement()
{
Children =
{
ret, falseVal
}
}
}
}));
}
/**
* Solution 2 (for 3 parameters):
* ret = (((a == 1 && b == 1) || (b == 1 && c == 1)) || (a == 1 && c == 1))
*/
if (ParameterCount == 3)
{
trees.Add(new SyntaxTree(new BoolAssignmentStatement()
{
Children =
{
ret,
new BoolOrExpression()
{
Children =
{
new BoolOrExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
b, one
}
}
}
},
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
b, one
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
}
}
},
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
}
}
}
}
}));
}
/**
* Solution 2 (for 4 parameters):
* ret = (((a == 1 && b == 1) && c == 1) || (a == 1 && b == 1) && d == 1)) ||
* ((a == 1 && c == 1) && d == 1) || (b == 1 && c == 1) && d == 1)))
*/
if (ParameterCount == 4)
{
trees.Add(new SyntaxTree(new BoolAssignmentStatement()
{
Children =
{
ret,
new BoolOrExpression()
{
Children =
{
new BoolOrExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
b, one
}
}
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
},
new BoolAndExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
b, one
}
}
}
},
new BoolEqualIntExpression()
{
Children =
{
d, one
}
}
}
}
}
},
new BoolOrExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
a, one
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
},
new BoolEqualIntExpression()
{
Children =
{
d, one
}
}
}
},
new BoolAndExpression()
{
Children =
{
new BoolAndExpression()
{
Children =
{
new BoolEqualIntExpression()
{
Children =
{
b, one
}
},
new BoolEqualIntExpression()
{
Children =
{
c, one
}
}
}
},
new BoolEqualIntExpression()
{
Children =
{
d, one
}
}
}
}
}
}
}
}
}
}));
}
return(trees);
}
