Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Interpreter Environment Change Diff

Created 4 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

113 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

111 lines

# Top level function that interprets an entire program. It creates the

# initial environment that's used for storing variables.

def interpret_program(model):

# Make the initial environment (a dict). The environment is

# where you will create and store variables.

env = {'constants':{}, 'variables':{}}

env = {}

for structure in model.statements:

interpret(structure, env)

# Internal function to interpret a node in the environment. You need

# to expand to cover all of the classes in the model.py file.

def interpret(node, env):

# Expand to check for different node types

if isinstance(node, Integer):

return int(node.value)

elif isinstance(node, Float):

return node.value

elif isinstance(node, BinaryOperator):

if node.op == '*':

return interpret(node.left, env) * interpret(node.right, env)

elif node.op == '/':

return interpret(node.left, env) / interpret(node.right, env)

elif node.op == '+':

return interpret(node.left, env) + interpret(node.right, env)

elif node.op == '-':

return interpret(node.left, env) - interpret(node.right, env)

elif isinstance(node, Comparison):

if node.op == '>':

return interpret(node.left, env) > interpret(node.right, env)

elif node.op == '<':

return interpret(node.left, env) < interpret(node.right, env)

elif node.op == '==':

return interpret(node.left, env) == interpret(node.right, env)

elif node.op == '>=':

return interpret(node.left, env) >= interpret(node.right, env)

elif node.op == '<=':

return interpret(node.left, env) <= interpret(node.right, env)

elif node.op == '!=':

return interpret(node.left, env) != interpret(node.right, env)

elif isinstance(node, Print):

print(interpret(node.value, env))

elif isinstance(node, VariableAssignment):

# if node.type.string_representation == the start of type checking

env[str(node.name)] = {"value": interpret(node.value, env), "mutable": True}

env['variables'][str(node.name)] = interpret(node.value, env)

return Unit()

elif isinstance(node, ConstantAssignment):

env['constants'][str(node.name)] = interpret(node.value, env)

env[str(node.name)] = {"value": interpret(node.value, env), "mutable": False}

return Unit()

elif isinstance(node, VariableDeclaration):

env['variables'][str(node.name)] = "WABBITASSIGNMENTINWAITING"

env[str(node.name)] = {"value": None, "mutable": True}

return Unit()

elif isinstance(node, VariableReAssignment):

if str(node.name) in env['variables'].keys():

if str(node.name) in env.keys():

env['variables'][str(node.name)] = interpret(node.value, env)

if not env[str(node.name)]['mutable']:

elif str(node.name) in env['constants'].keys():

raise RuntimeError("Cannot reassign the value of a constant")

else:

env[str(node.name)] = interpret(node.value, env)

else:

raise RuntimeError(f"{node.name} not found for reassignment")

return Unit()

elif isinstance(node, Name):

if node.name in env['variables'].keys():

if node.name in env.keys():

return env['variables'].get(node.name)

return env.get(node.name).get('value')

elif node.name in env['constants'].keys():

return env['constants'].get(str(node.name))

else:

raise RuntimeError(f"'{node.name}' not defined")

elif isinstance(node, Negative):

# gotta check if its type that can be negative

return interpret(node.value, env) * -1

elif isinstance(node, Conditional):

if interpret(node.if_condition, env):

result = interpret(node.if_block, env)

if isinstance(result, Break):

return Break()

else:

if node.else_block:

result = interpret(node.else_block, env)

if isinstance(result, Break):

return Break()

elif isinstance(node, WhileLoop):

if interpret(node.while_condition, env):

result = interpret(node.while_block, env)

if not isinstance(result, Break):

interpret(node, env)

else:

return Unit()

elif isinstance(node, Block):

for statement in node.statements:

maybe_flow_interruptor = interpret(statement, env)

if isinstance(maybe_flow_interruptor, Continue):

return Unit()

elif isinstance(maybe_flow_interruptor, Break):

return Break()

return Unit()

elif isinstance(node, CompoundExpression):

final_statement = None

for statement in node.statements:

final_statement = interpret(statement, env)

return final_statement

elif isinstance(node, Break):

return Break()

elif isinstance(node, Continue):

return Continue()

elif isinstance(node, WabbitType):

