Project 7 - Virtual Machine.tar

CodeWriter.py0100777000000000000000000002615014146411272010443 0ustar00"""This file is part of nand2tetris, as taught in The Hebrew University,
and was written by Aviv Yaish according to the specifications given in  
https://www.nand2tetris.org (Shimon Schocken and Noam Nisan, 2017)
and as allowed by the Creative Common Attribution-NonCommercial-ShareAlike 3.0 
Unported License (https://creativecommons.org/licenses/by-nc-sa/3.0/).
"""
import os
import typing
from Parser import *

operator_dict = {
    "and": "&",
    "add": "+",
    "or": "|",
    "sub": "-"
}

shift_dict = {
    "shiftleft": "<<",
    "shiftright": ">>"
}

compare_dict = {
    "eq": "JEQ",
    "gt": "JLT",
    "lt": "JGT"
}

self_switch_dict = {
    "neg": "-",
    "not": "!"
}

segment_dict = {
    "local": "LCL",
    "argument": "ARG",
    "this": "THIS",
    "that": "THAT",
    "temp": "R5",
    "pointer": "R3"
}


class CodeWriter:
    """Translates VM commands into Hack assembly code."""

    def __init__(self, output_stream: typing.TextIO) -> None:
        """Initializes the CodeWriter.

        Args:
            output_stream (typing.TextIO): output stream.
        """
        # Your code goes here!
        self.out_file = output_stream
        self.num_of_func = 0
        self.file_name = ""


    def read_file(self,  input_file: typing.TextIO):
        p = Parser(input_file)
        while p.has_more_commands():
            c_type = p.command_type()
            if c_type == "C_ARITHMETIC":
                self.write_arithmetic(p.arg1())
            if c_type == "C_PUSH" or c_type == "C_POP":
                self.write_push_pop(p.arg1(), p.segment(),
                                    p.segment_index())
            p.advance()
        c_type = p.command_type()
        if c_type == "C_ARITHMETIC":
            self.write_arithmetic(p.arg1())
        if c_type == "C_PUSH" or c_type == "C_POP":
            self.write_push_pop(p.arg1(), p.segment(),
                                p.segment_index())


    def set_file_name(self, filename: str) -> None:
        """Informs the code writer that the translation of a new VM file is 
        started.

        Args:
            filename (str): The name of the VM file.
        """
        self.file_name, input_extension = os.path.splitext(
            os.path.basename(filename))


    def write_arithmetic(self, command: str) -> None:
        """Writes the assembly code that is the translation of the given 
        arithmetic command.

        Args:
            command (str): an arithmetic command.
        """
        # Your code goes here!

        if command in operator_dict:

            # sets pointer to first value
            self.out_file.write("@SP\n"
                                "A=M\n"
                                "A=A-1\n")

            # saves first value and goes to next value and
            # adds it to next value
            self.out_file.write("D=M\n"
                                "A=A-1\n"
                                "M=M" + operator_dict.get(command) + "D\n")

            # lowers value of pointer
            self.out_file.write("@SP\n"
                                "M=M-1\n")

        elif command in shift_dict:

            # sets pointer to first value
            self.out_file.write("@SP\n"
                                "A=M\n"
                                "A=A-1\n")

            # saves first value and goes to next value and
            # adds it to next value
            self.out_file.write(
                                "M="+ shift_dict.get(command) +"M\n")

        elif command in compare_dict:
            # sets pointer to first value
            self.out_file.write("@SP\n"
                                "M=M-1\n"
                                "A=M\n")
            # check if first value is positive, and if so jump
            self.out_file.write("D=M\n"
                                "@A_POS" + str(self.num_of_func) + "\n"
                                                                   "D;JGT\n")
            # check if the second value is positive, and if so jump
            self.out_file.write("@SP\n"
                                "A=M-1\n"
                                "D=M\n"
                                "@B_POS" + str(self.num_of_func) + "\n"
                                                                   "D;JGT\n")
            # a and b <= 0
            self.out_file.write("@SAME_SIGN" + str(self.num_of_func) + "\n"
                                                                       "0;JMP\n")
            # a > 0
            self.out_file.write("(A_POS" + str(self.num_of_func) + ")\n")
            # check if b is positive
            self.out_file.write("@SP\n"
                                "A=M-1\n"
                                "D=M\n"
                                "@SAME_SIGN" + str(self.num_of_func) + "\n"
                                                                       "D;JGT\n")
            # a > 0; b <= 0
            self.out_file.write("@SP\n"
                                "A=M\n"
                                "D=M\n"
                                "@TRUE" + str(self.num_of_func) + "\n"
                                                                  "D;" + compare_dict.get(
                command) + "\n"
                           "@FALSE" + str(self.num_of_func) + "\n"
                                                              "0;JMP\n")
            # b > 0, a <= 0
            self.out_file.write("(B_POS" + str(self.num_of_func) + ")\n"
                                                                   "@SP\n"
                                                                   "A=M\n"
                                                                   "D=M\n"
                                                                   "@TRUE" + str(
                self.num_of_func) + "\n"
                                    "D;" + compare_dict.get(command) + "\n"
                                                                       "@FALSE" + str(
                self.num_of_func) + "\n"
                                    "0;JMP\n")
            # a and b have the same sign, compare the numbers
            self.out_file.write("(SAME_SIGN" + str(self.num_of_func) + ")\n"
                                                                       "@SP\n"
                                                                       "A=M\n"
                                                                       "D=M-D\n"
                                                                       "@TRUE" + str(
                self.num_of_func) + "\n"
                                    "D;" + compare_dict.get(command) + "\n"
                                                                       "@FALSE" + str(
                self.num_of_func) + "\n"
                                    "0;JMP\n")
            # if the output is true
            self.out_file.write("(TRUE" + str(self.num_of_func) + ")\n"
                                                                  "@SP\n"
                                                                  "A=M-1\n"
                                                                  "M=-1\n"
                                                                  "@END" + str(
                self.num_of_func) + "\n"
                                    "0;JMP\n")
            self.out_file.write("(FALSE" + str(self.num_of_func) + ")\n"
                                                                   "@SP\n"
                                                                   "A=M-1\n"
                                                                   "M=0\n")
            # end commands and lowers value of pointer
            self.out_file.write("(END" + str(self.num_of_func) + ")\n")
            self.num_of_func += 1

        elif command in self_switch_dict:
            # sets pointer to first value
            self.out_file.write("@SP\nA=M\nA=A-1\nM=" +
                                self_switch_dict.get(command) + "M\n")

    def write_push_pop(self, command: str, segment: str, index: int) -> None:
        """Writes the assembly code that is the translation of the given 
        command, where command is either C_PUSH or C_POP.

        Args:
            command (str): "C_PUSH" or "C_POP".
            segment (str): the memory segment to operate on.
            index (int): the index in the memory segment.
        """
        # Your code goes here!
        # command_type, location, destination = command.split(SPACE)

        if command == "pop":

            # pops a value from the stack
            self.out_file.write("@SP\nA=M-1\nD=M\n")

            # lowers the value of the SP
            self.out_file.write("@SP\nM=M-1\n")

            # creates a location to hold the value
            # until we set the pointer location
            self.out_file.write("@pop_holder\nM=D\n")

            # gets the location above the stack we need to push
            self.out_file.write("@" + str(index) + "\n" + "D=A\n")

            # sets the location we need to the value from
            self.out_file.write("@LOC_HOLDER\nM=D\n")

            if segment in segment_dict:

                self.out_file.write("@" + segment_dict.get(segment)
                                    + "\nD=")
            else:
                self.out_file.write("@" + self.file_name + "." + str(index)
                                    + "\nD=")

            # checks if we are dealing with a pointer location or addressing
            if segment != "temp" and segment != "pointer":
                self.out_file.write("M\n")
            else:
                self.out_file.write("A\n")

            self.out_file.write("@LOC_HOLDER\nM=M+D\n")
            self.out_file.write("@pop_holder\nD=M\n")
            self.out_file.write("@LOC_HOLDER\nA=M\nM=D\n")

        # if we are dealing with a push command
        elif command == "push":

            # gets a value for the a destination since we cannot
            # use number bigger than one will just use it as a
            # pointer location
            self.out_file.write("@" + str(index) + "\n" + "D=A\n")

            if segment != "constant":
                # sets the location we need to the value from
                self.out_file.write("@LOC_HOLDER\nM=D\n")

                if segment in segment_dict:

                    self.out_file.write(
                        "@" + segment_dict.get(segment)
                        + "\nD=")
                else:
                    self.out_file.write(
                        "@" + self.file_name + "." + str(index)
                        + "\nD=")

                # checks if we are dealing with a pointer location or addressing
                if segment != "temp" and segment != "pointer":
                    self.out_file.write("M\n")
                else:
                    self.out_file.write("A\n")

                self.out_file.write("@LOC_HOLDER\nM=M+D\n")
                self.out_file.write("A=M\nD=M\n")

            # pushes the value of D onto the stack
            self.out_file.write("@SP\nAM=M+1\nA=A-1\nM=D\n")

            # raises the location of the stack pointer
            # self.out_file.write("@SP\nM=M+1\n")

    def close(self) -> None:
        """Closes the output file."""
        # Your code goes here!
        self.out_file.close()
