Wsrtjtyk

I am making an fantasy programming language for a game, and so I am writing the language and interpreter in python. The language works as a stream of a commands, each one is interpreted each "step." A string of code is inputted, and converted to a list of command objects. The interpreter handles the commands, but some of the commands need to be able to access attributes of the interpreter.

For example, the interpreter keeps track of the active command (numbered from the first command) so a goto command would need to change the active command. The current way I do this is pass the data into a command, it is modified, and the interpreter sets it's attribute equal to it.

self.current = active.evaluate(self.current)

This sets the current command number equal to the active command evaluated with the current command number inputted. This is how the whole block looks:

        if active.complete():  # on command completion

            type = active.return_type  # get return type

            # passes in requested data to modify

            if type == "var":  # changing var stream

                self.var = active.evaluate(self.var)

            elif type == "stream":  # changing packet stream

                self.stream = active.evaluate(self.stream)

            elif type == "current":  # changing current packet

                self.current = active.evaluate(self.current)

            elif type == "value":  # returns argument for next command

                self.holder = active.evaluate(self.var)

                self.resolve = True

            elif type == "none":

                active.evaluate()

This seems like a inconvient way of doing things, is there a better way of modifying class attributes from inside of class?

My simple answer would be to simply pass in the interpreter itself and let the object change the relevant property on the interpreter. If you didn't want to break too much from the format you already have, you could give the evaluate() function two arguments:

def evaluate(interpreter, field_name):

    interpreter.setattr(field_name, some_value)

which you would then call like

active.evaluate(self, "var")

However, this seems like a good place to implement polymorphism, which would solve both the problem you're asking about and eliminate the need for a growing stack of if statements.

First, let's say you have a superclass for commands:

class Command:

    def complete():

        # do something, return a boolean



    def evaluate(interpreter):

        raise NotImplementedException()

Currently, it seems like you're using the command's return_type to change what you're doing with the command. But why not simply detect what type of command is going to be run, and instantiate a different subclass with different behavior accordingly?

class GotoCommand(Command):

    def evaluate(interpreter):

        interpreter.current = some_value



class PacketCommand(Command):

    def evaluate(interpreter):

        interpreter.stream = some_other_value



...

after which you could just call active.evaluate(self) in the interpreter, without even having to care what kind of command it is.