Project 12 - The Operating System.tar

Array.jack0100777000000000000000000000154014164633074007734 0ustar00// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/12/Memory.jack

/**
 * Represents an array.
 * In the Jack language, arrays are instances of the Array class.
 * Once declared, the array entries can be accessed using the usual
 * syntax arr[i]. Each array entry can hold a primitive data type as 
 * well as any object type. Different array entries can have different 
 * data types.
 */
class Array {

    /** Constructs a new Array of the given size. */
    function Array new(int size) {
        if (size < 1)
        {
            return Sys.error(2);
        }
        return Memory.alloc(size);
    }

    /** Disposes this array. */
    method void dispose() {

        do Memory.deAlloc(this);
        return;
    }
}
Keyboard.jack0100777000000000000000000000525014165042341010410 0ustar00// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/12/Keyboard.jack

/**
 * A library for handling user input from the keyboard.
 */
class Keyboard {



    /** Initializes the keyboard. */
    function void init() {

        return;
    }

    /**
     * Returns the character of the currently pressed key on the keyboard;
     * if no key is currently pressed, returns 0.
     *
     * Recognizes all ASCII characters, as well as the following keys:
     * new line = 128 = String.newline()
     * backspace = 129 = String.backspace()
     * left arrow = 130
     * up arrow = 131
     * right arrow = 132
     * down arrow = 133
     * home = 134
     * End = 135
     * page up = 136
     * page down = 137
     * insert = 138
     * delete = 139
     * ESC = 140
     * F1 - F12 = 141 - 152
     */
    function char keyPressed() {

        return Memory.peek(24576);
    }

    /**
     * Waits until a key is pressed on the keyboard and released,
     * then echoes the key to the screen, and returns the character
     * of the pressed key.
     */
    function char readChar() {

        var char c;
        while(Keyboard.keyPressed() = 0){}
        let c = Keyboard.keyPressed();
        while(~(Keyboard.keyPressed() = 0)){}
        do Output.printChar(c);
		return c;
    }

    /**
     * Displays the message on the screen, reads from the keyboard the entered
     * text until a newline character is detected, echoes the text to the screen,
     * and returns its value. Also handles user backspaces.
     */
    function String readLine(String message) {

        var String str;
        var char c;

        do Output.printString(message);
        let c = Keyboard.readChar();
        let str = String.new(63);

        while(~(c = String.newLine()))
        {
            if (c = String.backSpace())
            {
                do str.eraseLastChar();
            }
            else
            {
                do str.appendChar(c);
            }
            let c = Keyboard.readChar();
        }
        return str;
    }

    /**
     * Displays the message on the screen, reads from the keyboard the entered
     * text until a newline character is detected, echoes the text to the screen,
     * and returns its integer value (until the first non-digit character in the
     * entered text is detected). Also handles user backspaces.
     */
    function int readInt(String message) {

        var String val;
        let val = Keyboard.readLine(message);
        return val.intValue();
    }
}
Math.jack0100777000000000000000000000643414165015704007551 0ustar00// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/12/Math.jack

/**
 * A library of commonly used mathematical functions.
 * Note: Jack compilers implement multiplication and division using OS method calls.
 */
class Math {

    static Array powOfTwo;
	static int currBit, val, divideTemp;


    /** Initializes the library. */
    function void init() {

        let powOfTwo = Array.new(16);
		let currBit = 0;
		let val = 1;

		while(currBit < 16)
		{
			let powOfTwo[currBit] = val;
			let val = val + val;
			let currBit = currBit + 1;
		}
		return;
    }

    /** Returns the absolute value of x. */
    function int abs(int x) {

        if (x < 0)
        {
            return -x;
        }
        else
        {
            return x;
        }

    }

    /** Returns the product of x and y. 
     *  When a Jack compiler detects the multiplication operator '*' in the 
     *  program's code, it handles it by invoking this method. In other words,
     *  the Jack expressions x*y and multiply(x,y) return the same value.
     */
    function int multiply(int x, int y) {
        var int sum, numOfBit, shiftedX;

        let sum = 0;
        let numOfBit = 0;
        let shiftedX = x;

        while (numOfBit < 16)
        {
            if (~((powOfTwo[numOfBit] & y) = 0))
            {
                let sum = sum + shiftedX;
            }
            let numOfBit = numOfBit + 1;
            let shiftedX = shiftedX + shiftedX;
        }
        return sum;
    }

