Chiebot-Mirror
/
meson
mirror of https://github.com/mesonbuild/meson.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Kill ply dependency dead.

Browse Source
pull/15/head
Jussi Pakkanen 11 years ago
parent 8a02b9da39
commit 4ab3dc440b
6 changed files with 27 additions and 548 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 10
      backends.py
  2. 18
      interpreter.py
  3. 291
      mparser.py
  4. 220
      nodes.py
  5. 35
      optinterpreter.py
  6. 1
      readme.txt

10
backends.py
Unescape View File

@ -12,8 +12,8 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
import parsertest as mparser2
import os, sys, re, pickle import os, sys, re, pickle
import nodes
import environment, mlog import environment, mlog
from meson_install import InstallData from meson_install import InstallData
from build import InvalidArguments from build import InvalidArguments
@ -39,8 +39,8 @@ def do_replacement(regex, line, confdata):
var = confdata.get(varname) var = confdata.get(varname)
if isinstance(var, str): if isinstance(var, str):
pass pass
elif isinstance(var, nodes.StringStatement): elif isinstance(var, mparser2.StringNode):
var = var.get_value() var = var.value
elif isinstance(var, int): elif isinstance(var, int):
var = str(var) var = str(var)
else: else:
@ -60,8 +60,8 @@ def do_mesondefine(line, confdata):
v = confdata.get(varname) v = confdata.get(varname)
except KeyError: except KeyError:
return '/* undef %s */\n' % varname return '/* undef %s */\n' % varname
if isinstance(v, nodes.BoolStatement): if isinstance(v, mparser2.BooleanNode):
v = v.get_value() v = v.value
if isinstance(v, bool): if isinstance(v, bool):
if v: if v:
return '#define %s\n' % varname return '#define %s\n' % varname

18
interpreter.py
Unescape View File

@ -12,9 +12,7 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
import mparser
import parsertest as mparser2 import parsertest as mparser2
import nodes
import environment import environment
import coredata import coredata
import dependencies import dependencies
@ -430,8 +428,6 @@ class CompilerHolder(InterpreterObject):
if len(args) != 1: if len(args) != 1:
raise InterpreterException('Run method takes exactly one positional argument.') raise InterpreterException('Run method takes exactly one positional argument.')
code = args[0] code = args[0]
if isinstance(code, nodes.StringStatement):
code = code.get_value()
testname = kwargs.get('name', '') testname = kwargs.get('name', '')
if not isinstance(testname, str): if not isinstance(testname, str):
raise InterpreterException('Testname argument must be a string.') raise InterpreterException('Testname argument must be a string.')
@ -509,8 +505,6 @@ class CompilerHolder(InterpreterObject):
testname = kwargs.get('name', '') testname = kwargs.get('name', '')
if not isinstance(testname, str): if not isinstance(testname, str):
raise InterpreterException('Testname argument must be a string.') raise InterpreterException('Testname argument must be a string.')
if isinstance(string, nodes.StringStatement):
string = string.value
if not isinstance(string, str): if not isinstance(string, str):
raise InterpreterException('Argument to compiles() must be a string') raise InterpreterException('Argument to compiles() must be a string')
result = self.compiler.compiles(string) result = self.compiler.compiles(string)
@ -526,8 +520,6 @@ class CompilerHolder(InterpreterObject):
if len(args) != 1: if len(args) != 1:
raise InterpreterException('has_header method takes exactly one argument.') raise InterpreterException('has_header method takes exactly one argument.')
string = args[0] string = args[0]
if isinstance(string, nodes.StringStatement):
string = string.value
if not isinstance(string, str): if not isinstance(string, str):
raise InterpreterException('Argument to has_header() must be a string') raise InterpreterException('Argument to has_header() must be a string')
haz = self.compiler.has_header(string) haz = self.compiler.has_header(string)
@ -1121,8 +1113,8 @@ class Interpreter():
self.build.global_args[lang] = args self.build.global_args[lang] = args
def flatten(self, args): def flatten(self, args):
if isinstance(args, nodes.StringStatement): if isinstance(args, mparser2.StringNode):
return args.get_value() return args.value
if isinstance(args, str): if isinstance(args, str):
return args return args
if isinstance(args, InterpreterObject): if isinstance(args, InterpreterObject):
@ -1132,8 +1124,8 @@ class Interpreter():
if isinstance(a, list): if isinstance(a, list):
rest = self.flatten(a) rest = self.flatten(a)
result = result + rest result = result + rest
elif isinstance(a, nodes.StringStatement): elif isinstance(a, mparser2.StringNode):
result.append(a.get_value()) result.append(a.value)
else: else:
result.append(a) result.append(a)
return result return result
@ -1283,7 +1275,7 @@ class Interpreter():
if method_name == 'extract_objects' and self.environment.coredata.unity: if method_name == 'extract_objects' and self.environment.coredata.unity:
raise InterpreterException('Single object files can not be extracted in Unity builds.') raise InterpreterException('Single object files can not be extracted in Unity builds.')
args = node.args args = node.args
if isinstance(obj, nodes.StringStatement): if isinstance(obj, mparser2.StringNode):
obj = obj.get_value() obj = obj.get_value()
if isinstance(obj, str): if isinstance(obj, str):
return self.string_method_call(obj, method_name, args) return self.string_method_call(obj, method_name, args)