Main.py0100777000000000000000000000424414145165470007265 0ustar00"""This file is part of nand2tetris, as taught in The Hebrew University,
and was written by Aviv Yaish according to the specifications given in  
https://www.nand2tetris.org (Shimon Schocken and Noam Nisan, 2017)
and as allowed by the Creative Common Attribution-NonCommercial-ShareAlike 3.0 
Unported License (https://creativecommons.org/licenses/by-nc-sa/3.0/).
"""
import os
import sys
import typing
from Parser import Parser
from CodeWriter import CodeWriter


def translate_file(
        input_file: typing.TextIO, output_file: typing.TextIO) -> None:
    """Translates a single file.

    Args:
        input_file (typing.TextIO): the file to translate.
        output_file (typing.TextIO): writes all output to this file.
    """
    # Your code goes here!
    # Note: you can get the input file's name using:

    name = input_file.name
    code_writer = CodeWriter(output_file)
    code_writer.set_file_name(name)
    code_writer.read_file(input_file)


if "__main__" == __name__:
    # Parses the input path and calls translate_file on each input file.
    # This opens both the input and the output files!
    # Both are closed automatically when the code finishes running.
    # If the output file does not exist, it is created automatically in the
    # correct path, using the correct filename.
    if not len(sys.argv) == 2:
        sys.exit("Invalid usage, please use: VMtranslator <input path>")
    argument_path = os.path.abspath(sys.argv[1])
    if os.path.isdir(argument_path):
        files_to_translate = [
            os.path.join(argument_path, filename)
            for filename in os.listdir(argument_path)]
        output_path = os.path.join(argument_path, os.path.basename(
            argument_path))
    else:
        files_to_translate = [argument_path]
        output_path, extension = os.path.splitext(argument_path)
    output_path += ".asm"
    with open(output_path, 'w') as output_file:
        for input_path in files_to_translate:
            filename, extension = os.path.splitext(input_path)
            if extension.lower() != ".vm":
                continue
            with open(input_path, 'r') as input_file:
                translate_file(input_file, output_file)