    function int divideHelper(int x, int y)
	{
		var int q;

		if(y > x)
		{
			return 0;
		}

		let q = Math.divideHelper(x, (y + y));

		if((x - divideTemp) < y)
		{
			return q + q;
		}
        let divideTemp = divideTemp + y;
        return q + q + 1;

	}


    /** Returns the integer part of x/y.
     *  When a Jack compiler detects the multiplication operator '/' in the 
     *  program's code, it handles it by invoking this method. In other words,
     *  the Jack expressions x/y and divide(x,y) return the same value.
     */
    function int divide(int x, int y) {
        var int isNeg;
        let isNeg = 1;
        let divideTemp = 0;

        if (y < 0)
        {
            let isNeg = -isNeg;
        }
        if (x < 0)
        {
            let isNeg = -isNeg;
        }
		return Math.multiply(isNeg, Math.divideHelper(Math.abs(x), Math.abs(y)));
    }

    /** Returns the integer part of the square root of x. */
    function int sqrt(int x) {

        var int counter, y, help, temp;

		let y = 0;
		let counter = 7;
		let help = 0;

		while(counter > -1)
		{
			let help = y + powOfTwo[counter];
            let temp = Math.multiply(help, help);
			if(~(temp > x) & (temp > 0))
			{
				let y = help;
			}
			let counter = counter - 1;
		}
		return y;
    }

    /** Returns the greater number. */
    function int max(int a, int b) {

        if (a > b)
        {
            return a;
        }
        return b;
    }

    /** Returns the smaller number. */
    function int min(int a, int b) {
        if (a < b)
        {
            return a;
        }
        return b;
    }
}
Memory.jack0100777000000000000000000000524314165030546010126 0ustar00// This file is part of nand2tetris, as taught in The Hebrew University,
// and was written by Aviv Yaish, and is published under the Creative 
// Common Attribution-NonCommercial-ShareAlike 3.0 Unported License 
// https://creativecommons.org/licenses/by-nc-sa/3.0/
// It is an extension to the specifications given in  
// https://www.nand2tetris.org (Shimon Schocken and Noam Nisan, 2017)
// as allowed by the Creative Common Attribution-NonCommercial-ShareAlike 3.0 
// File name: projects/12/Memory.jack

/**
 * This library provides two services: direct access to the computer's main
 * memory (RAM), and allocation and recycling of memory blocks. The Hack RAM
 * consists of 32,768 words, each holding a 16-bit binary number.
 */ 
class Memory {

    static Array ram, heap;
    static int freeLocation;

    /** Initializes the class. */
    function void init() {

        let ram = 0;
        let heap = 2048;
        let freeLocation = 2048;
        let heap[0] = 0;
        let heap[1] = 14334;
        return;
    }

    /** Returns the RAM value at the given address. */
    function int peek(int address) {

        return ram[address];
    }

    /** Sets the RAM value at the given address to the given value. */
    function void poke(int address, int value) {

        let ram[address] = value;
        return;
    }

    /** Finds an available RAM block of the given size and returns
     *  a reference to its base address. */
    function int alloc(int size) {

        var Array block, prevBlock;
        let block = freeLocation;

        while (block[1] < (size + 2))
        {
            let block = block[0];
        }
        let prevBlock = block;
        let block = prevBlock + prevBlock[1] - size;
        let prevBlock[1] = prevBlock[1] - size - 2;
        let block[1] = size;
        let block[0] = 0;
        return block + 2;
    }

    /** De-allocates the given object (cast as an array) by making
     *  it available for future allocations. */
    function void deAlloc(Array o) {
        var Array block;
        let block = o - 2;
        let block[0] = freeLocation;
        let freeLocation = block;
        return;
    }