return Unit()

elif isinstance(node, WabbitBoolean):

return node.value

elif isinstance(node, Character):

return str(node.value)

else:

raise RuntimeError(f"Can't interpret {node}")

Saved diffs

Original text

Open file

# Top level function that interprets an entire program. It creates the
# initial environment that's used for storing variables.

def interpret_program(model):
    # Make the initial environment (a dict).  The environment is
    # where you will create and store variables.
    env = {'constants':{}, 'variables':{}}
    for structure in model.statements:
        interpret(structure, env)

# Internal function to interpret a node in the environment.  You need
# to expand to cover all of the classes in the model.py file.

def interpret(node, env):
    # Expand to check for different node types
    if isinstance(node, Integer):
        return int(node.value)
    elif isinstance(node, Float):
        return node.value
    elif isinstance(node, BinaryOperator):
        if node.op == '*':
            return interpret(node.left, env) * interpret(node.right, env)
        elif node.op == '/':
            return interpret(node.left, env) / interpret(node.right, env)
        elif node.op == '+':
            return interpret(node.left, env) + interpret(node.right, env)
        elif node.op == '-':
            return interpret(node.left, env) - interpret(node.right, env)
    elif isinstance(node, Comparison):
        if node.op == '>':
            return interpret(node.left, env) > interpret(node.right, env)
        elif node.op == '<':
            return interpret(node.left, env) < interpret(node.right, env)
        elif node.op == '==':
            return interpret(node.left, env) == interpret(node.right, env)
        elif node.op == '>=':
            return interpret(node.left, env) >= interpret(node.right, env)
        elif node.op == '<=':
            return interpret(node.left, env) <= interpret(node.right, env)
        elif node.op == '!=':
            return interpret(node.left, env) != interpret(node.right, env)
    elif isinstance(node, Print):
        print(interpret(node.value, env))
    elif isinstance(node, VariableAssignment):
        # if node.type.string_representation == the start of type checking
        env['variables'][str(node.name)] = interpret(node.value, env)
        return Unit()
    elif isinstance(node, ConstantAssignment):
        env['constants'][str(node.name)] = interpret(node.value, env)
        return Unit()
    elif isinstance(node, VariableDeclaration):
        env['variables'][str(node.name)] = "WABBITASSIGNMENTINWAITING"
        return Unit()
    elif isinstance(node, VariableReAssignment):
        if str(node.name) in env['variables'].keys():
            env['variables'][str(node.name)] = interpret(node.value, env)
        elif str(node.name) in env['constants'].keys():
            raise RuntimeError("Cannot reassign the value of a constant")
        else:
            raise RuntimeError(f"{node.name} not found for reassignment")
        return Unit()
    elif isinstance(node, Name):
        if node.name in env['variables'].keys():
            return env['variables'].get(node.name)
        elif node.name in env['constants'].keys():
            return env['constants'].get(str(node.name))
        else:
            raise RuntimeError(f"'{node.name}' not defined")
    elif isinstance(node, Negative):
        # gotta check if its  type that can be negative
        return interpret(node.value, env) * -1
    elif isinstance(node, Conditional):
        if interpret(node.if_condition, env):
            result = interpret(node.if_block, env)
            if isinstance(result, Break):
                return Break()
        else:
            if node.else_block:
                result = interpret(node.else_block, env)
                if isinstance(result, Break):
                    return Break()
    elif isinstance(node, WhileLoop):
        if interpret(node.while_condition, env):
            result = interpret(node.while_block, env)
            if not isinstance(result, Break):
                interpret(node, env)
            else:
                return Unit()
    elif isinstance(node, Block):
        for statement in node.statements:
            maybe_flow_interruptor = interpret(statement, env)
            if isinstance(maybe_flow_interruptor, Continue):
                return Unit()
            elif isinstance(maybe_flow_interruptor, Break):
                return Break()
        return Unit()
    elif isinstance(node, CompoundExpression):
        final_statement = None
        for statement in node.statements:
            final_statement = interpret(statement, env)
        return final_statement
    elif isinstance(node, Break):
        return Break()
    elif isinstance(node, Continue):
        return Continue()
    elif isinstance(node, WabbitType):
        return Unit()
    elif isinstance(node, WabbitBoolean):
        return node.value
    elif isinstance(node, Character):
        return str(node.value)
    else:
        raise RuntimeError(f"Can't interpret {node}")