Makefile0100777000000000000000000000334414072605526007467 0ustar00###############################################################################
#
# Makefile for a script (e.g. Python)
#
###############################################################################

# **** Why do we need this file? ****
# We want our users to have a simple API to run the project. 
# So, we need a "wrapper" that will hide all  details to do so,
# thus enabling our users to simply type 'VMtranslator <path>' in order to use it.

# **** What are makefiles? ****
# This is a sample makefile. 
# The purpose of makefiles is to make sure that after running "make" your 
# project is ready for execution.

# **** What should I change in this file to make it work with my project? ****
# Usually, scripting language (e.g. Python) based projects only need execution 
# permissions for your run file executable to run. 
# Your project may be more complicated and require a different makefile.

# **** How are rules defined? ****
# The following line is a rule declaration: 
# all:
# 	chmod a+x VMtranslator

# A makefile rule is a list of prerequisites (other rules that need to be run 
# before this rule) and commands that are run one after the other. 
# The "all" rule is what runs when you call "make".
# In this example, all it does is grant execution permissions for your 
# executable, so your project will be able to run on the graders' computers. 
# In this case, the "all" rule has no preqrequisites.

# A general rule looks like this:
# rule_name: prerequisite1 prerequisite2 prerequisite3 prerequisite4 ...
#	command1
#	command2
#	command3
#	...
# Where each preqrequisite is a rule name, and each command is a command-line 
# command (for example chmod, javac, echo, etc').