    /** Returns the maximal element contained in the given Array/object. */
	function int max(Array o) {

        var int max, size, curr;
        var Array arr;
        let arr = o - 1;
        let size  = arr[0];
        let curr = 0;
        let max = o[0];
        while(curr < size)
        {
            if(o[curr] > max)
            {
                let max = o[curr];
            }
            let curr = curr + 1;
        }
        return max;
    }
}
Output.jack0100777000000000000000000003075414170010661010153 0ustar00// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/12/Output.jack

/**
 * A library of functions for writing text on the screen.
 * The Hack physical screen consists of 512 rows of 256 pixels each.
 * The library uses a fixed font, in which each character is displayed 
 * within a frame which is 11 pixels high (including 1 pixel for inter-line 
 * spacing) and 8 pixels wide (including 2 pixels for inter-character spacing).
 * The resulting grid accommodates 23 rows (indexed 0..22, top to bottom)
 * of 64 characters each (indexed 0..63, left to right). The top left 
 * character position on the screen is indexed (0,0). A cursor, implemented
 * as a small filled square, indicates where the next character will be displayed.
 */
class Output {

    // Character map for displaying characters
    static Array charMaps; 
    static Array screen;
    static Array litBitsArr;
    static int y_in;
    static int x_in;


    /** Initializes the screen, and locates the cursor at the screen's top-left. */
    function void init() {
    		var int curBit;
            var int bitAmount;
    		var int Val;
    		let y_in = 0;
    		let x_in = 0;
    		let bitAmount = 16;
    		let curBit = 0;
    		let litBitsArr = Array.new(bitAmount);
    		let Val = 1;
    		while(curBit < bitAmount)
    		{
    			let litBitsArr[curBit] = Val;
    			let Val = Val + Val;
    			let curBit = curBit + 1;
    		}
    		do Output.initMap();
    		return;
    }

