Beispiel #1
0
	def __init__(self, tw=None):
		super().__init__()

		# declare instance attributes
		self.cond = None
		self.then_st = S_Empty()
		self.else_st = S_Empty()

		# if created without a TW
		if tw is None:
			return

		# keyword
		tw.consume(T_IF)

		# paren with condition
		paren = tw.consume_paren(ParenType.EXPR)
		self.cond = expressions.parse( paren.expression )

		# the "then" branch
		self.then_st = tw.consume_statement()

		if tw.has(T_ELSE):
			# "else" branch
			tw.consume(T_ELSE)
			self.else_st = tw.consume_statement()
		else:
			# there is no "else" branch
			# add empty statement instead.
			self.else_st = S_Empty()
Beispiel #2
0
	def __init__(self, tw=None):
		super().__init__()

		# declare instance attributes
		self.cond = None
		self.body_st = None

		# if created without a TW
		if tw is None:
			return

		# keyword
		tw.consume(T_DO)

		# the loop body
		self.body_st = tw.consume_statement()

		# keyword
		tw.consume(T_WHILE)

		# paren with condition
		paren = tw.consume_paren(ParenType.EXPR)
		self.cond = expressions.parse( paren.expression )

		# end of the statement.
		tw.consume(T_Semicolon)
Beispiel #3
0
	def __init__(self, tw=None):
		super().__init__()

		# declare instance attributes
		self.name = None
		self.args = None

		# if created without a TW
		if tw is None:
			return

		# keyword
		tw.consume(T_CALL)

		# func name
		self.name = tw.consume(T_Name).value

		# arguments paren
		paren = tw.consume_paren(ParenType.ARGVALS)

		# collect all argument names
		atw = StTokenWalker(paren.tokens)
		self.args = []
		while atw.has_next():
			val = atw.consume(T_Expression)

			expr = expressions.parse(val)
			self.args.append(expr)

		tw.consume(T_Semicolon)
Beispiel #4
0
	def __init__(self, tw=None):
		super().__init__()

		# declare instance attributes
		self.var = None
		self.op = T_AssignOperator('=')
		self.value = None

		# if created without a TW
		if tw is None:
			return

		# keyword
		tw.consume(T_SET)

		# variable name
		name = tw.consume(T_Name).value
		index = None
		if tw.has(T_Bracket):
			br = tw.consume(T_Bracket)
			index = br.index

		self.var = E_Variable(name, index)

		# operator and value
		rv = tw.consume(T_Rvalue)
		self.op = rv.tokens[0]

		# convert T_Expression to Expression
		self.value = expressions.parse( rv.tokens[1] )

		# end of statement
		tw.consume(T_Semicolon)
Beispiel #5
0
    def __init__(self, parent, stmt):
        super(If, self).__init__(parent)

        # Create sub-scope
        self.get_ctx().sub_scope()

        self.condition = expressions.parse(self, stmt.children[0])
        self.if_stmt = parse.parse(self, stmt.children[1])
        self.else_stmt = parse.parse(self, stmt.children[2]) if len(
            stmt.children) == 3 else None
Beispiel #6
0
    def __init__(self, parent, stmt):
        super(Assignment, self).__init__(parent)

        if stmt.children[0].children[0].type != 'identifier':
            raise Exception("Expression not yet supported on left side of assignment")

        if len(stmt.children[0].children) == 2:
            self.left = Definition(self, stmt.children[0], terminator='')
        else:
            self.left = expressions.parse(self, stmt.children[0].children[0])

        # mark as type as to allow proper casts
        self.get_ctx().set('type', self.left.get_type())

        self.right = expressions.parse(self, stmt.children[1])

        print(self.left.identifier, self.left.get_type(), self.right.get_type())
        if self.left.get_type() != self.right.get_type():
            raise Exception("Assigning {assign} to variable of type {var}".format(
                var    = self.left.get_type(),
                assign = self.right.get_type(),
            ))
Beispiel #7
0
	def __init__(self, tw=None):
		super().__init__()

		# declare instance attributes
		self.value = None

		# if created without a TW
		if tw is None:
			return

		# keyword
		tw.consume(T_CASE)

		# the value
		expr = tw.consume(T_Expression)
		self.value = expressions.parse(expr)

		# a colon
		tw.consume(T_Colon)
Beispiel #8
0
	def __init__(self, tw=None):
		super().__init__()

		# declare instance attributes
		self.value = None
		self.body_st = None

		# if created without a TW
		if tw is None:
			return

		# keyword
		tw.consume(T_SWITCH)

		# paren with condition
		paren = tw.consume_paren(ParenType.EXPR)
		self.value = expressions.parse( paren.expression )

		# the switch body
		self.body_st = S_Block(tw)
Beispiel #9
0
	def __init__(self, tw=None):
		super().__init__()

		# declare instance attributes
		self.var = None
		self.value = None

		# if created without a TW
		if tw is None:
			return

		# keyword
		tw.consume(T_VAR)

		# variable name
		name = tw.consume(T_Name).value
		self.var = E_Variable(name)

		# optional rvalue
		if tw.has(T_Rvalue):

			# operator and value
			rv = tw.consume(T_Rvalue)
			assignOp = rv.tokens[0]
			expr = rv.tokens[1]

			# cannot use other than simple = in declaration
			# the variable isn't defined yet.
			if assignOp.value != '=':
				raise Exception(
					'Cannot use %s in variable declaration!'
					% assignOp.value
				)

			self.value = expressions.parse(expr)

		else:
			# synthetic zero value
			self.value = None

		tw.consume(T_Semicolon)
Beispiel #10
0
	def __init__(self, tw=None):
		super().__init__()

		# declare instance attributes
		self.value = None

		# if created without a TW
		if tw is None:
			return

		# keyword
		tw.consume(T_RETURN)

		if tw.has(T_Expression):
			# explicitly given return value
			expr = tw.consume(T_Expression)
			self.value = expressions.parse(expr)
		else:
			# a defualt return value
			self.value = E_Literal(T_Number('0'))

		tw.consume(T_Semicolon)
Beispiel #11
0
	def __init__(self, tw=None):
		super().__init__()

		# declare instance attributes
		self.init = None
		self.cond = None
		self.iter = None
		self.body_st = None

		# if created without a TW
		if tw is None:
			return

		# keyword
		tw.consume(T_FOR)

		# paren with init, cond, iter
		paren = tw.consume_paren(ParenType.FOR)
		self.cond = expressions.parse( paren.for_cond )

		# init statements
		itw = StTokenWalker(paren.for_init)
		self.init = []
		while itw.has_next():
			s = itw.consume_statement()
			self.init.append(s)

		# iter statements
		itw = StTokenWalker(paren.for_iter)
		self.iter = []
		while itw.has_next():
			s = itw.consume_statement()
			self.iter.append(s)

		# the loop body
		self.body_st = tw.consume_statement()
Beispiel #12
0
 def set_clause(self, str_):
     self.expr = exp.parse(str_)
Beispiel #13
0
    def __init__(self, parent, stmt):
        super(ExprStatement, self).__init__(parent)

        self.expr = expressions.parse(self, stmt)