# **** Beginning of the actual Makefile ****
all:
	chmod a+x *Parser.py0100777000000000000000000001235214146402332007624 0ustar00"""This file is part of nand2tetris, as taught in The Hebrew University,
and was written by Aviv Yaish according to the specifications given in  
https://www.nand2tetris.org (Shimon Schocken and Noam Nisan, 2017)
and as allowed by the Creative Common Attribution-NonCommercial-ShareAlike 3.0 
Unported License (https://creativecommons.org/licenses/by-nc-sa/3.0/).
"""
import typing


class Parser:
    """
    Handles the parsing of a single .vm file, and encapsulates access to the
    input code. It reads VM commands, parses them, and provides convenient 
    access to their components. 
    In addition, it removes all white space and comments.
    """

    def __init__(self, input_file: typing.TextIO) -> None:
        """Gets ready to parse the input file.

        Args:
            input_file (typing.TextIO): input file.
        """

        self.input_lines = input_file.read().splitlines()
        self.commands_arr = []
        for line in self.input_lines:
            # if ' ' in line:
                # line = line.replace(' ', "")
            line = line.split('//')[0]
            if len(line) < 1 or line[0] == '\n':
                continue
            self.commands_arr.append(line)
        # self.local_ind, self.arg_ind, self.const_ind = 0, 0, 0
        self.curr_line = 0
        self.curr_command = self.commands_arr[0]

    def has_more_commands(self) -> bool:
        """Are there more commands in the input?

        Returns:
            bool: True if there are more commands, False otherwise.
        """
        # Your code goes here!
        return self.curr_line < len(self.commands_arr) - 1

    def advance(self) -> None:
        """Reads the next command from the input and makes it the current 
        command. Should be called only if has_more_commands() is true. Initially
        there is no current command.
        """
        # Your code goes here!

        self.curr_line += 1
        self.curr_command = self.commands_arr[self.curr_line]


    def command_type(self) -> str:
        """
        Returns:
            str: the type of the current VM command.
            "C_ARITHMETIC" is returned for all arithmetic commands.
            For other commands, can return:
            "C_PUSH", "C_POP", "C_LABEL", "C_GOTO", "C_IF", "C_FUNCTION",
            "C_RETURN", "C_CALL".
        """
        # Your code goes here!
        arithmetic_set = {"add", "sub", "neg", "eq", "gt", "lt", "and", "or",
                          "not"}
        curr = self.curr_command.split(" ")[0]
        if curr == "push":
            return "C_PUSH"
        elif curr == "pop":
            return "C_POP"
        elif curr == "label":
            return "C_LABEL"
        elif curr == "goto":
            return "C_GOTO"
        elif curr == "if-goto":
            return "C_IF"
        elif curr == "function":
            return "C_FUNCTION"
        elif curr == "call":
            return "C_CALL"
        elif curr == "return":
            return "C_RETURN"
        elif curr in arithmetic_set:
            return "C_ARITHMETIC"

    def arg1(self) -> str:
        """
        Returns:
            str: the first argument of the current command. In case of 
            "C_ARITHMETIC", the command itself (add, sub, etc.) is returned. 
            Should not be called if the current command is "C_RETURN".
        """
        # Your code goes here!
        c_type = self.command_type()
        if c_type != "C_RETURN":
            if c_type == "C_ARITHMETIC":
                return self.curr_command
            else:
                return self.curr_command.split(" ")[0]

    def arg2(self) -> int:
        """
        Returns:
            int: the second argument of the current command. Should be
            called only if the current command is "C_PUSH", "C_POP", 
            "C_FUNCTION" or "C_CALL".
        """
        # Your code goes here!
        commands_set = {"C_PUSH", "C_POP", "C_FUNCTION", "C_CALL"}
        if self.command_type() in commands_set:
            return int(self.curr_command.split(" ")[2])

    def segment(self) -> str:
        """
        Returns:
        int: the first argument of the current command. Should be
        called only if the current command is "C_PUSH", "C_POP",
        """
        commands_set = {"C_PUSH", "C_POP"}
        if self.command_type() in commands_set:
            return self.curr_command.split(" ")[1]

    def segment_index(self) -> int:
        # seg = self.segment()
        # if seg == "constant":
        #     self.const_ind += 1
        #     return self.const_ind - 1
        # if seg == "local":
        #     self.local_ind += 1
        #     return self.local_ind - 1
        # else:
        #     self.arg_ind += 1
        #     return self.arg_ind - 1
        commands_set = {"C_PUSH", "C_POP"}
        if self.command_type() in commands_set:
            return int(self.curr_command.split(" ")[2])



    #
    # def run(self):
    #     while self.has_more_commands():
    #         self.advance()
    #         command = self.command_type()
    #         if command == "C_PUSH" or command == "C_POP":
    #             CodeWriter.write_push_pop(command, self.segment(),
    #                                       self.segment_index())
    #         elif command == "C_ARITHMETIC":
    #             self.write.write_arithmetic(command)