    // Initializes the character map array
    function void initMap() {
        var int i;
    
        let charMaps = Array.new(127);
        
        // Black square, used for displaying non-printable characters.
        do Output.create(0,63,63,63,63,63,63,63,63,63,0,0);

        // Assigns the bitmap for each character in the charachter set.
        // The first parameter is the character index, the next 11 numbers
        // are the values of each row in the frame that represents this character.
        do Output.create(32,0,0,0,0,0,0,0,0,0,0,0);          //
        do Output.create(33,12,30,30,30,12,12,0,12,12,0,0);  // !
        do Output.create(34,54,54,20,0,0,0,0,0,0,0,0);       // "
        do Output.create(35,0,18,18,63,18,18,63,18,18,0,0);  // #
        do Output.create(36,12,30,51,3,30,48,51,30,12,12,0); // $
        do Output.create(37,0,0,35,51,24,12,6,51,49,0,0);    // %
        do Output.create(38,12,30,30,12,54,27,27,27,54,0,0); // &
        do Output.create(39,12,12,6,0,0,0,0,0,0,0,0);        // '
        do Output.create(40,24,12,6,6,6,6,6,12,24,0,0);      // (
        do Output.create(41,6,12,24,24,24,24,24,12,6,0,0);   // )
        do Output.create(42,0,0,0,51,30,63,30,51,0,0,0);     // *
        do Output.create(43,0,0,0,12,12,63,12,12,0,0,0);     // +
        do Output.create(44,0,0,0,0,0,0,0,12,12,6,0);        // ,
        do Output.create(45,0,0,0,0,0,63,0,0,0,0,0);         // -
        do Output.create(46,0,0,0,0,0,0,0,12,12,0,0);        // .    
        do Output.create(47,0,0,32,48,24,12,6,3,1,0,0);      // /
        
        do Output.create(48,12,30,51,51,51,51,51,30,12,0,0); // 0
        do Output.create(49,12,14,15,12,12,12,12,12,63,0,0); // 1
        do Output.create(50,30,51,48,24,12,6,3,51,63,0,0);   // 2
        do Output.create(51,30,51,48,48,28,48,48,51,30,0,0); // 3
        do Output.create(52,16,24,28,26,25,63,24,24,60,0,0); // 4
        do Output.create(53,63,3,3,31,48,48,48,51,30,0,0);   // 5
        do Output.create(54,28,6,3,3,31,51,51,51,30,0,0);    // 6
        do Output.create(55,63,49,48,48,24,12,12,12,12,0,0); // 7
        do Output.create(56,30,51,51,51,30,51,51,51,30,0,0); // 8
        do Output.create(57,30,51,51,51,62,48,48,24,14,0,0); // 9
        
        do Output.create(58,0,0,12,12,0,0,12,12,0,0,0);      // :
        do Output.create(59,0,0,12,12,0,0,12,12,6,0,0);      // ;
        do Output.create(60,0,0,24,12,6,3,6,12,24,0,0);      // <
        do Output.create(61,0,0,0,63,0,0,63,0,0,0,0);        // =
        do Output.create(62,0,0,3,6,12,24,12,6,3,0,0);       // >
        do Output.create(64,30,51,51,59,59,59,27,3,30,0,0);  // @
        do Output.create(63,30,51,51,24,12,12,0,12,12,0,0);  // ?

        do Output.create(65,12,30,51,51,63,51,51,51,51,0,0);          // A ** TO BE FILLED **
        do Output.create(66,31,51,51,51,31,51,51,51,31,0,0); // B
        do Output.create(67,28,54,35,3,3,3,35,54,28,0,0);    // C
        do Output.create(68,15,27,51,51,51,51,51,27,15,0,0); // D
        do Output.create(69,63,51,35,11,15,11,35,51,63,0,0); // E
        do Output.create(70,63,51,35,11,15,11,3,3,3,0,0);    // F
        do Output.create(71,28,54,35,3,59,51,51,54,44,0,0);  // G
        do Output.create(72,51,51,51,51,63,51,51,51,51,0,0); // H
        do Output.create(73,30,12,12,12,12,12,12,12,30,0,0); // I
        do Output.create(74,60,24,24,24,24,24,27,27,14,0,0); // J
        do Output.create(75,51,51,51,27,15,27,51,51,51,0,0); // K
        do Output.create(76,3,3,3,3,3,3,35,51,63,0,0);       // L
        do Output.create(77,33,51,63,63,51,51,51,51,51,0,0); // M
        do Output.create(78,51,51,55,55,63,59,59,51,51,0,0); // N
        do Output.create(79,30,51,51,51,51,51,51,51,30,0,0); // O
        do Output.create(80,31,51,51,51,31,3,3,3,3,0,0);     // P
        do Output.create(81,30,51,51,51,51,51,63,59,30,48,0);// Q
        do Output.create(82,31,51,51,51,31,27,51,51,51,0,0); // R
        do Output.create(83,30,51,51,6,28,48,51,51,30,0,0);  // S
        do Output.create(84,63,63,45,12,12,12,12,12,30,0,0); // T
        do Output.create(85,51,51,51,51,51,51,51,51,30,0,0); // U
        do Output.create(86,51,51,51,51,51,30,30,12,12,0,0); // V
        do Output.create(87,51,51,51,51,51,63,63,63,18,0,0); // W
        do Output.create(88,51,51,30,30,12,30,30,51,51,0,0); // X
        do Output.create(89,51,51,51,51,30,12,12,12,30,0,0); // Y
        do Output.create(90,63,51,49,24,12,6,35,51,63,0,0);  // Z

        do Output.create(91,30,6,6,6,6,6,6,6,30,0,0);          // [
        do Output.create(92,0,0,1,3,6,12,24,48,32,0,0);        // \
        do Output.create(93,30,24,24,24,24,24,24,24,30,0,0);   // ]
        do Output.create(94,8,28,54,0,0,0,0,0,0,0,0);          // ^
        do Output.create(95,0,0,0,0,0,0,0,0,0,63,0);           // _
        do Output.create(96,6,12,24,0,0,0,0,0,0,0,0);          // `

        do Output.create(97,0,0,0,14,24,30,27,27,54,0,0);      // a
        do Output.create(98,3,3,3,15,27,51,51,51,30,0,0);      // b
        do Output.create(99,0,0,0,30,51,3,3,51,30,0,0);        // c
        do Output.create(100,48,48,48,60,54,51,51,51,30,0,0);  // d
        do Output.create(101,0,0,0,30,51,63,3,51,30,0,0);      // e
        do Output.create(102,28,54,38,6,15,6,6,6,15,0,0);      // f
        do Output.create(103,0,0,30,51,51,51,62,48,51,30,0);   // g
        do Output.create(104,3,3,3,27,55,51,51,51,51,0,0);     // h
        do Output.create(105,12,12,0,14,12,12,12,12,30,0,0);   // i
        do Output.create(106,48,48,0,56,48,48,48,48,51,30,0);  // j
        do Output.create(107,3,3,3,51,27,15,15,27,51,0,0);     // k
        do Output.create(108,14,12,12,12,12,12,12,12,30,0,0);  // l
        do Output.create(109,0,0,0,29,63,43,43,43,43,0,0);     // m
        do Output.create(110,0,0,0,29,51,51,51,51,51,0,0);     // n
        do Output.create(111,0,0,0,30,51,51,51,51,30,0,0);     // o
        do Output.create(112,0,0,0,30,51,51,51,31,3,3,0);      // p
        do Output.create(113,0,0,0,30,51,51,51,62,48,48,0);    // q
        do Output.create(114,0,0,0,29,55,51,3,3,7,0,0);        // r
        do Output.create(115,0,0,0,30,51,6,24,51,30,0,0);      // s
        do Output.create(116,4,6,6,15,6,6,6,54,28,0,0);        // t
        do Output.create(117,0,0,0,27,27,27,27,27,54,0,0);     // u
        do Output.create(118,0,0,0,51,51,51,51,30,12,0,0);     // v
        do Output.create(119,0,0,0,51,51,51,63,63,18,0,0);     // w
        do Output.create(120,0,0,0,51,30,12,12,30,51,0,0);     // x
        do Output.create(121,0,0,0,51,51,51,62,48,24,15,0);    // y
        do Output.create(122,0,0,0,63,27,12,6,51,63,0,0);      // z
        
        do Output.create(123,56,12,12,12,7,12,12,12,56,0,0);   // {
        do Output.create(124,12,12,12,12,12,12,12,12,12,0,0);  // |
        do Output.create(125,7,12,12,12,56,12,12,12,7,0,0);    // }
        do Output.create(126,38,45,25,0,0,0,0,0,0,0,0);        // ~

	return;
    }

