Kill ply dependency dead.
This commit is contained in:
Jussi Pakkanen
parent
8a02b9da39
commit
4ab3dc440b
10
backends.py
10
backends.py
|
|
@ -12,8 +12,8 @@
|
|||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
import parsertest as mparser2
|
||||
import os, sys, re, pickle
|
||||
import nodes
|
||||
import environment, mlog
|
||||
from meson_install import InstallData
|
||||
from build import InvalidArguments
|
||||
|
|
@ -39,8 +39,8 @@ def do_replacement(regex, line, confdata):
|
|||
var = confdata.get(varname)
|
||||
if isinstance(var, str):
|
||||
pass
|
||||
elif isinstance(var, nodes.StringStatement):
|
||||
var = var.get_value()
|
||||
elif isinstance(var, mparser2.StringNode):
|
||||
var = var.value
|
||||
elif isinstance(var, int):
|
||||
var = str(var)
|
||||
else:
|
||||
|
|
@ -60,8 +60,8 @@ def do_mesondefine(line, confdata):
|
|||
v = confdata.get(varname)
|
||||
except KeyError:
|
||||
return '/* undef %s */\n' % varname
|
||||
if isinstance(v, nodes.BoolStatement):
|
||||
v = v.get_value()
|
||||
if isinstance(v, mparser2.BooleanNode):
|
||||
v = v.value
|
||||
if isinstance(v, bool):
|
||||
if v:
|
||||
return '#define %s\n' % varname
|
||||
|
|
|
|||
|
|
@ -12,9 +12,7 @@
|
|||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
import mparser
|
||||
import parsertest as mparser2
|
||||
import nodes
|
||||
import environment
|
||||
import coredata
|
||||
import dependencies
|
||||
|
|
@ -430,8 +428,6 @@ class CompilerHolder(InterpreterObject):
|
|||
if len(args) != 1:
|
||||
raise InterpreterException('Run method takes exactly one positional argument.')
|
||||
code = args[0]
|
||||
if isinstance(code, nodes.StringStatement):
|
||||
code = code.get_value()
|
||||
testname = kwargs.get('name', '')
|
||||
if not isinstance(testname, str):
|
||||
raise InterpreterException('Testname argument must be a string.')
|
||||
|
|
@ -509,8 +505,6 @@ class CompilerHolder(InterpreterObject):
|
|||
testname = kwargs.get('name', '')
|
||||
if not isinstance(testname, str):
|
||||
raise InterpreterException('Testname argument must be a string.')
|
||||
if isinstance(string, nodes.StringStatement):
|
||||
string = string.value
|
||||
if not isinstance(string, str):
|
||||
raise InterpreterException('Argument to compiles() must be a string')
|
||||
result = self.compiler.compiles(string)
|
||||
|
|
@ -526,8 +520,6 @@ class CompilerHolder(InterpreterObject):
|
|||
if len(args) != 1:
|
||||
raise InterpreterException('has_header method takes exactly one argument.')
|
||||
string = args[0]
|
||||
if isinstance(string, nodes.StringStatement):
|
||||
string = string.value
|
||||
if not isinstance(string, str):
|
||||
raise InterpreterException('Argument to has_header() must be a string')
|
||||
haz = self.compiler.has_header(string)
|
||||
|
|
@ -1121,8 +1113,8 @@ class Interpreter():
|
|||
self.build.global_args[lang] = args
|
||||
|
||||
def flatten(self, args):
|
||||
if isinstance(args, nodes.StringStatement):
|
||||
return args.get_value()
|
||||
if isinstance(args, mparser2.StringNode):
|
||||
return args.value
|
||||
if isinstance(args, str):
|
||||
return args
|
||||
if isinstance(args, InterpreterObject):
|
||||
|
|
@ -1132,8 +1124,8 @@ class Interpreter():
|
|||
if isinstance(a, list):
|
||||
rest = self.flatten(a)
|
||||
result = result + rest
|
||||
elif isinstance(a, nodes.StringStatement):
|
||||
result.append(a.get_value())
|
||||
elif isinstance(a, mparser2.StringNode):
|
||||
result.append(a.value)
|
||||
else:
|
||||
result.append(a)
|
||||
return result
|
||||
|
|
@ -1283,7 +1275,7 @@ class Interpreter():
|
|||
if method_name == 'extract_objects' and self.environment.coredata.unity:
|
||||
raise InterpreterException('Single object files can not be extracted in Unity builds.')
|
||||
args = node.args
|
||||
if isinstance(obj, nodes.StringStatement):
|
||||
if isinstance(obj, mparser2.StringNode):
|
||||
obj = obj.get_value()
|
||||
if isinstance(obj, str):
|
||||
return self.string_method_call(obj, method_name, args)
|
||||
|
|
|
|||
291
mparser.py
291
mparser.py
|
|
@ -1,291 +0,0 @@
|
|||
# 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 ply.lex as lex
|
||||
import ply.yacc as yacc
|
||||
import nodes
|
||||
from coredata import MesonException
|
||||
|
||||
class ParserException(MesonException):
|
||||
def __init__(self, text, lineno):
|
||||
MesonException.__init__(self, text)
|
||||
self.lineno = lineno
|
||||
|
||||
reserved = {'true' : 'TRUE',
|
||||
'false' : 'FALSE',
|
||||
'if' : 'IF',
|
||||
'endif' : 'ENDIF',
|
||||
'elif' : 'ELIF',
|
||||
'else' : 'ELSE',
|
||||
'and' : 'AND',
|
||||
'or' : 'OR',
|
||||
'not' : 'NOT',
|
||||
}
|
||||
|
||||
tokens = ['LPAREN',
|
||||
'RPAREN',
|
||||
'LBRACKET',
|
||||
'RBRACKET',
|
||||
'ATOM',
|
||||
'COMMENT',
|
||||
'ASSIGN',
|
||||
'EQUALS',
|
||||
'NEQUALS',
|
||||
'COMMA',
|
||||
'DOT',
|
||||
'STRING',
|
||||
'MULTILINE_STRING',
|
||||
'INT',
|
||||
'EOL_CONTINUE',
|
||||
'EOL',
|
||||
'COLON',
|
||||
] + list(reserved.values())
|
||||
|
||||
t_ASSIGN = '='
|
||||
t_EQUALS = '=='
|
||||
t_NEQUALS = '\!='
|
||||
t_LPAREN = '\('
|
||||
t_RPAREN = '\)'
|
||||
t_LBRACKET = '\['
|
||||
t_RBRACKET = '\]'
|
||||
t_ignore_COMMENT = '\\#.*?(?=\\n)'
|
||||
t_COMMA = ','
|
||||
t_DOT = '\.'
|
||||
t_COLON = ':'
|
||||
|
||||
t_ignore = ' \t'
|
||||
|
||||
precedence = (
|
||||
('left', 'COMMA'),
|
||||
('left', 'ASSIGN'),
|
||||
('left', 'OR'),
|
||||
('left', 'AND'),
|
||||
('right', 'NOT'),
|
||||
('nonassoc', 'EQUALS', 'NEQUALS'),
|
||||
('nonassoc', 'COLON'),
|
||||
('left', 'DOT'),
|
||||
)
|
||||
|
||||
def t_ATOM(t):
|
||||
'[_a-zA-Z][_0-9a-zA-Z]*'
|
||||
t.type = reserved.get(t.value, 'ATOM')
|
||||
return t
|
||||
|
||||
|
||||
def t_MULTILINE_STRING(t):
|
||||
r"'''(.|\n)*?'''"
|
||||
t.value = t.value[3:-3]
|
||||
t.lexer.lineno += t.value.count('\n')
|
||||
return t
|
||||
|
||||
def t_STRING(t):
|
||||
"'[^']*'"
|
||||
t.value = t.value[1:-1]
|
||||
return t
|
||||
|
||||
def t_INT(t):
|
||||
'[0-9]+'
|
||||
t.value = int(t.value)
|
||||
return t
|
||||
|
||||
def t_EOL(t):
|
||||
r'\n'
|
||||
t.lexer.lineno += 1
|
||||
return t
|
||||
|
||||
def t_EOL_CONTINUE(t):
|
||||
r'\\[ \t]*\n'
|
||||
t.lexer.lineno += 1
|
||||
|
||||
def t_error(t):
|
||||
raise ParserException("Illegal character '%s'." % t.value[0], t.lineno)
|
||||
|
||||
# Yacc part
|
||||
|
||||
def p_codeblock(t):
|
||||
'codeblock : statement EOL codeblock'
|
||||
cb = t[3]
|
||||
cb.prepend(t[1])
|
||||
t[0] = cb
|
||||
|
||||
def p_codeblock_emptyline(t):
|
||||
'codeblock : EOL codeblock'
|
||||
t[0] = t[2]
|
||||
|
||||
def p_codeblock_empty(t):
|
||||
'codeblock : '
|
||||
t[0] = nodes.CodeBlock(-1)
|
||||
|
||||
def p_expression_atom(t):
|
||||
'expression : ATOM'
|
||||
t[0] = nodes.AtomExpression(t[1], t.lineno(1))
|
||||
|
||||
def p_expression_int(t):
|
||||
'expression : INT'
|
||||
t[0] = nodes.IntExpression(t[1], t.lineno(1))
|
||||
|
||||
def p_expression_bool(t):
|
||||
'''expression : TRUE
|
||||
| FALSE'''
|
||||
if t[1] == 'true':
|
||||
t[0] = nodes.BoolExpression(True, t.lineno(1))
|
||||
else:
|
||||
t[0] = nodes.BoolExpression(False, t.lineno(1))
|
||||
|
||||
def p_expression_string(t):
|
||||
'expression : STRING'
|
||||
t[0] = nodes.StringExpression(t[1], t.lineno(1))
|
||||
|
||||
def p_expression_multiline_string(t):
|
||||
'expression : MULTILINE_STRING'
|
||||
t[0] = nodes.StringExpression(t[1], t.lineno(1))
|
||||
|
||||
def p_statement_assign(t):
|
||||
'statement : expression ASSIGN statement'
|
||||
t[0] = nodes.Assignment(t[1], t[3], t[1].lineno())
|
||||
|
||||
def p_statement_comparison(t):
|
||||
'''statement : statement EQUALS statement
|
||||
| statement NEQUALS statement'''
|
||||
t[0] = nodes.Comparison(t[1], t[2], t[3], t[1].lineno())
|
||||
|
||||
def p_statement_array(t):
|
||||
'''statement : LBRACKET args RBRACKET
|
||||
| LBRACKET EOL args RBRACKET'''
|
||||
if len(t) == 4:
|
||||
t[0] = nodes.ArrayStatement(t[2], t.lineno(1))
|
||||
else:
|
||||
t[0] = nodes.ArrayStatement(t[3], t.lineno(1))
|
||||
|
||||
def p_statement_func_call(t):
|
||||
'statement : expression LPAREN args RPAREN'
|
||||
t[0] = nodes.FunctionCall(t[1], t[3], t[1].lineno())
|
||||
|
||||
def p_statement_method_call(t):
|
||||
'statement : statement DOT expression LPAREN args RPAREN'
|
||||
t[0] = nodes.MethodCall(t[1], t[3], t[5], t[1].lineno())
|
||||
|
||||
def p_statement_if(t):
|
||||
'statement : IF statement EOL codeblock elseblock ENDIF'
|
||||
t[0] = nodes.IfStatement(t[2], t[4], t[5], t.lineno(1))
|
||||
|
||||
def p_statement_parentheses(t):
|
||||
'statement : LPAREN statement RPAREN'
|
||||
t[0] = t[2]
|
||||
|
||||
def p_statement_and(t):
|
||||
'statement : statement AND statement'
|
||||
t[0] = nodes.AndStatement(t[1], t[3])
|
||||
|
||||
def p_statement_or(t):
|
||||
'statement : statement OR statement'
|
||||
t[0] = nodes.OrStatement(t[1], t[3])
|
||||
|
||||
def p_statement_not(t):
|
||||
'statement : NOT statement'
|
||||
t[0] = nodes.NotStatement(t[2])
|
||||
|
||||
def p_statement_elif(t):
|
||||
'elseblock : ELIF statement EOL codeblock elseblock'
|
||||
t[0] = nodes.IfStatement(t[2], t[4], t[5], t.lineno(1))
|
||||
|
||||
def p_empty_else(t):
|
||||
'elseblock : '
|
||||
return None
|
||||
|
||||
def p_else(t):
|
||||
'elseblock : ELSE EOL codeblock'
|
||||
t[0] = t[3]
|
||||
|
||||
def p_statement_expression(t):
|
||||
'statement : expression'
|
||||
t[0] = nodes.statement_from_expression(t[1])
|
||||
|
||||
|
||||
def p_args_multiple(t):
|
||||
'''args : statement COMMA args
|
||||
| statement COMMA EOL args
|
||||
| statement EOL COMMA args'''
|
||||
if len(t) == 5:
|
||||
args = t[4]
|
||||
else:
|
||||
args = t[3]
|
||||
args.prepend(t[1])
|
||||
t[0] = args
|
||||
|
||||
def p_kwargs_multiple(t):
|
||||
'''args : expression COLON statement COMMA args
|
||||
| expression COLON statement COMMA EOL args
|
||||
| expression COLON statement EOL COMMA args'''
|
||||
if len(t) == 7:
|
||||
args = t[6]
|
||||
else:
|
||||
args = t[5]
|
||||
args.set_kwarg(t[1], t[3])
|
||||
t[0] = args
|
||||
|
||||
def p_args_single_pos(t):
|
||||
'args : statement'
|
||||
args = nodes.Arguments(t[1].lineno())
|
||||
args.prepend(t[1])
|
||||
t[0] = args
|
||||
|
||||
def p_args_single_kw(t):
|
||||
'args : expression COLON statement'
|
||||
a = nodes.Arguments(t[1].lineno())
|
||||
a.set_kwarg(t[1], t[3])
|
||||
t[0] = a
|
||||
|
||||
def p_args_none(t):
|
||||
'args :'
|
||||
t[0] = nodes.Arguments(t.lineno(0))
|
||||
|
||||
def p_error(t):
|
||||
lineno = -1
|
||||
if t is None:
|
||||
txt = 'NONE'
|
||||
else:
|
||||
txt = t.value
|
||||
lineno = t.lineno
|
||||
raise ParserException('Parser errored out at: %s.' % txt, lineno)
|
||||
|
||||
def test_lexer():
|
||||
s = """hello = (something) # this = (that)
|
||||
two = ['file1', 'file2']
|
||||
function(h) { stuff }
|
||||
obj.method(lll, \\
|
||||
'string')
|
||||
"""
|
||||
lexer = lex.lex()
|
||||
lexer.input(s)
|
||||
while True:
|
||||
tok = lexer.token()
|
||||
if not tok:
|
||||
break
|
||||
print(tok)
|
||||
|
||||
def generate_parser_files(outputdir):
|
||||
code = """project('empty', 'c')
|
||||
"""
|
||||
build_ast(code, outputdir=outputdir)
|
||||
|
||||
def build_ast(code, outputdir=None):
|
||||
code = code.rstrip() + '\n'
|
||||
lex.lex()
|
||||
if outputdir:
|
||||
parser = yacc.yacc(outputdir=outputdir)
|
||||
else:
|
||||
parser = yacc.yacc()
|
||||
result = parser.parse(code)
|
||||
return result
|
||||
220
nodes.py
220
nodes.py
|
|
@ -1,220 +0,0 @@
|
|||
# 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.
|
||||
|
||||
class Node():
|
||||
def __init__(self, lineno):
|
||||
self.line_number = lineno
|
||||
|
||||
def lineno(self):
|
||||
return self.line_number
|
||||
|
||||
class Expression(Node):
|
||||
pass
|
||||
|
||||
class Statement(Node):
|
||||
pass
|
||||
|
||||
class BoolExpression(Expression):
|
||||
def __init__(self, value, lineno):
|
||||
Expression.__init__(self, lineno)
|
||||
self.value = value
|
||||
assert(isinstance(value, bool))
|
||||
|
||||
def get_value(self):
|
||||
return self.value
|
||||
|
||||
class AtomExpression(Expression):
|
||||
def __init__(self, value, lineno):
|
||||
Expression.__init__(self, lineno)
|
||||
self.value = value
|
||||
|
||||
def get_value(self):
|
||||
return self.value
|
||||
|
||||
class StringExpression(Expression):
|
||||
def __init__(self, value, lineno):
|
||||
Expression.__init__(self, lineno)
|
||||
self.value = value
|
||||
|
||||
class IntExpression(Expression):
|
||||
def __init__(self, value, lineno):
|
||||
Expression.__init__(self, lineno)
|
||||
self.value = value
|
||||
|
||||
def get_value(self):
|
||||
return self.value
|
||||
|
||||
class AtomStatement(Statement):
|
||||
def __init__(self, value, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
assert(type(value) == type(''))
|
||||
self.value = value
|
||||
|
||||
def get_value(self):
|
||||
return self.value
|
||||
|
||||
class BoolStatement(Statement):
|
||||
def __init__(self, value, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
assert(isinstance(value, bool))
|
||||
self.value = value
|
||||
|
||||
def get_value(self):
|
||||
return self.value
|
||||
|
||||
class IntStatement(Statement):
|
||||
def __init__(self, value, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
assert(isinstance(value, int))
|
||||
self.value = value
|
||||
|
||||
def get_value(self):
|
||||
return self.value
|
||||
|
||||
class AndStatement(Statement):
|
||||
def __init__(self, left, right):
|
||||
Statement.__init__(self, left.lineno)
|
||||
self.left = left
|
||||
self.right = right
|
||||
|
||||
class OrStatement(Statement):
|
||||
def __init__(self, left, right):
|
||||
Statement.__init__(self, left.lineno)
|
||||
self.left = left
|
||||
self.right = right
|
||||
|
||||
class NotStatement(Statement):
|
||||
def __init__(self, val):
|
||||
Statement.__init__(self, val.lineno)
|
||||
self.val = val
|
||||
|
||||
class IfStatement(Statement):
|
||||
def __init__(self, clause, trueblock, falseblock, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
self.clause = clause
|
||||
self.trueblock = trueblock
|
||||
self.falseblock = falseblock
|
||||
|
||||
def get_clause(self):
|
||||
return self.clause
|
||||
|
||||
def get_trueblock(self):
|
||||
return self.trueblock
|
||||
|
||||
def get_falseblock(self):
|
||||
return self.falseblock
|
||||
|
||||
class Comparison(Statement):
|
||||
def __init__(self, first, ctype, second, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
self.first = first
|
||||
self.ctype = ctype
|
||||
self.second = second
|
||||
|
||||
def get_first(self):
|
||||
return self.first
|
||||
|
||||
def get_ctype(self):
|
||||
return self.ctype
|
||||
|
||||
def get_second(self):
|
||||
return self.second
|
||||
|
||||
class ArrayStatement(Statement):
|
||||
def __init__(self, args, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
self.args = args
|
||||
|
||||
def get_args(self):
|
||||
return self.args
|
||||
|
||||
class StringStatement(Statement):
|
||||
def __init__(self, value, lineno):
|
||||
assert(type(value) == type(''))
|
||||
Statement.__init__(self, lineno)
|
||||
self.value = value
|
||||
|
||||
def get_value(self):
|
||||
return self.value
|
||||
|
||||
class FunctionCall(Statement):
|
||||
def __init__(self, func_name, arguments, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
self.func_name = func_name
|
||||
self.arguments = arguments
|
||||
|
||||
def get_function_name(self):
|
||||
return self.func_name.value
|
||||
|
||||
class MethodCall(Statement):
|
||||
def __init__(self, invokable, method_name, arguments, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
self.invokable = invokable
|
||||
self.method_name = method_name
|
||||
self.arguments = arguments
|
||||
|
||||
class Assignment(Statement):
|
||||
def __init__(self, var_name, value, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
self.var_name = var_name
|
||||
self.value = value
|
||||
|
||||
class CodeBlock(Statement):
|
||||
def __init__(self, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
self.statements = []
|
||||
|
||||
def prepend(self, statement):
|
||||
self.statements = [statement] + self.statements
|
||||
|
||||
def get_statements(self):
|
||||
return self.statements
|
||||
|
||||
class Arguments(Statement):
|
||||
def __init__(self, lineno):
|
||||
Statement.__init__(self, lineno)
|
||||
self.arguments = []
|
||||
self.kwargs = {}
|
||||
self.order_error = False
|
||||
|
||||
def prepend(self, statement):
|
||||
self.arguments = [statement] + self.arguments
|
||||
|
||||
def set_kwarg(self, name, value):
|
||||
if self.num_args() > 0:
|
||||
self.order_error = True
|
||||
self.kwargs[name.get_value()] = value
|
||||
|
||||
def num_args(self):
|
||||
return len(self.arguments)
|
||||
|
||||
def num_kwargs(self):
|
||||
return len(self.kwargs)
|
||||
|
||||
def incorrect_order(self):
|
||||
return self.order_error
|
||||
|
||||
def __len__(self):
|
||||
return self.num_args() # Fixme
|
||||
|
||||
def statement_from_expression(expr):
|
||||
if isinstance(expr, AtomExpression):
|
||||
return AtomStatement(expr.value, expr.lineno())
|
||||
if isinstance(expr, StringExpression):
|
||||
return StringStatement(expr.value, expr.lineno())
|
||||
if isinstance(expr, BoolExpression):
|
||||
return BoolStatement(expr.value, expr.lineno())
|
||||
if isinstance(expr, IntExpression):
|
||||
return IntStatement(expr.get_value(), expr.lineno())
|
||||
raise RuntimeError('Can not convert unknown expression to a statement.')
|
||||
|
|
@ -12,9 +12,8 @@
|
|||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
import mparser
|
||||
import parsertest as mparser2
|
||||
import coredata
|
||||
import nodes
|
||||
import os
|
||||
|
||||
forbidden_option_names = {'type': True,
|
||||
|
|
@ -89,41 +88,41 @@ class OptionInterpreter:
|
|||
|
||||
def process(self, option_file):
|
||||
try:
|
||||
ast = mparser.build_ast(open(option_file, 'r').read())
|
||||
ast = mparser2.Parser(open(option_file, 'r').read()).parse()
|
||||
except coredata.MesonException as me:
|
||||
me.file = option_file
|
||||
raise me
|
||||
if not isinstance(ast, nodes.CodeBlock):
|
||||
if not isinstance(ast, mparser2.CodeBlockNode):
|
||||
e = OptionException('Option file is malformed.')
|
||||
e.lineno = ast.lineno()
|
||||
raise e
|
||||
statements = ast.get_statements()
|
||||
for cur in statements:
|
||||
for cur in ast.lines:
|
||||
try:
|
||||
self.evaluate_statement(cur)
|
||||
except Exception as e:
|
||||
e.lineno = cur.lineno()
|
||||
e.lineno = cur.lineno
|
||||
e.colno = cur.colno
|
||||
e.file = os.path.join('meson_options.txt')
|
||||
raise e
|
||||
|
||||
def reduce_single(self, arg):
|
||||
if isinstance(arg, nodes.AtomExpression) or isinstance(arg, nodes.AtomStatement):
|
||||
if isinstance(arg, mparser2.IdNode):
|
||||
return self.get_variable(arg.value)
|
||||
elif isinstance(arg, str):
|
||||
return arg
|
||||
elif isinstance(arg, nodes.StringExpression) or isinstance(arg, nodes.StringStatement):
|
||||
return arg.get_value()
|
||||
elif isinstance(arg, nodes.BoolStatement) or isinstance(arg, nodes.BoolExpression):
|
||||
return arg.get_value()
|
||||
elif isinstance(arg, nodes.ArrayStatement):
|
||||
elif isinstance(arg, mparser2.StringNode):
|
||||
return arg.value
|
||||
elif isinstance(arg, mparser2.BooleanNode):
|
||||
return arg.value
|
||||
elif isinstance(arg, mparser2.ArrayNode):
|
||||
return [self.reduce_single(curarg) for curarg in arg.args.arguments]
|
||||
elif isinstance(arg, nodes.IntStatement):
|
||||
elif isinstance(arg, mparser2.NumberNode):
|
||||
return arg.get_value()
|
||||
else:
|
||||
raise OptionException('Arguments may only be string, int, bool, or array of those.')
|
||||
|
||||
def reduce_arguments(self, args):
|
||||
assert(isinstance(args, nodes.Arguments))
|
||||
assert(isinstance(args, mparser2.ArgumentNode))
|
||||
if args.incorrect_order():
|
||||
raise OptionException('All keyword arguments must be after positional arguments.')
|
||||
reduced_pos = [self.reduce_single(arg) for arg in args.arguments]
|
||||
|
|
@ -136,12 +135,12 @@ class OptionInterpreter:
|
|||
return (reduced_pos, reduced_kw)
|
||||
|
||||
def evaluate_statement(self, node):
|
||||
if not isinstance(node, nodes.FunctionCall):
|
||||
if not isinstance(node, mparser2.FunctionNode):
|
||||
raise OptionException('Option file may only contain option definitions')
|
||||
func_name = node.get_function_name()
|
||||
func_name = node.func_name
|
||||
if func_name != 'option':
|
||||
raise OptionException('Only calls to option() are allowed in option files.')
|
||||
(posargs, kwargs) = self.reduce_arguments(node.arguments)
|
||||
(posargs, kwargs) = self.reduce_arguments(node.args)
|
||||
if 'type' not in kwargs:
|
||||
raise OptionException('Option call missing mandatory "type" keyword argument')
|
||||
opt_type = kwargs['type']
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ build system.
|
|||
Dependencies
|
||||
|
||||
Python 3.3: http://python.org
|
||||
Python-Ply: http://www.dabeaz.com/ply/ply.html
|
||||
Ninja: http://martine.github.com/ninja/
|
||||
|
||||
Installing from source
|
||||
|
|
|
|||
Loading…
Reference in New Issue