README0100777000000000000000000000203714146377615006714 0ustar00zoharmarbel,ronelharedim
===============================================================================
Ronel Charedim, ID 208917641, Ronel.Charedim@mail.huji.ac.il
Zohar Marbel, ID 316298413, zohar.marbel@mail.huji.ac.il
===============================================================================

                           Project 7 - Virtual Machine (Arithmetic)
                           ----------------------------------------
  

Submitted Files
---------------
README - This file.
VMtranslator - The executable.
Makefile - A makefile for the project.
Main.py - 
Parser.py - 
CodeWriter.py - 
Include other files required by your project, if there are any.

Remarks
-------
* The README file must contain the following:
- In the first line: login(s) of the author(s), 
separated by commas and nothing else! 
If you work alone, do not include a comma. 
Logins should be identical to the names of your home folders and are 
case-sensitive.
- Name(s), email(s) and ID(s) of the project's author(s).
- Any remarks you have about your submission.VMtranslator0100777000000000000000000000135414072605625010405 0ustar00#!/bin/sh

# **** Why do we need this file? ****
# The purpose of this file is to run your project.
# We want our users to have a simple API to run the project. 
# So, we need a "wrapper" that will hide all  details to do so,
# enabling users to simply type 'VMtranslator <path>' in order to use it.

# **** What are '#!/bin/sh' and '$*'? ****
# '$*' is a variable that holds all the arguments this file has received. So, if you
# run "VMtranslator trout mask replica", $* will hold "trout mask replica".

# **** What should I change in this file to make it work with my project? ****
# IMPORTANT: This file assumes that the main is contained in "Main.py".
#			 If your main is contained elsewhere, you will need to change this.

python3 Main.py $*