    // Creates the character map array of the given character index, using the given values.
    function void create(int index, int a, int b, int c, int d, int e,
                         int f, int g, int h, int i, int j, int k) {
	var Array map;

	let map = Array.new(11);
        let charMaps[index] = map;

        let map[0] = a;
        let map[1] = b;
        let map[2] = c;
        let map[3] = d;
        let map[4] = e;
        let map[5] = f;
        let map[6] = g;
        let map[7] = h;
        let map[8] = i;
        let map[9] = j;
        let map[10] = k;

        return;
    }
    
    // Returns the character map (array of size 11) of the given character.
    // If the given character is invalid or non-printable, returns the
    // character map of a black square.
    function Array getMap(char c) {
        if ((c < 32) | (c > 126)) {
            let c = 0;
        }
        return charMaps[c];
    }

    /** Moves the cursor to the j-th column of the i-th row,
     *  and erases the character displayed there. */
    function void moveCursor(int i, int j) {
            let x_in = j;
    		let y_in = i;
    		return;
    }

    function void arrCounter(char c){
            var int arr_counter;
            var int bit_counter;
            var boolean flag;
            var Array symbol;
            var int x_loc;
            var int y_loc;
            let x_loc = x_in * 8;
            let y_loc = y_in * 11;
            let arr_counter = 0;
            let symbol = Output.getMap(c);

            do Screen.setColor(true);

            while (arr_counter < 11)
            {
                let bit_counter = 0;
                while (bit_counter < 8)
                {
                    let flag = ~((symbol[arr_counter] &
                                                   litBitsArr[bit_counter])=0);
                    if(flag)
                    {
                        do Screen.drawPixel(x_loc + bit_counter, y_loc +
                        arr_counter);
                    }
                    let bit_counter = bit_counter + 1;
                }
                let arr_counter = arr_counter + 1;
            }
            return;
    }


