def test_string_variable_declaration(self):
self.assertEqual(
self.parse("int main(void) { const char* foo = \"foo\"; }"),
self.function_wrap_node(
VariableDeclaration(name="foo",
vtype=Type(base="pointer",
const=True,
reference=Type(base="char")),
value=String("foo"))))
def test_pointer_to_pointer_variable_declaration(self):
self.assertEqual(
self.parse(self.function_wrap('char **argv;')),
self.function_wrap_node(
VariableDeclaration(
name="argv",
vtype=Type(base="pointer",
reference=Type(base="pointer",
reference=Type(base="char"))),
value=None)))
def test_long_double_variable_declaration(self):
self.assertEqual(
self.parse(self.function_wrap('long double i;')),
self.function_wrap_node(
VariableDeclaration(name="i",
vtype=Type(base="long double"),
value=None)))
var = Type(base="long double")
self.assertEqual(var.base_type, "float")
self.assertEqual(var.length, 80)
def test_short_variable_declaration(self):
self.assertEqual(
self.parse(self.function_wrap('short i;')),
self.function_wrap_node(
VariableDeclaration(name="i",
vtype=Type(base="short"),
value=None)))
var = Type(base="short")
self.assertEqual(var.base_type, "int")
self.assertEqual(var.length, 16)
def test_main_with_multiple_parameters(self):
self.assertEqual(
self.parse(
"int main(int argc, char **argv, char **env) { return 0; }"),
Program(units=[
Function(return_type=Type(base='int'),
name="main",
params=[
VariableDeclaration(name="argc",
vtype=Type(base="int")),
VariableDeclaration(
name="argv",
vtype=Type(base="pointer",
reference=Type(base="pointer",
reference=Type(
base="char")))),
VariableDeclaration(
name="env",
vtype=Type(base="pointer",
reference=Type(base="pointer",
reference=Type(
base="char")))),
],
body=Block([ReturnStatement(value=Int32(value=0))]))
]))
def test_puts_function(self):
self.assertEqual(
self.parse("""
int puts(const char * string) {
int i = 0;
while (string[i] != NULL) {
putc(string[i++]);
}
putc('\\n');
return i + 1;
}
"""),
Program([
Function(
return_type=Type(base='int'),
name="puts",
params=[
VariableDeclaration(name="string",
vtype=Type(
base="pointer",
const=True,
reference=Type(base="char")))
],
body=Block([
VariableDeclaration(name="i",
vtype=Type(base="int"),
value=Int32(value=0)),
For(condition=BinaryOperation(
operator="!=",
left=ArrayDereference(
array=Variable(name="string"),
index=Variable(name="i")),
right=Null()),
body=Block([
Call(name="putc",
args=[
ArrayDereference(
array=Variable("string"),
index=PostOperation(
operator="++",
variable=Variable(name="i")))
])
])),
Call(name="putc", args=[Char('\n')]),
ReturnStatement(
value=BinaryOperation(operator="+",
left=Variable(name="i"),
right=Int32(value=1)))
]))
]))
def test_array_variable_declaration(self):
self.assertEqual(
self.parse(self.function_wrap('int foo[10];')),
self.function_wrap_node(
VariableDeclaration(name="foo",
vtype=Type(base="array",
arraylength=10,
reference=Type(base="int")),
value=None)))
var = Type(base="array",
arraylength=Int32(value=10),
reference=Type(base="int"))
self.assertEqual(var.base_type, "pointer")
self.assertEqual(var.length, Int32(value=10))
def test_function_arguments(self):
self.assertEqual(
self.parse("int puts(const char* string) { return 0; }"),
Program([
Function(return_type=Type(base='int'),
name="puts",
params=[
VariableDeclaration(
name="string",
vtype=Type(base="pointer",
const=True,
reference=Type(base="char")))
],
body=Block([ReturnStatement(value=Int32(value=0))]))
]))
def test_pointer_variable_declaration(self):
self.assertEqual(
self.parse(self.function_wrap('int* i;')),
self.function_wrap_node(
VariableDeclaration(name="i",
vtype=Type(base="pointer",
reference=Type(base="int")),
value=None)))
self.assertEqual(
self.parse(self.function_wrap('int *i;')),
self.function_wrap_node(
VariableDeclaration(name="i",
vtype=Type(base="pointer",
reference=Type(base="int")),
value=None)))
def test_variable_declaration_with_assignment(self):
self.assertEqual(
self.parse(self.function_wrap("int i = 0;")),
self.function_wrap_node(
VariableDeclaration(name="i",
vtype=Type(base="int"),
value=Int32(value=0))))
def function_wrap_node(self, node):
return Program([
Function(return_type=Type(base="int"),
name="main",
params=[],
body=Block([node]))
])
def test_unsigned_variable_declaration(self):
self.assertEqual(
self.parse(self.function_wrap('unsigned int i;')),
self.function_wrap_node(
VariableDeclaration(name="i",
vtype=Type(base="int", unsigned=True),
value=None)))
def test_variable_declaration_with_floating_point_assignment(self):
self.assertEqual(
self.parse(self.function_wrap("float i = 0.0;")),
self.function_wrap_node(
VariableDeclaration(name="i",
vtype=Type(base="float"),
value=Double(value=0.0))))
def test_main_with_no_parameters(self):
self.assertEqual(
self.parse("int main(void) { return 0; }"),
Program(units=[
Function(return_type=Type(base='int'),
name="main",
params=[],
body=Block([ReturnStatement(value=Int32(value=0))]))
]))
def test_auxiliary_function(self):
self.assertEqual(
self.parse("""
int foo(void) {
return 12;
}
int main(void) {
return foo();
}
"""),
Program([
Function(return_type=Type(base='int'),
name="foo",
params=[],
body=Block(
[ReturnStatement(value=Int32(value=12))], )),
Function(return_type=Type(base='int'),
name="main",
params=[],
body=Block([
ReturnStatement(value=Call(name="foo",
args=[]), ),
])),
]))
def test_main_function(self):
self.assertEqual(
self.parse("""
int main(void) {
return puts("Hello, world!");
}
"""),
Program([
Function(return_type=Type(base='int'),
name="main",
params=[],
body=Block([
ReturnStatement(value=Call(
name="puts", args=[String("Hello, world!")]))
]))
]))
def test_prototype_with_named_arguments(self):
self.assertEqual(
self.parse("int foo(int i, long l, double d, char *cp);"),
Program([
Function(
return_type=Type(base='int'),
name="foo",
params=[
VariableDeclaration(name="i", vtype=Type(base="int")),
VariableDeclaration(name="l", vtype=Type(base="long")),
VariableDeclaration(name="d",
vtype=Type(base="double")),
VariableDeclaration(name="cp",
vtype=Type(
base="pointer",
reference=Type(base="char"))),
],
prototype=True,
)
]))
def long_double_vtype(self, p):
return Type(base='long double')
def long_long_vtype(self, p):
return Type(base='long long')
def pointer_type(self, p):
return Type(base="pointer", reference=p[0])
def generic_vtype(self, p):
return Type(base=p[0].getstr())
def declare_array(self, p):
return VariableDeclaration(name=p[1].getstr(),
vtype=Type(base="array",
arraylength=int(p[3].getstr()),
reference=p[0]))