String.jack

// 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 int _maxLength;
	field int length;
	field Array chars;

    /** constructs a new empty string with a maximum length of maxLength
     *  and initial length of 0. */
    constructor String new(int maxLength) {
		if(maxLength < 0){
			do Sys.error(14);
		}
		if(maxLength > 0){
			let chars = Array.new(maxLength);
		}
		let _maxLength = maxLength;
		
		return this;
    }

    /** Disposes this string. */
    method void dispose() {
		if(~(chars = 0)){
			do chars.dispose();
		}
		do Memory.deAlloc(this);
		return;
    }

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

    /** Returns the character at the j-th location of this string. */
    method char charAt(int j) {
		if((j < 0) | (~(j < length))){
			do Sys.error(15);
		}
		return chars[j];
    }

    /** Sets the character at the j-th location of this string to c. */
    method void setCharAt(int j, char c) {
		if((j < 0) | (~(j < length))){
			do Sys.error(16);			
		}
		let chars[j] = c;
		return;
    }

    /** Appends c to this string's end and returns this string. */
    method String appendChar(char c) {
		if(_maxLength = length){
			do Sys.error(17);			
		}
		let chars[length] = c;
		let length = length + 1;
		return this;
    }

    /** Erases the last character from this string. */
    method void eraseLastChar() {
		if(length = 0){
			do Sys.error(18);			
		}
		let length = length - 1;
		return;
    }
	
		
    /** Returns the integer value of this string, 
     *  until a non-digit character is detected. */
    method int intValue() {
		var int ret, i, sign;
		while(i < length){
			if(i = 0){
				if(chars[i] = 45){
					let sign = -1;
				} else {
					let sign = 1;
					if((chars[i] > 47) & (chars[i] < 58)){
						let ret = (10 * ret) + chars[i] - 48;
					} else {
						return ret;
					}
				}
			} else {
				if((chars[i] > 47) & (chars[i] < 58)){
					let ret = (10 * ret) + chars[i] - 48;
				} else {
					return ret;
				}
			}
			let i = i + 1;
		}
		return ret * sign;
    }

    /** Sets this string to hold a representation of the given value. */
    method void setInt(int value) {
		var int divisor;
		let length = 0;
		if(value < 0){
			do appendChar(45);  // minus
			let value = -value;
		} 
		do addDigits(value);
		
		return;
    }
	
	function int mod(int x, int y){
		return x - ((x / y) * y);
	}
	
    method void addDigits(int value) {
		if(_maxLength = 0){
			do Sys.error(19);			
		}
		if(value < 10){
			do appendChar(value + 48);
		} else {
			do addDigits(value / 10);
			do appendChar(String.mod(value, 10) + 48);
		}
		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;
    }
}