    /** Displays the given character at the cursor location,
     *  and advances the cursor one column forward. */
    function void printChar(char c) {
            do Output.arrCounter(c);
            if(x_in = 63)
                {
                    if(y_in = 22)
                    {
                        do Output.moveCursor(0,0);
                    }
                    else
                    {
                        do Output.println();
                    }
                }
            else
                {
                    do Output.moveCursor(y_in, x_in + 1);
                }
            return;
    }

    /** displays the given string starting at the cursor location,
     *  and advances the cursor appropriately. */
    function void printString(String s) {
            var int l_counter;
    		let l_counter = 0;
    		while(l_counter < s.length())
    		{
    			do Output.printChar(s.charAt(l_counter));
    			let l_counter = l_counter + 1;
    		}
    		return;
    }

    /** Displays the given integer starting at the cursor location,
     *  and advances the cursor appropriately. */
    function void printInt(int i) {
            var String myint;
    		let myint = String.new(63);
    		do myint.setInt(i);
    		do Output.printString(myint);
    		return;
    }

    /** Advances the cursor to the beginning of the next line. */
    function void println() {
        if( ~(y_in < 22) )
        {
            let y_in = -1;
        }
        do Output.moveCursor(y_in + 1 ,0);
        return;
    }


    /** Moves the cursor one column back. */
    function void backSpace() {
		if(x_in = 0)
		{
			if(~(y_in = 0))
			{
				do Output.moveCursor(y_in - 1, 63);
			}
		}
		else
		{
			do Output.moveCursor(y_in,(x_in - 1));
		}
		return;
    }

}
README0100777000000000000000000000172714170030175006701 0ustar00zoharmarbel,ronelharedim
===============================================================================
Ronel Charedim, ID 208917641, Ronel.Charedim@mail.huji.ac.il
Zohar Marbel, ID 316298413, zohar.marbel@mail.huji.ac.il
===============================================================================


                           Project 12 - The Operating System
                           ---------------------------------
  

Submitted Files
---------------
README - This file.
Array.jack - 
Keyboard.jack - 
Math.jack - 
Memory.jack - 
Output.jack - 
Screen.jack - 
String.jack - 
Sys.jack - 

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.Screen.jack0100777000000000000000000001700714170006740010071 0ustar00// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/12/Screen.jack

/**
 * A library of functions for displaying graphics on the screen.
 * The Hack physical screen consists of 256 rows (indexed 0..255, top to bottom)
 * of 512 pixels each (indexed 0..511, left to right). The top left pixel on 
 * the screen is indexed (0,0).
 */
class Screen {

    static int screen;
    static boolean white, black, color;
    static Array array;

    /** Initializes the Screen. */
    function void init() {
            var int i,j;
            let color = true;
            let white = false;
            let black = true;
            let screen = 16384;

            let array = Array.new(16);
            let i = 1;
            let j = 0;
            while(j <16){
                let array[j] = i;
                let j = j + 1;
                let i = i + i;
            }
            return;
    }

    /** Erases the entire screen. */
    function void clearScreen() {
            var int i;
            let i = 0;
            while(i < 8192){
                do Memory.poke(screen + i, white);
                let i = i + 1;
            }
            return;
    }

    /** Sets the current color, to be used for all subsequent drawXXX commands.
     *  Black is represented by true, white by false. */
    function void setColor(boolean b) {
            let color = b;
            return;
    }

    /** Draws the (x,y) pixel, using the current color. */
    function void drawPixel(int x, int y) {
                var int address, value, bitLoc, bit,i;
                let i =0;
                while (i<5)
                {
                    let y = y + y;
                    let i = i + 1;
                }
                let address = screen + y + (x / 16);
                let value = Memory.peek(address);
                let bitLoc = x&15;
                let bit = array[bitLoc];
                if (~color)
                {
                    let value = (value & ~bit);
                }
                else{
                    let value = (value | bit);
                    }
                do Memory.poke(address, value);
                return;
    }