Changed text

Open file

# Top level function that interprets an entire program. It creates the
# initial environment that's used for storing variables.

def interpret_program(model):
    # Make the initial environment (a dict).  The environment is
    # where you will create and store variables.
    env = {}
    for structure in model.statements:
        interpret(structure, env)

# Internal function to interpret a node in the environment.  You need
# to expand to cover all of the classes in the model.py file.

def interpret(node, env):
    # Expand to check for different node types
    if isinstance(node, Integer):
        return int(node.value)
    elif isinstance(node, Float):
        return node.value
    elif isinstance(node, BinaryOperator):
        if node.op == '*':
            return interpret(node.left, env) * interpret(node.right, env)
        elif node.op == '/':
            return interpret(node.left, env) / interpret(node.right, env)
        elif node.op == '+':
            return interpret(node.left, env) + interpret(node.right, env)
        elif node.op == '-':
            return interpret(node.left, env) - interpret(node.right, env)
    elif isinstance(node, Comparison):
        if node.op == '>':
            return interpret(node.left, env) > interpret(node.right, env)
        elif node.op == '<':
            return interpret(node.left, env) < interpret(node.right, env)
        elif node.op == '==':
            return interpret(node.left, env) == interpret(node.right, env)
        elif node.op == '>=':
            return interpret(node.left, env) >= interpret(node.right, env)
        elif node.op == '<=':
            return interpret(node.left, env) <= interpret(node.right, env)
        elif node.op == '!=':
            return interpret(node.left, env) != interpret(node.right, env)
    elif isinstance(node, Print):
        print(interpret(node.value, env))
    elif isinstance(node, VariableAssignment):
        env[str(node.name)] = {"value": interpret(node.value, env), "mutable": True}
        return Unit()
    elif isinstance(node, ConstantAssignment):
        env[str(node.name)] = {"value": interpret(node.value, env), "mutable": False}
        return Unit()
    elif isinstance(node, VariableDeclaration):
        env[str(node.name)] = {"value": None, "mutable": True}
        return Unit()
    elif isinstance(node, VariableReAssignment):
        if str(node.name) in env.keys():
            if not env[str(node.name)]['mutable']:
               raise RuntimeError("Cannot reassign the value of a constant")
            else:
                env[str(node.name)] = interpret(node.value, env)
        else:
            raise RuntimeError(f"{node.name} not found for reassignment")
        return Unit()
    elif isinstance(node, Name):
        if node.name in env.keys():
            return env.get(node.name).get('value')
        else:
            raise RuntimeError(f"'{node.name}' not defined")
    elif isinstance(node, Negative):
        # gotta check if its  type that can be negative
        return interpret(node.value, env) * -1
    elif isinstance(node, Conditional):
        if interpret(node.if_condition, env):
            result = interpret(node.if_block, env)
            if isinstance(result, Break):
                return Break()
        else:
            if node.else_block:
                result = interpret(node.else_block, env)
                if isinstance(result, Break):
                    return Break()
    elif isinstance(node, WhileLoop):
        if interpret(node.while_condition, env):
            result = interpret(node.while_block, env)
            if not isinstance(result, Break):
                interpret(node, env)
            else:
                return Unit()
    elif isinstance(node, Block):
        for statement in node.statements:
            maybe_flow_interruptor = interpret(statement, env)
            if isinstance(maybe_flow_interruptor, Continue):
                return Unit()
            elif isinstance(maybe_flow_interruptor, Break):
                return Break()
        return Unit()
    elif isinstance(node, CompoundExpression):
        final_statement = None
        for statement in node.statements:
            final_statement = interpret(statement, env)
        return final_statement
    elif isinstance(node, Break):
        return Break()
    elif isinstance(node, Continue):
        return Continue()
    elif isinstance(node, WabbitType):
        return Unit()
    elif isinstance(node, WabbitBoolean):
        return node.value
    elif isinstance(node, Character):
        return str(node.value)
    else:
        raise RuntimeError(f"Can't interpret {node}")