Source code

Revision control

Other Tools

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
from pyparsing import (CharsNotIn, Group, Forward, Literal, Suppress, Word,
QuotedString, ZeroOrMore, alphas, alphanums)
from string import Template
import re
# Grammar for CMake
comment = Literal('#') + ZeroOrMore(CharsNotIn('\n'))
quoted_argument = QuotedString('\"', '\\', multiline=True)
unquoted_argument = CharsNotIn('\n ()#\"\\')
argument = quoted_argument | unquoted_argument | Suppress(comment)
arguments = Forward()
arguments << (argument | (Literal('(') + ZeroOrMore(arguments) + Literal(')')))
identifier = Word(alphas, alphanums+'_')
command = Group(identifier + Literal('(') + ZeroOrMore(arguments) + Literal(')'))
file_elements = command | Suppress(comment)
cmake = ZeroOrMore(file_elements)
def extract_arguments(parsed):
"""Extract the command arguments skipping the parentheses"""
return parsed[2:len(parsed) - 1]
def match_block(command, parsed, start):
"""Find the end of block starting with the command"""
depth = 0
end = start + 1
endcommand = 'end' + command
while parsed[end][0] != endcommand or depth > 0:
if parsed[end][0] == command:
depth += 1
elif parsed[end][0] == endcommand:
depth -= 1
end = end + 1
if end == len(parsed):
print('error: eof when trying to match block statement: %s'
% parsed[start])
return end
def parse_if(parsed, start):
"""Parse if/elseif/else/endif into a list of conditions and commands"""
depth = 0
conditions = []
condition = [extract_arguments(parsed[start])]
start = start + 1
end = start
while parsed[end][0] != 'endif' or depth > 0:
command = parsed[end][0]
if command == 'if':
depth += 1
elif command == 'else' and depth == 0:
condition.append(parsed[start:end])
conditions.append(condition)
start = end + 1
condition = [['TRUE']]
elif command == 'elseif' and depth == 0:
condition.append(parsed[start:end])
conditions.append(condition)
condition = [extract_arguments(parsed[end])]
start = end + 1
elif command == 'endif':
depth -= 1
end = end + 1
if end == len(parsed):
print('error: eof when trying to match if statement: %s'
% parsed[start])
condition.append(parsed[start:end])
conditions.append(condition)
return end, conditions
def substs(variables, values):
"""Substitute variables into values"""
new_values = []
for value in values:
t = Template(value)
new_value = t.safe_substitute(variables)
# Safe substitute leaves unrecognized variables in place.
# We replace them with the empty string.
new_values.append(re.sub('\$\{\w+\}', '', new_value))
return new_values
def evaluate(variables, cache_variables, parsed):
"""Evaluate a list of parsed commands, returning sources to build"""
i = 0
sources = []
while i < len(parsed):
command = parsed[i][0]
arguments = substs(variables, extract_arguments(parsed[i]))
if command == 'foreach':
end = match_block(command, parsed, i)
for argument in arguments[1:]:
# ; is also a valid divider, why have one when you can have two?
argument = argument.replace(';', ' ')
for value in argument.split():
variables[arguments[0]] = value
cont_eval, new_sources = evaluate(variables, cache_variables,
parsed[i+1:end])
sources.extend(new_sources)
if not cont_eval:
return cont_eval, sources
elif command == 'function':
# for now we just execute functions inline at point of declaration
# as this is sufficient to build libaom
pass
elif command == 'if':
i, conditions = parse_if(parsed, i)
for condition in conditions:
if evaluate_boolean(variables, condition[0]):
cont_eval, new_sources = evaluate(variables,
cache_variables,
condition[1])
sources.extend(new_sources)
if not cont_eval:
return cont_eval, sources
break
elif command == 'include':
if arguments:
try:
print('including: %s' % arguments[0])
sources.extend(parse(variables, cache_variables, arguments[0]))
except IOError:
print('warning: could not include: %s' % arguments[0])
elif command == 'list':
try:
action = arguments[0]
variable = arguments[1]
values = arguments[2:]
if action == 'APPEND':
if variable not in variables:
variables[variable] = ' '.join(values)
else:
variables[variable] += ' ' + ' '.join(values)
except (IndexError, KeyError):
pass
elif command == 'option':
variable = arguments[0]
value = arguments[2]
# Allow options to be override without changing CMake files
if variable not in variables:
variables[variable] = value
elif command == 'return':
return False, sources
elif command == 'set':
variable = arguments[0]
values = arguments[1:]
# CACHE variables are not set if already present
try:
cache = values.index('CACHE')
values = values[0:cache]
if variable not in variables:
variables[variable] = ' '.join(values)
cache_variables.append(variable)
except ValueError:
variables[variable] = ' '.join(values)
# we need to emulate the behavior of these function calls
# because we don't support interpreting them directly
# see bug 1492292
elif command in ['set_aom_config_var', 'set_aom_detect_var']:
variable = arguments[0]
value = arguments[1]
if variable not in variables:
variables[variable] = value
cache_variables.append(variable)
elif command == 'set_aom_option_var':
# option vars cannot go into cache_variables
variable = arguments[0]
value = arguments[2]
if variable not in variables:
variables[variable] = value
elif command == 'add_asm_library':
try:
sources.extend(variables[arguments[1]].split(' '))
except (IndexError, KeyError):
pass
elif command == 'add_intrinsics_object_library':
try:
sources.extend(variables[arguments[3]].split(' '))
except (IndexError, KeyError):
pass
elif command == 'add_library':
for source in arguments[1:]:
sources.extend(source.split(' '))
elif command == 'target_sources':
for source in arguments[1:]:
sources.extend(source.split(' '))
elif command == 'MOZDEBUG':
print('>>>> MOZDEBUG: %s' % ' '.join(arguments))
i += 1
return True, sources
def evaluate_boolean(variables, arguments):
"""Evaluate a boolean expression"""
if not arguments:
return False
argument = arguments[0]
if argument == 'NOT':
return not evaluate_boolean(variables, arguments[1:])
if argument == '(':
i = 0
depth = 1
while depth > 0 and i < len(arguments):
i += 1
if arguments[i] == '(':
depth += 1
if arguments[i] == ')':
depth -= 1
return evaluate_boolean(variables, arguments[1:i])
def evaluate_constant(argument):
try:
as_int = int(argument)
if as_int != 0:
return True
else:
return False
except ValueError:
upper = argument.upper()
if upper in ['ON', 'YES', 'TRUE', 'Y']:
return True
elif upper in ['OFF', 'NO', 'FALSE', 'N', 'IGNORE', '', 'NOTFOUND']:
return False
elif upper.endswith('-NOTFOUND'):
return False
return None
def lookup_variable(argument):
# If statements can have old-style variables which are not demarcated
# like ${VARIABLE}. Attempt to look up the variable both ways.
try:
if re.search('\$\{\w+\}', argument):
try:
t = Template(argument)
value = t.substitute(variables)
try:
# Attempt an old-style variable lookup with the
# substituted value.
return variables[value]
except KeyError:
return value
except ValueError:
# TODO: CMake supports nesting, e.g. ${${foo}}
return None
else:
return variables[argument]
except KeyError:
return None
lhs = lookup_variable(argument)
if lhs is None:
# variable resolution failed, treat as string
lhs = argument
if len(arguments) > 1:
op = arguments[1]
if op == 'AND':
return evaluate_constant(lhs) and evaluate_boolean(variables, arguments[2:])
elif op == 'MATCHES':
rhs = lookup_variable(arguments[2])
if not rhs:
rhs = arguments[2]
return not re.match(rhs, lhs) is None
elif op == 'OR':
return evaluate_constant(lhs) or evaluate_boolean(variables, arguments[2:])
elif op == 'STREQUAL':
rhs = lookup_variable(arguments[2])
if not rhs:
rhs = arguments[2]
return lhs == rhs
else:
lhs = evaluate_constant(lhs)
if lhs is None:
lhs = lookup_variable(argument)
return lhs
def parse(variables, cache_variables, filename):
parsed = cmake.parseFile(filename)
cont_eval, sources = evaluate(variables, cache_variables, parsed)
return sources