    function void HorizontalLine(int x1, int x2, int y1) {
            var int address, value, currentBit, bitNumber, dx, tempBitNumber, i;
            let dx = x2 - x1;
            let i =0;
            while (i<5)
            {
                let y1 = y1 + y1;
                let i = i + 1;
            }
            let address = screen + y1 + (x1 / 16);
            let currentBit = x1 & 15;
            while(~(dx<0))
            {
                if((currentBit = 0) & (dx > 15))
                {
                    do Memory.poke(address, color);
                    let dx = dx - 16;
                    let address = address + 1;
                }
                else
                {
                    let bitNumber = 0;
                    while(~(dx < 0) & (currentBit < 16))
                    {
                        let tempBitNumber = array[currentBit];
                        let bitNumber = tempBitNumber | bitNumber;
                        let currentBit = currentBit + 1;
                        let dx = dx - 1;
                    }
                    if(currentBit > 15)
                    {
                        let currentBit = 0;
                    }
                    let value = Memory.peek(address);
                    if(~color)
                    {
                         let value = (value & ~bitNumber);
                    }
                    else
                    {
                       let value = (value | bitNumber);
                    }
                    do Memory.poke(address, value);
                    let address = address + 1;
                }
            }
            return;
        }

    function void helper2(int x1, int x2, int y1, int y2){
            var int a, b, dx, dy, diff;
            let a = 0;
            let b = 0;
            let dx = x2 - x1;
            let dy = y2 - y1;
            if (dy > 0)
            {
                while (~(a > dx) & ~(b > dy))
                {
                    do Screen.drawPixel(x1 + a, y1 + b);
                    if (diff < 0)
                    {
                        let a = a + 1;
                        let diff = diff + dy;
                    }
                    else
                    {
                        let b = b + 1;
                        let diff = diff - dx;
                    }
                }
                return;
            }
            else{
                while (~(a > dx) & ~(b < dy))
                {
                    do Screen.drawPixel(x1 + a, y1 + b);
                    if (diff < 0)
                    {
                        let a = a + 1;
                        let diff = diff - dy;
                    }
                    else
                    {
                        let b = b - 1;
                        let diff = diff - dx;
                    }
                }
                return;
            }
    }

function void helper1(int x1, int x2, int y1, int y2){
                if (y1 < y2)
                {
                    while(~(y1 > y2))
                        {
                            do Screen.drawPixel(x1, y1);
                            let y1 = y1 + 1;
                        }
                }
                else
                {
                    while(~(y2 > y1))
                        {
                            do Screen.drawPixel(x1, y2);
                            let y2 = y2 + 1;
                        }
                }
                return;
}

    /** Draws a line from pixel (x1,y1) to pixel (x2,y2), using the current color. */
    function void drawLine(int x1, int y1, int x2, int y2) {
            var int temp;
            if (x1 = x2)
            {
                do Screen.helper1(x1,x2,y1,y2);
                return;
            }

            if (x1 > x2){
                let temp = x1;
                let x1 = x2;
                let x2 = temp;
                let temp = y1;
                let y1 = y2;
                let y2 = temp;
            }

            if (y1 = y2)
            {
                do Screen.HorizontalLine(x1, x2, y1);
                return;
            }
           do Screen.helper2(x1, x2, y1, y2);
           return;
    }

    /** Draws a filled rectangle whose top left corner is (x1, y1)
     * and bottom right corner is (x2,y2), using the current color. */
    function void drawRectangle(int x1, int y1, int x2, int y2) {
            while( (y1 = y2) | (y1 < y2))
                {
                    do Screen.HorizontalLine(x1,x2,y1);
                    let y1 = y1 + 1;
                }
            return;
    }

    /** Draws a filled circle of radius r<=181 around (x,y), using the current color. */
    function void drawCircle(int x, int y, int r) {
            var int dy;
            var int center_location;
    		if (r < 181)
    		{
    			let dy = -r;
    			while (~(dy > r))
    			{
    				let center_location = Math.sqrt((r * r) - (dy * dy));
    				do Screen.drawLine((x - center_location), (y + dy),
    				(x + center_location), (y + dy));
    				let dy = dy + 1;
    			}
    		}
            return;
        }
}
String.jack0100777000000000000000000001037114170006746010123 0ustar00// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/12/String.jack

/**
 * Represents character strings. In addition for constructing and disposing
 * strings, the class features methods for getting and setting individual
 * characters of the string, for erasing the string's last character,
 * for appending a character to the string's end, and more typical
 * string-oriented operations.
 */
