def assign(self):
content = self._content
if content is not None:
definition = (
types.declaration((self.content_symbol,)),
content)
return types.definitions((definition,))
def assign(self):
content = self._content
if content is not None:
definition = (types.declaration(
(self.content_symbol, )), content)
return types.definitions((definition, ))
expr = self.expression(string[i:j])
except SyntaxError, e:
if string.rfind(';', i, j) > 0:
continue
raise e
break
defines.append((var, expr))
if j < 0:
break
i = j + 1
return types.definitions(defines)
def definition(self, string):
defs = self.definitions(string)
if len(defs) != 1:
raise ValueError, "Multiple definitions not allowed."
return defs[0]
def output(self, string):
"""String output; supports 'structure' keyword.
>>> class MockExpressionTranslator(ExpressionTranslator):
... def validate(self, string):
... return True
...
def definitions(self, string):
"""Semi-colon separated variable definitions.
>>> class MockExpressionTranslator(ExpressionTranslator):
... def tales(self, string, escape=None):
... if string == '' or ';' in string.replace("';'", "''"):
... raise SyntaxError()
... return types.value(string.strip())
>>> definitions = MockExpressionTranslator().definitions
Single define:
>>> definitions("variable expression")
definitions((declaration('variable'), value('expression')),)
Multiple defines:
>>> definitions("variable1 expression1; variable2 expression2")
definitions((declaration('variable1'), value('expression1')),
(declaration('variable2'), value('expression2')))
Defines are only split on semi-colon if a valid declaration is
available.
>>> definitions("variable1 ';'+expression1; variable2 expression2")
definitions((declaration('variable1'), value("';'+expression1")),
(declaration('variable2'), value('expression2')))
Tuple define:
>>> definitions("(variable1, variable2) (expression1, expression2)")
definitions((declaration('variable1', 'variable2'),
value('(expression1, expression2)')),)
Global defines:
>>> definitions("global variable expression")
definitions((declaration('variable', global_scope=True), value('expression')),)
>>> definitions("variable1 expression1; global variable2 expression2")
definitions((declaration('variable1'), value('expression1')),
(declaration('variable2', global_scope=True), value('expression2')))
Space, the 'in' operator and '=' may be used to separate
variable from expression.
>>> definitions("variable in expression")
definitions((declaration('variable'), value('expression')),)
>>> definitions("variable1 = expression1; variable2 = expression2")
definitions((declaration('variable1'), value('expression1')),
(declaration('variable2'), value('expression2')))
>>> definitions("variable1=expression1; variable2=expression2")
definitions((declaration('variable1'), value('expression1')),
(declaration('variable2'), value('expression2')))
A define clause that ends in a semicolon:
>>> definitions("variable expression;")
definitions((declaration('variable'), value('expression')),)
A define clause with a trivial expression (we do allow this):
>>> definitions("variable")
definitions((declaration('variable'), None),)
A proper define clause following one with a trivial expression:
>>> definitions("variable1 expression; variable2")
definitions((declaration('variable1'), value('expression')),
(declaration('variable2'), None))
"""
string = string.replace('\n', '').strip()
defines = []
i = 0
while i < len(string):
while string[i] == ' ':
i += 1
global_scope = False
if string[i:].startswith('global'):
global_scope = True
i += 6
# get variable definition
if string[i] == '(':
j = string.find(')', i+1)
if j == -1:
raise ValueError, "Invalid variable tuple definition (%s)." % string
var = self.declaration(string[i+1:j])
j += 1
else:
j = string.find('=', i + 1)
k = string.find(' ', i + 1)
if k < j and k > -1 or j < 0:
j = k
if j < 0:
var = self.declaration(string[i:])
j = len(string)
else:
var = self.declaration(string[i:j])
var.global_scope = global_scope
# get expression
i = j + len(string) - j - len(string[j:].lstrip())
token = string[i:]
if token.startswith('=='):
raise ValueError("Invalid variable definition (%s)." % string)
elif token.startswith('='):
i += 1
elif token.startswith('in '):
i += 3
try:
expr = self.tales(string[i:], ';')
j = -1
except SyntaxError:
expr = None
j = len(string)
while j > i:
j = string.rfind(';', i, j)
if j < 0:
# this is always a re-raise from right above
raise
try:
expr = self.tales(string[i:j], ';')
except SyntaxError:
if string.rfind(';', i, j) > 0:
continue
raise
break
defines.append((var, expr))
if j < 0:
break
i = j + 1
return types.definitions(defines)
