def execute(self, code: str) -> InterpreterResult: """Execute some code preserving current context and stack :param code: Michelson code """ result = InterpreterResult(stdout=[]) stack_backup = deepcopy(self.stack) context_backup = deepcopy(self.context) try: code_section = CodeSection.match(michelson_to_micheline(code)) instructions = code_section.args[0].execute( self.stack, result.stdout, self.context) result.instructions = MichelineSequence([instructions]) result.stack = self.stack except (MichelsonParserError, MichelsonRuntimeError) as e: if self.context.debug: raise self.stack = stack_backup self.context = context_backup result.stdout.append(e.format_stdout()) result.error = e return result
def _execute_code(self, code, parameter=None, storage=None) -> None: micheline = michelson_to_micheline(code) sequence = MichelineSequence.match(micheline) program = MichelsonProgram.create(sequence)( 'default', parameter or ParameterSection(UnitType()), storage or StorageSection(UnitType()) ) program.execute(self.stack, self.stdout, self.context)
def to_literal(self) -> Type[Micheline]: if self.ptr is not None: return MichelineLiteral.create(self.ptr) else: return MichelineSequence.create_type(args=[ EltLiteral.create_type( args=[k.to_literal(), v.to_literal()]) for k, v in self.items ])
def _find_stack_items(self, instructions: MichelineSequence, stack: MichelsonStack) -> Optional[List[MichelsonInstruction]]: for operation in instructions.items[::-1]: items = getattr(operation, 'items', None) if isinstance(items, list): stack_items = self._find_stack_items(MichelineSequence(items), stack) if stack_items: return stack_items if not isinstance(operation, MichelsonInstruction): continue if operation.stack_items_added: return cast(List[MichelsonInstruction], stack.items[-operation.stack_items_added :]) return None
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext): left, lambda_ = cast(Tuple[MichelsonType, LambdaType], stack.pop2()) lambda_.assert_type_in(LambdaType) lambda_.args[0].assert_type_in(PairType) left_type, right_type = lambda_.args[0].args left.assert_type_equal(left_type) new_value = MichelineSequence.create_type(args=[ PushInstruction.create_type(args=[left_type, left.to_literal()]), PairInstruction, lambda_.value ]) res = LambdaType.create_type(args=[right_type, lambda_.args[1]])(new_value) # type: ignore stack.push(res) stdout.append(format_stdout(cls.prim, [left, lambda_], [res])) # type: ignore return cls(stack_items_added=1)
def to_literal(self) -> Type[Micheline]: return MichelineSequence.create_type(args=[ EltLiteral.create_type( args=[k.to_literal(), v.to_literal()]) for k, v in self.items ])
def to_literal(self) -> Type[Micheline]: if self.ptr is not None: return MichelineLiteral.create(self.ptr) else: return MichelineSequence.create_type(args=[])
def match(expr) -> Type['MichelsonProgram']: seq = cast(Type[MichelineSequence], MichelineSequence.match(expr)) if not issubclass(seq, MichelineSequence): raise Exception(f'Expected sequence, got {seq.prim}') return MichelsonProgram.create(seq)
def to_literal(self) -> Type[Micheline]: return MichelineSequence.create_type( args=[item.to_literal() for item in self.items])
def match(expr) -> Type['MichelsonProgram']: seq = cast(Type[MichelineSequence], MichelineSequence.match(expr)) assert issubclass(seq, MichelineSequence), f'expected sequence, got {seq.prim}' return MichelsonProgram.create(seq)