class String {


	field Array chars;
	field int maxlen;
	field int len;

    /** constructs a new empty string with a maximum length of maxLength
     *  and initial length of 0. */
    constructor String new(int maxLength) {
            let maxlen = maxLength;
    		if(maxLength < 1)
    		{
    			let maxLength = 1;
    		}
    		let chars = Array.new(maxLength);
    		let len = 0;
    		return this;
    }

    /** Disposes this string. */
    method void dispose() {
            let len = 0;
            return;
    }

    /** Returns the current length of this string. */
    method int length() {
            return len;
    }

    /** Returns the character at the j-th location of this string. */
    method char charAt(int j) {
             return chars[j];
    }

    /** Sets the character at the j-th location of this string to c. */
    method void setCharAt(int j, char c) {
            let chars[j]=c;
            return;
    }

    /** Appends c to this string's end and returns this string. */
    method String appendChar(char c) {
            if(len < maxlen)
            {
                let chars[len] = c;
                let len = len + 1;
            }
            return this;
    }

    /** Erases the last character from this string. */
    method void eraseLastChar() {
            if(len > 0)
    		{
    			let len = len - 1;
    		}
    		return;
    }

    /** Returns the integer value of this string, 
     *  until a non-digit character is detected. */
    method int intValue() {
                    var int total;
            		var int counter;
            		var char tempchar;
            		var int tempint;
            		var int neg;
            		let tempchar = charAt(0);
            		let counter = 0;
                    let total = 0;
            		let neg = 1;
                    if (~(tempchar>47 & tempchar<58))
                    		{
                    			if (~(tempchar = 45))
                    			{
                    				return total;
                    			}
                    			else
                    			{
                    				let counter = counter + 1;
                    				let neg = -1;
                    			}
                    		}

                    while(counter < len)
                        {
                            if (~(charAt(counter)>47 & charAt(counter)<58))
                            {
                                return (total * neg);
                            }

                            let total = (total * 10) + (charAt(counter))-48;
                            let counter = counter + 1;
                        }

                        return (total * neg);
    }
	method void setinthelp(int val)
	{
		var char charval;
		var int modulehelp;

			if(val < 10)
			{
				let charval = (val+48);
				do appendChar(charval);
			}
			else
			{
				let modulehelp = val / 10;
				do setinthelp(modulehelp);

				let charval = ((val - (modulehelp * 10))+48);
				do appendChar(charval);
			}

			return;
	}

    /** Sets this string to hold a representation of the given value. */
    method void setInt(int val) {
                let len = 0;
                if (val < 0)
                {
                    let val = -val;
                    do appendChar(45);
                }
                do setinthelp(val);
                return;
    }

    /** Returns the new line character. */
    function char newLine() {
            return 128;
    }

    /** Returns the backspace character. */
    function char backSpace() {
            return 129;
    }

    /** Returns the double quote (") character. */
    function char doubleQuote() {
            return 34;
    }
}
Sys.jack0100777000000000000000000000263514170006744007435 0ustar00// This file is part of www.nand2tetris.org
// and the book "The Elements of Computing Systems"
// by Nisan and Schocken, MIT Press.
// File name: projects/12/Sys.jack

/**
 * A library that supports various program execution services.
 */
class Sys {

    /** Performs all the initializations required by the OS. */
    function void init() {
            do Memory.init();
            do Math.init();
            do Screen.init();
            do Output.init();
            do Keyboard.init();
            do Main.main();
            do Sys.halt();
            return;
    }

    /** Halts the program execution. */
    function void halt() {
     while(true){
            }
            return;
    }

    /** Waits approximately duration milliseconds and returns.  */
    function void wait(int duration) {
            var int buffer;
            while(duration > 0){
                let buffer = 50;
                while(buffer > 0){
                    let buffer = buffer - 1;
                }
                let duration = duration - 1;
            }
            return;
    }

    /** Displays the given error code in the form "ERR<errorCode>",
     *  and halts the program's execution. */
    function void error(int errorCode) {
            do Output.printString("err ");
            do Output.printInt(errorCode);
            do Sys.halt();
            return;
        }
}