1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
#!/usr/bin/python3 -tt
# Copyright 2012 Jussi Pakkanen
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import parser
import nodes
import environment
class InterpreterException(Exception):
pass
class InvalidCode(InterpreterException):
pass
class InvalidArguments(InterpreterException):
pass
class InterpreterObject():
pass
class BuildTarget(InterpreterObject):
def __init__(self, name, sources):
self.name = name
self.sources = sources
self.external_deps = []
def get_basename(self):
return self.name
def get_sources(self):
return self.sources
def add_external_dep(self, dep):
if not isinstance(dep, environment.PkgConfigDependency):
raise InvalidArguments('Argument is not an external dependency')
self.external_deps.append(dep)
def get_external_deps(self):
return self.external_deps
class Executable(BuildTarget):
pass
class Interpreter():
def __init__(self, code):
self.ast = parser.build_ast(code)
self.sanity_check_ast()
self.project = None
self.compilers = []
self.executables = {}
self.variables = {}
def get_project(self):
return self.project
def get_executables(self):
return self.executables
def sanity_check_ast(self):
if not isinstance(self.ast, nodes.CodeBlock):
raise InvalidCode('AST is of invalid type. Possibly a bug in the parser.')
if len(self.ast.get_statements()) == 0:
raise InvalidCode('No statements in code.')
first = self.ast.get_statements()[0]
if not isinstance(first, nodes.FunctionCall) or first.get_function_name() != 'project':
raise InvalidCode('First statement must be a call to project')
def run(self):
i = 0
statements = self.ast.get_statements()
while i < len(statements):
cur = statements[i]
self.evaluate_statement(cur)
i += 1 # In THE FUTURE jump over blocks and stuff.
def evaluate_statement(self, cur):
if isinstance(cur, nodes.FunctionCall):
return self.function_call(cur)
elif isinstance(cur, nodes.Assignment):
return self.assignment(cur)
else:
raise InvalidCode("Unknown statement in line %d." % cur.lineno())
def validate_arguments(self, args, argcount, arg_types):
if argcount is not None:
if argcount != len(args):
raise InvalidArguments('Expected %d arguments, got %d',
argcount, len(args))
for i in range(min(len(args), len(arg_types))):
wanted = arg_types[i]
actual = args[i]
if wanted != None:
if not isinstance(actual, wanted):
raise InvalidArguments('Incorrect argument type.')
def func_project(self, node, args):
self.validate_arguments(args, 1, [nodes.StringStatement])
if self.project is not None:
raise InvalidCode('Second call to project() on line %d.' % node.lineno())
self.project = args[0].get_string()
print("Project name is %s." % self.project)
def func_message(self, node, args):
self.validate_arguments(args, 1, [nodes.StringStatement])
print('Message: %s' % args[0].get_string())
def func_language(self, node, args):
self.validate_arguments(args, 1, [nodes.StringStatement])
if len(self.compilers) > 0:
raise InvalidCode('Function language() can only be called once (line %d).' % node.lineno())
lang = args[0].get_string()
if lang.lower() == 'c':
self.compilers.append(environment.detect_c_compiler('gcc'))
else:
raise InvalidCode('Tried to use unknown language "%s".' % lang)
def func_executable(self, node, args):
self.validate_arguments(args, 2, (nodes.StringStatement, nodes.StringStatement))
name = args[0].get_string()
sources = [args[1].get_string()]
if name in self.executables:
raise InvalidCode('Line %d, tried to create executable "%s", which already exists.' % (node.lineno(), name))
exe = Executable(name, sources)
self.executables[name] = exe
print('Creating executable %s with file %s' % (name, sources[0]))
return exe
def func_find_dep(self, node, args):
self.validate_arguments(args, 1, [nodes.StringStatement])
name = args[0].get_string()
dep = environment.find_external_dependency(name)
return dep
def function_call(self, node):
func_name = node.get_function_name()
args = node.arguments.arguments
if func_name == 'project':
return self.func_project(node, args)
elif func_name == 'message':
return self.func_message(node, args)
elif func_name == 'language':
return self.func_language(node, args)
elif func_name == 'executable':
return self.func_executable(node, args)
elif func_name == 'find_dep':
return self.func_find_dep(node, args)
else:
raise InvalidCode('Unknown function "%s".' % func_name)
def is_assignable(self, value):
if isinstance(value, InterpreterObject) or \
isinstance(value, environment.PkgConfigDependency):
return True
return False
def assignment(self, node):
var_name = node.var_name
if not isinstance(var_name, nodes.AtomExpression):
raise InvalidArguments('Line %d: Tried to assign value to a non-variable.' % node.lineno())
value = self.evaluate_statement(node.value)
if value is None:
raise InvalidCode('Line %d: Can not assign None to variable.' % node.lineno())
if not self.is_assignable(value):
raise InvalidCode('Line %d: Tried to assign an invalid value to variable.' % node.lineno())
self.variables[var_name] = value
return value
if __name__ == '__main__':
code = """project('myawesomeproject')
message('I can haz text printed out?')
language('c')
prog = executable('prog', 'prog.c')
dep = find_dep('gtk+-3.0')
"""
i = Interpreter(code)
i.run()
|
