def __init__(self, lexer, parser, parent):
Token.__init__(self, 'If-condition', lexer, parser, parent)
# Expect an expression.
lexer.expect(self, 'keyword', 'if')
lexer.expect(self, 'whitespace')
self.expression = Expression(lexer, parser, parent)
self.mark_end()
# Body of the if block.
self.if_block = Exscript.interpreter.Code.Code(lexer, parser, parent)
self.elif_blocks = []
self.else_block = None
# If there is no "else" statement, just return.
lexer.skip(['whitespace', 'newline'])
if not lexer.next_if('keyword', 'else'):
return
# If the "else" statement is followed by an "if" (=elif),
# read the next if condition recursively and return.
lexer.skip(['whitespace', 'newline'])
if lexer.current_is('keyword', 'if'):
self.else_block = IfCondition(lexer, parser, parent)
return
# There was no "elif", so we handle a normal "else" condition here.
self.else_block = Exscript.interpreter.Code.Code(lexer, parser, parent)
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Enter', lexer, parser, parent)
lexer.expect(self, 'keyword', 'enter')
lexer.skip(['whitespace', 'newline'])
self.execute = Execute(lexer, parser, parent, '')
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'If-condition', lexer, parser, parent)
# Expect an expression.
lexer.expect(self, 'keyword', 'if')
lexer.expect(self, 'whitespace')
self.expression = Expression(lexer, parser, parent)
self.mark_end()
# Body of the if block.
self.if_block = Code.Code(lexer, parser, parent)
self.elif_blocks = []
self.else_block = None
# If there is no "else" statement, just return.
lexer.skip(['whitespace', 'newline'])
if not lexer.next_if('keyword', 'else'):
return
# If the "else" statement is followed by an "if" (=elif),
# read the next if condition recursively and return.
lexer.skip(['whitespace', 'newline'])
if lexer.current_is('keyword', 'if'):
self.else_block = IfCondition(lexer, parser, parent)
return
# There was no "elif", so we handle a normal "else" condition here.
self.else_block = Code.Code(lexer, parser, parent)
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Term', lexer, parser, parent)
self.term = None
self.lft = None
self.rgt = None
self.op = None
# Expect a term.
ttype, token = lexer.token()
if lexer.current_is('varname'):
if not parent.is_defined(token):
lexer.error('Undeclared variable %s' % token, self, ValueError)
self.term = Variable(lexer, parser, parent)
elif lexer.current_is('open_function_call'):
self.term = FunctionCall(lexer, parser, parent)
elif lexer.current_is('string_delimiter'):
self.term = String(lexer, parser, parent)
elif lexer.next_if('number'):
self.term = Number(token)
elif lexer.next_if('keyword', 'false'):
self.term = Number(0)
elif lexer.next_if('keyword', 'true'):
self.term = Number(1)
elif lexer.next_if('octal_number'):
self.term = Number(int(token[1:], 8))
elif lexer.next_if('hex_number'):
self.term = Number(int(token[2:], 16))
elif lexer.current_is('regex_delimiter'):
self.term = Regex(lexer, parser, parent)
else:
lexer.syntax_error('Expected term but got %s' % ttype, self)
self.mark_end()
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'FunctionCall', lexer, parser, parent)
self.funcname = None
self.arguments = []
# Extract the function name.
_, token = lexer.token()
lexer.expect(self, 'open_function_call')
self.funcname = token[:-1]
function = self.parent.get(self.funcname)
if function is None:
lexer.syntax_error('Undefined function %s' % self.funcname, self)
# Parse the argument list.
_, token = lexer.token()
while 1:
if lexer.next_if('close_bracket'):
break
self.arguments.append(Expression.Expression(lexer, parser, parent))
ttype, token = lexer.token()
if not lexer.next_if('comma') and not lexer.current_is('close_bracket'):
error = 'Expected separator or argument list end but got %s'
lexer.syntax_error(error % ttype, self)
if parser.secure_only and not hasattr(function, '_is_secure'):
msg = 'Use of insecure function %s is not permitted' % self.funcname
lexer.error(msg, self, PermissionError)
self.mark_end()
def __init__(self, lexer, parser, parent):
Token.__init__(self, "Enter", lexer, parser, parent)
lexer.expect(self, "keyword", "enter")
lexer.skip(["whitespace", "newline"])
self.execute = Execute(lexer, parser, parent, "")
def __init__(self, lexer, parser, parent):
Token.__init__(self, self.__class__.__name__, lexer, parser, parent)
# Create a grammar depending on the delimiting character.
tok_type, delimiter = lexer.token()
escaped_delimiter = '\\' + delimiter
data = r'[^\r\n\\' + escaped_delimiter + ']+'
delimiter_re = re.compile(escaped_delimiter)
data_re = re.compile(data)
grammar_with_delim = grammar_c[:]
grammar_with_delim.append(('string_data', data_re))
grammar_with_delim.append(('string_delimiter', delimiter_re))
lexer.set_grammar(grammar_with_delim)
# Begin parsing the string.
lexer.expect(self, 'string_delimiter')
self.string = ''
while 1:
if lexer.current_is('string_data'):
self.string += lexer.token()[1]
lexer.next()
elif lexer.current_is('escaped_data'):
self.string += self._escape(lexer.token()[1])
lexer.next()
elif lexer.next_if('string_delimiter'):
break
else:
ttype = lexer.token()[0]
lexer.syntax_error('Expected string but got %s' % ttype, self)
# Make sure that any variables specified in the command are declared.
string_re.sub(self.variable_test_cb, self.string)
self.mark_end()
lexer.restore_grammar()
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Term', lexer, parser, parent)
self.term = None
self.lft = None
self.rgt = None
self.op = None
# Expect a term.
ttype, token = lexer.token()
if lexer.current_is('varname'):
if not parent.is_defined(token):
lexer.error('Undeclared variable %s' % token, self, ValueError)
self.term = Variable(lexer, parser, parent)
elif lexer.current_is('open_function_call'):
self.term = FunctionCall(lexer, parser, parent)
elif lexer.current_is('string_delimiter'):
self.term = String(lexer, parser, parent)
elif lexer.next_if('number'):
self.term = Number(token)
elif lexer.next_if('keyword', 'false'):
self.term = Number(0)
elif lexer.next_if('keyword', 'true'):
self.term = Number(1)
elif lexer.next_if('octal_number'):
self.term = Number(int(token[1:], 8))
elif lexer.next_if('hex_number'):
self.term = Number(int(token[2:], 16))
elif lexer.current_is('regex_delimiter'):
self.term = Regex(lexer, parser, parent)
else:
lexer.syntax_error('Expected term but got %s' % ttype, self)
self.mark_end()
def __init__(self, lexer, parser, parent):
Token.__init__(self, self.__class__.__name__, lexer, parser, parent)
# Create a grammar depending on the delimiting character.
tok_type, delimiter = lexer.token()
escaped_delimiter = '\\' + delimiter
data = r'[^\r\n\\' + escaped_delimiter + ']+'
delimiter_re = re.compile(escaped_delimiter)
data_re = re.compile(data)
grammar_with_delim = grammar_c[:]
grammar_with_delim.append(('string_data', data_re))
grammar_with_delim.append(('string_delimiter', delimiter_re))
lexer.set_grammar(grammar_with_delim)
# Begin parsing the string.
lexer.expect(self, 'string_delimiter')
self.string = ''
while 1:
if lexer.current_is('string_data'):
self.string += lexer.token()[1]
lexer.next()
elif lexer.current_is('escaped_data'):
self.string += self._escape(lexer.token()[1])
lexer.next()
elif lexer.next_if('string_delimiter'):
break
else:
ttype = lexer.token()[0]
lexer.syntax_error('Expected string but got %s' % ttype, self)
# Make sure that any variables specified in the command are declared.
string_re.sub(self.variable_test_cb, self.string)
self.mark_end()
lexer.restore_grammar()
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Enter', lexer, parser, parent)
lexer.expect(self, 'keyword', 'enter')
lexer.skip(['whitespace', 'newline'])
self.execute = Execute(lexer, parser, parent, '')
def __init__(self, name, lexer, parser, parent=None, *args, **kwargs):
Token.__init__(self, name, lexer, parser, parent)
self.variables = kwargs.get('variables', {})
self.children = []
self.exit_requested = 0
for key in self.variables:
if key.find('.') < 0 and not key.startswith('_'):
assert type(self.variables[key]) == type([])
def __init__(self, name, lexer, parser, parent = None, *args, **kwargs):
Token.__init__(self, name, lexer, parser, parent)
self.variables = kwargs.get('variables', {})
self.children = []
self.exit_requested = 0
for key in self.variables:
if key.find('.') < 0 and not key.startswith('_'):
assert type(self.variables[key]) == type([])
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Expression', lexer, parser, parent)
# Parse the expression.
self.root = ExpressionNode(lexer, parser, parent)
# Reorder the tree according to the operator priorities.
self.prioritize(self.root)
self.mark_end()
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Expression', lexer, parser, parent)
# Parse the expression.
self.root = ExpressionNode(lexer, parser, parent)
# Reorder the tree according to the operator priorities.
self.prioritize(self.root)
self.mark_end()
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Extract', lexer, parser, parent)
self.varnames = []
self.variables = {}
self.append = False
self.source = None
if parser.no_prompt:
msg = "'extract' keyword does not work with --no-prompt"
lexer.syntax_error(msg, self)
# First expect a regular expression.
lexer.expect(self, 'keyword', 'extract')
lexer.expect(self, 'whitespace')
self.regex = Regex(lexer, parser, parent)
# Expect "as" keyword.
lexer.expect(self, 'whitespace')
if lexer.next_if('keyword', 'as'):
self.append = False
elif lexer.next_if('keyword', 'into'):
self.append = True
else:
_, token = lexer.token()
msg = 'Expected "as" or "into" but got %s' % token
lexer.syntax_error(msg, self)
# Expect a list of variable names.
while 1:
# Variable name.
lexer.expect(self, 'whitespace')
_, token = lexer.token()
lexer.expect(self, 'varname')
if token in self.variables:
lexer.syntax_error('Duplicate variable name %s', self)
self.varnames.append(token)
self.variables[token] = []
# Comma.
if lexer.next_if('comma'):
continue
break
self.parent.define(**self.variables)
if len(self.varnames) != self.regex.n_groups:
count = (len(self.varnames), self.regex.n_groups)
error = '%s variables, but regex has %s groups' % count
lexer.syntax_error(error, self)
# Handle the "from" keyword.
lexer.skip('whitespace')
if lexer.next_if('keyword', 'from'):
lexer.expect(self, 'whitespace')
self.source = Term(lexer, parser, parent)
self.mark_end()
def __init__(self, lexer, parser, parent):
Token.__init__(self, "Extract", lexer, parser, parent)
self.varnames = []
self.variables = {}
self.append = False
self.source = None
if parser.no_prompt:
msg = "'extract' keyword does not work with --no-prompt"
lexer.syntax_error(msg, self)
# First expect a regular expression.
lexer.expect(self, "keyword", "extract")
lexer.expect(self, "whitespace")
self.regex = Regex(lexer, parser, parent)
# Expect "as" keyword.
lexer.expect(self, "whitespace")
if lexer.next_if("keyword", "as"):
self.append = False
elif lexer.next_if("keyword", "into"):
self.append = True
else:
_, token = lexer.token()
msg = 'Expected "as" or "into" but got %s' % token
lexer.syntax_error(msg, self)
# Expect a list of variable names.
while 1:
# Variable name.
lexer.expect(self, "whitespace")
_, token = lexer.token()
lexer.expect(self, "varname")
if token in self.variables:
lexer.syntax_error("Duplicate variable name %s", self)
self.varnames.append(token)
self.variables[token] = []
# Comma.
if lexer.next_if("comma"):
continue
break
self.parent.define(**self.variables)
if len(self.varnames) != self.regex.n_groups:
count = (len(self.varnames), self.regex.n_groups)
error = "%s variables, but regex has %s groups" % count
lexer.syntax_error(error, self)
# Handle the "from" keyword.
lexer.skip("whitespace")
if lexer.next_if("keyword", "from"):
lexer.expect(self, "whitespace")
self.source = Term(lexer, parser, parent)
self.mark_end()
def __init__(self, lexer, parser, parent, command):
Token.__init__(self, 'Execute', lexer, parser, parent)
self.string = command
self.no_prompt = parser.no_prompt
self.strip_command = parser.strip_command
# The lexer has parsed the command, including a newline.
# Make the debugger point to the beginning of the command.
self.start -= len(command) + 1
self.mark_end(self.start + len(command))
# Make sure that any variables specified in the command are declared.
string_re.sub(self.variable_test_cb, command)
self.parent.define(__response__ = [])
def __init__(self, lexer, parser, parent, command):
Token.__init__(self, 'Execute', lexer, parser, parent)
self.string = command
self.no_prompt = parser.no_prompt
self.strip_command = parser.strip_command
# The lexer has parsed the command, including a newline.
# Make the debugger point to the beginning of the command.
self.start -= len(command) + 1
self.mark_end(self.start + len(command))
# Make sure that any variables specified in the command are declared.
string_re.sub(self.variable_test_cb, command)
self.parent.define(__response__ = [])
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Assign', lexer, parser, parent)
# Extract the variable name.
_, self.varname = lexer.token()
lexer.expect(self, 'varname')
lexer.expect(self, 'whitespace')
lexer.expect(self, 'assign')
lexer.expect(self, 'whitespace')
if self.varname.startswith('__'):
msg = 'Assignment to internal variable ' + self.varname
lexer.syntax_error(msg, self)
self.expression = Exscript.interpreter.Expression.Expression(lexer, parser, parent)
self.parent.define(**{self.varname: None})
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Assign', lexer, parser, parent)
# Extract the variable name.
_, self.varname = lexer.token()
lexer.expect(self, 'varname')
lexer.expect(self, 'whitespace')
lexer.expect(self, 'assign')
lexer.expect(self, 'whitespace')
if self.varname.startswith('__'):
msg = 'Assignment to internal variable ' + self.varname
lexer.syntax_error(msg, self)
self.expression = Expression.Expression(lexer, parser, parent)
self.parent.define(**{self.varname: None})
def __init__(self, lexer, parser, parent, parent_node=None):
# Skip whitespace before initializing the token to make sure that self.start
# points to the beginning of the expression (which makes for prettier error
# messages).
lexer.skip(["whitespace", "newline"])
Token.__init__(self, "ExpressionNode", lexer, parser, parent)
self.lft = None
self.rgt = None
self.op = None
self.op_type = None
self.parent_node = parent_node
# The "not" operator requires special treatment because it is
# positioned left of the term.
if not lexer.current_is("logical_operator", "not"):
self.lft = Term.Term(lexer, parser, parent)
# The expression may end already (a single term is also an
# expression).
lexer.skip(["whitespace", "newline"])
if (
not lexer.current_is("arithmetic_operator")
and not lexer.current_is("logical_operator")
and not lexer.current_is("comparison")
and not lexer.current_is("regex_delimiter")
):
self.mark_end()
return
# Expect the operator.
self.op_type, self.op = lexer.token()
if (
not lexer.next_if("arithmetic_operator")
and not lexer.next_if("logical_operator")
and not lexer.next_if("comparison")
and not lexer.next_if("regex_delimiter")
):
self.mark_end()
msg = "Expected operator but got %s" % self.op_type
lexer.syntax_error(msg, self)
# Expect the second term.
self.rgt = ExpressionNode(lexer, parser, parent, self)
self.mark_end()
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Fail', lexer, parser, parent)
self.expression = None
# "fail" keyword.
lexer.expect(self, 'keyword', 'fail')
lexer.expect(self, 'whitespace')
self.msg = Expression(lexer, parser, parent)
# 'If' keyword with an expression.
#token = lexer.token()
if lexer.next_if('keyword', 'if'):
lexer.expect(self, 'whitespace')
self.expression = Expression(lexer, parser, parent)
# End of expression.
self.mark_end()
lexer.skip(['whitespace', 'newline'])
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Fail', lexer, parser, parent)
self.expression = None
# "fail" keyword.
lexer.expect(self, 'keyword', 'fail')
lexer.expect(self, 'whitespace')
self.msg = Expression(lexer, parser, parent)
# 'If' keyword with an expression.
#token = lexer.token()
if lexer.next_if('keyword', 'if'):
lexer.expect(self, 'whitespace')
self.expression = Expression(lexer, parser, parent)
# End of expression.
self.mark_end()
lexer.skip(['whitespace', 'newline'])
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Append', lexer, parser, parent)
# First expect an expression.
lexer.expect(self, 'keyword', 'append')
lexer.expect(self, 'whitespace')
self.expr = Term(lexer, parser, parent)
# Expect "to" keyword.
lexer.expect(self, 'whitespace')
lexer.expect(self, 'keyword', 'to')
# Expect a variable name.
lexer.expect(self, 'whitespace')
_, self.varname = lexer.token()
lexer.expect(self, 'varname')
self.parent.define(**{self.varname: []})
self.mark_end()
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Append', lexer, parser, parent)
# First expect an expression.
lexer.expect(self, 'keyword', 'append')
lexer.expect(self, 'whitespace')
self.expr = Term(lexer, parser, parent)
# Expect "to" keyword.
lexer.expect(self, 'whitespace')
lexer.expect(self, 'keyword', 'to')
# Expect a variable name.
lexer.expect(self, 'whitespace')
_, self.varname = lexer.token()
lexer.expect(self, 'varname')
self.parent.define(**{self.varname: []})
self.mark_end()
def __init__(self, lexer, parser, parent, parent_node=None):
# Skip whitespace before initializing the token to make sure that self.start
# points to the beginning of the expression (which makes for prettier error
# messages).
lexer.skip(['whitespace', 'newline'])
Token.__init__(self, 'ExpressionNode', lexer, parser, parent)
self.lft = None
self.rgt = None
self.op = None
self.op_type = None
self.parent_node = parent_node
# The "not" operator requires special treatment because it is
# positioned left of the term.
if not lexer.current_is('logical_operator', 'not'):
self.lft = Term.Term(lexer, parser, parent)
# The expression may end already (a single term is also an
# expression).
lexer.skip(['whitespace', 'newline'])
if not lexer.current_is('arithmetic_operator') and \
not lexer.current_is('logical_operator') and \
not lexer.current_is('comparison') and \
not lexer.current_is('regex_delimiter'):
self.mark_end()
return
# Expect the operator.
self.op_type, self.op = lexer.token()
if not lexer.next_if('arithmetic_operator') and \
not lexer.next_if('logical_operator') and \
not lexer.next_if('comparison') and \
not lexer.next_if('regex_delimiter'):
self.mark_end()
msg = 'Expected operator but got %s' % self.op_type
lexer.syntax_error(msg, self)
# Expect the second term.
self.rgt = ExpressionNode(lexer, parser, parent, self)
self.mark_end()
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Loop', lexer, parser, parent)
self.during = None
self.until = None
self.thefrom = None
self.theto = None
self.list_variables = []
self.iter_varnames = []
# Expect one ore more lists.
lexer.expect(self, 'keyword', 'loop')
lexer.expect(self, 'whitespace')
if not lexer.current_is('keyword', 'while') and \
not lexer.current_is('keyword', 'until') and \
not lexer.current_is('keyword', 'from'):
self.list_variables = [Term(lexer, parser, parent)]
lexer.next_if('whitespace')
while lexer.next_if('comma'):
lexer.skip(['whitespace', 'newline'])
self.list_variables.append(Term(lexer, parser, parent))
lexer.skip(['whitespace', 'newline'])
# Expect the "as" keyword.
lexer.expect(self, 'keyword', 'as')
# The iterator variable.
lexer.next_if('whitespace')
_, iter_varname = lexer.token()
lexer.expect(self, 'varname')
parent.define(**{iter_varname: []})
self.iter_varnames = [iter_varname]
lexer.next_if('whitespace')
while lexer.next_if('comma'):
lexer.skip(['whitespace', 'newline'])
_, iter_varname = lexer.token()
lexer.expect(self, 'varname')
parent.define(**{iter_varname: []})
self.iter_varnames.append(iter_varname)
lexer.skip(['whitespace', 'newline'])
if len(self.iter_varnames) != len(self.list_variables):
error = '%s lists, but only %s iterators in loop' % (len(self.iter_varnames),
len(self.list_variables))
lexer.syntax_error(error, self)
# Check if this is a "from ... to ..." loop.
if lexer.next_if('keyword', 'from'):
lexer.expect(self, 'whitespace')
self.thefrom = Expression(lexer, parser, parent)
lexer.next_if('whitespace')
lexer.expect(self, 'keyword', 'to')
self.theto = Expression(lexer, parser, parent)
lexer.next_if('whitespace')
if lexer.next_if('keyword', 'as'):
lexer.next_if('whitespace')
_, iter_varname = lexer.token()
lexer.expect(self, 'varname')
lexer.next_if('whitespace')
else:
iter_varname = 'counter'
parent.define(**{iter_varname: []})
self.iter_varnames = [iter_varname]
# Check if this is a "while" loop.
if lexer.next_if('keyword', 'while'):
lexer.expect(self, 'whitespace')
self.during = Expression(lexer, parser, parent)
lexer.next_if('whitespace')
# Check if this is an "until" loop.
if lexer.next_if('keyword', 'until'):
lexer.expect(self, 'whitespace')
self.until = Expression(lexer, parser, parent)
lexer.next_if('whitespace')
# End of statement.
self.mark_end()
# Body of the loop block.
lexer.skip(['whitespace', 'newline'])
self.block = Code.Code(lexer, parser, parent)
def __init__(self, lexer, parser, parent):
Token.__init__(self, 'Variable', lexer, parser, parent)
self.varname = lexer.token()[1]
lexer.expect(self, 'varname')
self.mark_end()