291
mparser.py
Unescape View File

@ -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
Unescape View File

@ -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.')

35
optinterpreter.py
Unescape View File

@ -12,9 +12,8 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
import mparser import parsertest as mparser2
import coredata import coredata
import nodes
import os import os
forbidden_option_names = {'type': True, forbidden_option_names = {'type': True,
@ -89,41 +88,41 @@ class OptionInterpreter:
def process(self, option_file): def process(self, option_file):
try: try:
ast = mparser.build_ast(open(option_file, 'r').read()) ast = mparser2.Parser(open(option_file, 'r').read()).parse()
except coredata.MesonException as me: except coredata.MesonException as me:
me.file = option_file me.file = option_file
raise me raise me
if not isinstance(ast, nodes.CodeBlock): if not isinstance(ast, mparser2.CodeBlockNode):
e = OptionException('Option file is malformed.') e = OptionException('Option file is malformed.')
e.lineno = ast.lineno() e.lineno = ast.lineno()
raise e raise e
statements = ast.get_statements() for cur in ast.lines:
for cur in statements:
try: try:
self.evaluate_statement(cur) self.evaluate_statement(cur)
except Exception as e: except Exception as e:
e.lineno = cur.lineno() e.lineno = cur.lineno
e.colno = cur.colno
e.file = os.path.join('meson_options.txt') e.file = os.path.join('meson_options.txt')
raise e raise e
def reduce_single(self, arg): 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) return self.get_variable(arg.value)
elif isinstance(arg, str): elif isinstance(arg, str):
return arg return arg
elif isinstance(arg, nodes.StringExpression) or isinstance(arg, nodes.StringStatement): elif isinstance(arg, mparser2.StringNode):
return arg.get_value() return arg.value
elif isinstance(arg, nodes.BoolStatement) or isinstance(arg, nodes.BoolExpression): elif isinstance(arg, mparser2.BooleanNode):
return arg.get_value() return arg.value
elif isinstance(arg, nodes.ArrayStatement): elif isinstance(arg, mparser2.ArrayNode):
return [self.reduce_single(curarg) for curarg in arg.args.arguments] 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() return arg.get_value()
else: else:
raise OptionException('Arguments may only be string, int, bool, or array of those.') raise OptionException('Arguments may only be string, int, bool, or array of those.')
def reduce_arguments(self, args): def reduce_arguments(self, args):
assert(isinstance(args, nodes.Arguments)) assert(isinstance(args, mparser2.ArgumentNode))
if args.incorrect_order(): if args.incorrect_order():
raise OptionException('All keyword arguments must be after positional arguments.') raise OptionException('All keyword arguments must be after positional arguments.')
reduced_pos = [self.reduce_single(arg) for arg in args.arguments] reduced_pos = [self.reduce_single(arg) for arg in args.arguments]
@ -136,12 +135,12 @@ class OptionInterpreter:
return (reduced_pos, reduced_kw) return (reduced_pos, reduced_kw)
def evaluate_statement(self, node): 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') raise OptionException('Option file may only contain option definitions')
func_name = node.get_function_name() func_name = node.func_name
if func_name != 'option': if func_name != 'option':
raise OptionException('Only calls to option() are allowed in option files.') 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: if 'type' not in kwargs:
raise OptionException('Option call missing mandatory "type" keyword argument') raise OptionException('Option call missing mandatory "type" keyword argument')
opt_type = kwargs['type'] opt_type = kwargs['type']

1
readme.txt
Unescape View File

@ -4,7 +4,6 @@ build system.
Dependencies Dependencies
Python 3.3: http://python.org Python 3.3: http://python.org
Python-Ply: http://www.dabeaz.com/ply/ply.html
Ninja: http://martine.github.com/ninja/ Ninja: http://martine.github.com/ninja/
Installing from source Installing from source

Write Preview
Loading…
Cancel
Save