class Main {

function void main() {

var SnakeGame game;

let game = SnakeGame.new();

do game.run();

do game.dispose();

return;

}

}

class LinkedList {

field PixelNode first, last;

constructor LinkedList new(){

let first = null;

let last = null;

return this;

}

method void dispose(){

if( ~(first = null) ){

do first.dispose();

}

do Memory.deAlloc(this);

return;

}

method void push(PixelNode p){

if( last = null ){

let first = p;

let last = p;

} else {

do last.setNext(p);

let last = p;

}

return;

}

method void shift(){

var PixelNode old;

let old = first;

if( old.next() = null ){

let first = null;

let last = null;

} else {

let first = old.next();

}

do old.setNext(null);

do old.dispose();

return;

}

method PixelNode first(){

return first;

}

method PixelNode last(){

return last;

}

}

class Node {

field Node next;

field int data;

constructor Node new(int new_data) {

let data = new_data;

return this;

}

}

class PixelNode {

field int x, y;

field PixelNode next;

constructor PixelNode new(int new_x, int new_y){

let x = new_x;

let y = new_y;

let next = null;

return this;

}

method void dispose(){

if(~(next = null)){

do next.dispose();

}

do Memory.deAlloc(this);

return;

}

method int x(){

return x;

}

method int y(){

return y;

}

method PixelNode next(){

return next;

}

method void setNext(PixelNode next_node){

let next = next_node;

return;

}

}

class Snake {

field LinkedList pixels;

constructor Snake new(int x, int y) {

var PixelNode pix;

let pix = PixelNode.new(x, y);

let pixels = LinkedList.new();

do pixels.push(pix);

return this;

}

method void dispose() {

do pixels.dispose();

do Memory.deAlloc(this);

return;

}

method void crawlDown(bool increase_size){

var PixelNode last, new_pixel;

let last = pixels.last();

if( last.y() = 255){

return;

}

let new_pixel = PixelNode.new(last.x(), last.y() + 1);

do pixels.push(new_pixel);

if( ~increase_size ){

do pixels.shift();

}

return;

}

method void crawlLeft(bool increase_size){

var PixelNode last, new_pixel;

let last = pixels.last();

if( last.x() = 0){

return;

}

let new_pixel = PixelNode.new(last.x() - 1, last.y());

do pixels.push(new_pixel);

if( ~increase_size ){

do pixels.shift();

}

return;

}

method void crawlRight(bool increase_size){

var PixelNode last, new_pixel;

let last = pixels.last();

if( last.x() = 511 ){

return;

}

let new_pixel = PixelNode.new(last.x() + 1, last.y());

do pixels.push(new_pixel);

if( ~increase_size ){

do pixels.shift();

}

return;

}

method void crawlUp(bool increase_size){

var PixelNode last, new_pixel;

let last = pixels.last();

if( last.y() = 0){

return;

}

let new_pixel = PixelNode.new(last.x(), last.y() + -1);

do pixels.push(new_pixel);

if( ~increase_size ){

do pixels.shift();

}

return;

}

method PixelNode first(){

return pixels.first();

}

method LinkedList pixels(){

return pixels;

}

}

class SnakeGame {

field Snake snake;

constructor SnakeGame new() {

let snake = Snake.new(256, 128);

do Output.moveCursor(1, 13);

do Output.printString("Bienvenido al juego de la serpiente");

do Output.moveCursor(3, 10);

do Output.printString("Presione X para incrementar a la serpiente");

do Sys.wait(3000);

return this;

}

method void dispose(){

do snake.dispose();

do Memory.deAlloc(this);

return;

}

method void run(){

var char key;

var boolean exit, grow;

var int direction; // 0=ninguno, 1=arriba, 2=abajo, 3=izquierda, 4=derecha

let direction = 0;

while (~exit) {

// espera a que se presione una tecla

while (key = 0) {

let key = Keyboard.keyPressed();

do moveSnake(direction, grow);

do drawScreen();

}

if (key = 81) {

let exit = true;

}

if (key = 88) {

let grow = true;

}

if (key = 131) {

let direction = 1;

}

if (key = 133) {

let direction = 2;

}

if (key = 130) {

let direction = 3;

}

if (key = 132) {

let direction = 4;

}

// espera a que se suelte la tecla

while (~(key = 0)) {

let key = Keyboard.keyPressed();

do moveSnake(direction, grow);

do drawScreen();

let grow = false;

}

}

return;

}

method void moveSnake(int direction, bool grow) {

if (direction = 1) {

do snake.crawlUp(grow);

}

if (direction = 2) {

do snake.crawlDown(grow);

}

if (direction = 3) {

do snake.crawlLeft(grow);

}

if (direction = 4) {

do snake.crawlRight(grow);

}

do Sys.wait(5); // Tiempo de espera para el siguiente movimiento

return;

}

method void drawScreen(){

var PixelNode pix;

do Screen.clearScreen();

let pix = snake.first();

while( ~(pix = null) ){

do Screen.drawPixel(pix.x(), pix.y());

let pix = pix.next();

}

return;

}

}

from JackTokenizer import JackTokenizer

from CompilationEngine import CompilationEngine

import sys

import os

import glob

class JackAnalyzer():

# Genera el archivo de salida en el directorio correspondiente

@classmethod

def xml_output_file_for(cls, input_file):

file_name = os.path.basename(input_file).split(".")[0]

# generando el nombre del archivo de salida

return "/".join(input_file.split("/")[:-1]) + "/" + file_name + ".xml"

@classmethod

def run(cls, input_file, output_file):

tokenizer = JackTokenizer(input_file)

compiler = CompilationEngine(tokenizer, output_file)

compiler.compile_class()

if __name__ == "__main__" and len(sys.argv) == 2:

arg = sys.argv[1]

# Determina sí es un directorio o un archivo,

# y finalmente elige la ruta destino

if os.path.isfile(arg):

files = [arg]

elif os.path.isdir(arg):

jack_path = os.path.join(arg, "*.jack")

files = glob.glob(jack_path)

# create output directory - MAY NEED TO REMOVE

for input_file_name in files:

output_file_name = JackAnalyzer.xml_output_file_for(input_file_name)

output_file = open(output_file_name, 'w')

input_file = open(input_file_name, 'r')

JackAnalyzer.run(input_file, output_file)

class JackTokenizer():

# símbolos del lenguaje Jack

SYMBOL_CONVERSIONS = {

'<': '&lt;',

'>': '&gt;',

'\"': '&quot;',

'&': '&amp;'

}

COMMENT_OPERATORS = ["/", "*"]

KEYWORDS = [

'class',

'constructor',

'function',

'method',

'field',

'static',

'var',

'int',

'char',

'boolean',

'void',

'true',

'false',

'null',

'this',

'let',

'do',

'if',

'else',

'while',

'return'

]

# va a través de archivo .jack y produce una secuencia de tokens

# ignora los espacios en blanco y comentarios

def __init__(self, input_file):

self.input_file = input_file

self.tokens_found = []

self.current_token = None

self.next_token = None

self.has_more_tokens = True

# Avanza en la lectura del documento

def advance(self):

# Lee el primer carácter

char = self.input_file.read(1)

# en este loop salta todos loc comentarios y espacios en blanco

while char.isspace() or char in self.COMMENT_OPERATORS:

if char.isspace():

char = self.input_file.read(1)

elif char in self.COMMENT_OPERATORS:

# se asegura de que no haya ningún operador

last_pos = self.input_file.tell()

next_2_chars = self.input_file.read(2)

if not self._is_start_of_comment(char, next_2_chars):

# vuelve atrás

self.input_file.seek(last_pos)

break

# lee toda la linea

self.input_file.readline()

# lee el siguiente carácter

char = self.input_file.read(1)

continue

# encontramos el token

token = ""

if self._is_string_const_delimeter(char):

token += char

char = self.input_file.read(1)

while not self._is_string_const_delimeter(char):

token += char

char = self.input_file.read(1)

token += char

elif char.isalnum():

while self._is_alnum_or_underscore(char):

token += char

last_pos = self.input_file.tell()

char = self.input_file.read(1)

# retrocede un carácter que se adelantó

self.input_file.seek(last_pos)

else:

if char in self.SYMBOL_CONVERSIONS:

token = self.SYMBOL_CONVERSIONS[char]

else:

token = char

# establece los tokens

if self.current_token:

self.current_token = self.next_token

self.next_token = token

self.tokens_found.append(token)

else:

self.current_token = token

self.next_token = token

self.tokens_found.append(token)

# actualiza el siguiente token

self.advance()

if not len(self.next_token) > 0:

self.has_more_tokens = False

return False

else:

return True

def part_of_subroutine_call(self):

if len(self.tokens_found) < 3:

return False

index = len(self.tokens_found) - 4

token = self.tokens_found[index]

if token == ".":

return True

else:

return False

def current_token_type(self):

if self.current_token[0] == "\"":

return "STRING_CONST"

elif self.current_token in self.KEYWORDS:

return "KEYWORD"

elif self.current_token.isnumeric():

return "INT_CONST"

elif self.current_token.isalnum():

return "IDENTIFIER"

else:

return "SYMBOL"

def _is_alnum_or_underscore(self, char):

return char.isalnum() or char == "_"

def _is_string_const_delimeter(self, char):

return char == "\""

def _is_start_of_comment(self, char, next_2_chars):

# comentario de forma: // or */

single_line_comment = next_2_chars[0] == self.COMMENT_OPERATORS[0]

# comentario de la forma: /**

multi_line_comment = char == self.COMMENT_OPERATORS[0] and next_2_chars == "**"

# comentario de la forma: * comment

part_of_multi_line_comment = char == self.COMMENT_OPERATORS[1] and next_2_chars[0].isspace() and next_2_chars[

1] != '('

return single_line_comment or multi_line_comment or part_of_multi_line_comment

class CompilationEngine():

STARTING_TOKENS = {

'var_dec': ['var'],

'parameter_list': ['('],

'subroutine_body': ['{'],

'expression_list': ['('],

'expression': ['=', '[', '(']

}

TERMINATING_TOKENS = {

'class': ['}'],

'class_var_dec': [';'],

'subroutine': ['}'],

'parameter_list': [')'],

'expression_list': [')'],

'statements': ['}'],

'do': [';'],

'let': [';'],

'while': ['}'],

'if': ['}'],

'var_dec': [';'],

'return': [';'],

'expression': [';', ')', ']', ',']

}

SUBROUTINE_TOKENS = ["function", "method", "constructor"]

STATEMENT_TOKENS = ['do', 'let', 'while', 'return', 'if']

TERMINAL_KEYWORDS = ["boolean", "class", "void", "int"]

CLASS_VAR_DEC_TOKENS = ["static", "field"]

UNARY_OPERATORS = ['-', '~']

TERMINAL_TOKEN_TYPES = ["STRING_CONST", "INT_CONST", "IDENTIFIER", "SYMBOL"]

OPERATORS = [

'+',

'-',

'*',

'/',

'&amp;',

'|',

'&lt;',

'&gt;',

'='

]

def __init__(self, tokenizer, output_file):

self.tokenizer = tokenizer

self.output_file = output_file

# Compila una clase

def compile_class(self):

# lo básico para compilar una clase

self._write_current_outer_tag(body="class")

while self.tokenizer.has_more_tokens:

self.tokenizer.advance()

if self._terminal_token_type() or self._terminal_keyword():

self._write_current_terminal_token()

elif self.tokenizer.current_token in self.CLASS_VAR_DEC_TOKENS:

self.compile_class_var_dec()

elif self.tokenizer.current_token in self.SUBROUTINE_TOKENS:

self.compile_subroutine()

self._write_current_outer_tag(body="/class")

def compile_class_var_dec(self):

self._write_current_outer_tag(body="classVarDec")

self._write_current_terminal_token()

while self._not_terminal_token_for('class_var_dec'):

self.tokenizer.advance()

self._write_current_terminal_token()

self._write_current_outer_tag(body="/classVarDec")

# el encargado de compilar la rutina o función

def compile_subroutine(self):

self._write_current_outer_tag(body="subroutineDec")

self._write_current_terminal_token()

while self._not_terminal_token_for('subroutine'):

self.tokenizer.advance()

if self._starting_token_for('parameter_list'):

self.compile_parameter_list()

elif self._starting_token_for('subroutine_body'):

self.compile_subroutine_body()

else:

self._write_current_terminal_token()

self._write_current_outer_tag(body="/subroutineDec")

def compile_parameter_list(self):

# escribe el ( inicial

self._write_current_terminal_token()

self._write_current_outer_tag(body="parameterList")

while self._not_terminal_token_for(position='next', keyword_token='parameter_list'):

self.tokenizer.advance()

self._write_current_terminal_token()

self._write_current_outer_tag(body="/parameterList")

# avanza hasta cerrar el )

self.tokenizer.advance()

self._write_current_terminal_token()

def compile_subroutine_body(self):

self._write_current_outer_tag(body="subroutineBody")

# escribimos la llave inicial {

self._write_current_terminal_token()

while self._not_terminal_token_for('subroutine'):

self.tokenizer.advance()

if self._starting_token_for('var_dec'):

self.compile_var_dec()

elif self._statement_token():

self.compile_statements()

else:

self._write_current_terminal_token()

# cerramos la llave }

self._write_current_terminal_token()

self._write_current_outer_tag(body="/subroutineBody")

def compile_var_dec(self):

self._write_current_outer_tag(body="varDec")

self._write_current_terminal_token()

while self._not_terminal_token_for('var_dec'):

self.tokenizer.advance()

self._write_current_terminal_token()

self._write_current_outer_tag(body="/varDec")

def compile_statements(self):

self._write_current_outer_tag(body="statements")

while self._not_terminal_token_for('subroutine'):

if self.tokenizer.current_token == "if":

self.compile_if()

elif self.tokenizer.current_token == "do":

self.compile_do()

elif self.tokenizer.current_token == "let":

self.compile_let()

elif self.tokenizer.current_token == "while":

self.compile_while()

elif self.tokenizer.current_token == "return":

self.compile_return()

self.tokenizer.advance()

self._write_current_outer_tag(body="/statements")

def compile_statement_body(self, not_terminate_func, condition_func, do_something_special_func):

while not_terminate_func():

self.tokenizer.advance()

if condition_func():

do_something_special_func()

else:

self._write_current_terminal_token()

def compile_do(self):

self._write_current_outer_tag(body="doStatement")

self._write_current_terminal_token()

# experimental

def do_terminator_func():

return self._not_terminal_token_for('do')

def do_condition_func():

return self._starting_token_for('expression_list')

def do_do_something_func():

return self.compile_expression_list()

self.compile_statement_body(do_terminator_func, do_condition_func, do_do_something_func)

self._write_current_outer_tag(body="/doStatement")

def compile_let(self):

self._write_current_outer_tag(body="letStatement")

self._write_current_terminal_token()

while self._not_terminal_token_for('let'):

self.tokenizer.advance()

if self._starting_token_for('expression'):

self.compile_expression()

else:

self._write_current_terminal_token()

self._write_current_outer_tag(body="/letStatement")

def compile_while(self):

self._write_current_outer_tag(body="whileStatement")

# escribe

self._write_current_terminal_token()

# avanza hasta el comienzo del (

self.tokenizer.advance()

# compila lo que haya dentro de los paréntesis ()

self.compile_expression()

while self._not_terminal_token_for('while'):

self.tokenizer.advance()

if self._statement_token():

self.compile_statements()

else:

self._write_current_terminal_token()

# escribe el token del terminal

self._write_current_terminal_token()

self._write_current_outer_tag(body="/whileStatement")

def compile_if(self):

self._write_current_outer_tag(body="ifStatement")

# escribe el if

self._write_current_terminal_token()

# avanza hasta el comienzo de la expresión

self.tokenizer.advance()

# compila la expresión dentro de los paréntesis ()

self.compile_expression()

def not_terminate_func():

return self._not_terminal_token_for('if')

def condition_func():

return self._statement_token()

def do_something_special_func():

return self.compile_statements()

self.compile_statement_body(not_terminate_func, condition_func, do_something_special_func)

# compila el else

if self.tokenizer.next_token == "else":

self._write_current_terminal_token()

self.tokenizer.advance()

# escribe el else

self._write_current_terminal_token()

# lo mismo que arriba

self.compile_statement_body(

not_terminate_func,

condition_func,

do_something_special_func

)

# escribe el token del terminal

self._write_current_terminal_token()

self._write_current_outer_tag(body="/ifStatement")

def compile_expression(self):

self._write_current_terminal_token()

self._write_current_outer_tag(body="expression")

if self._starting_token_for('expression') and self._next_token_is_negative_unary_operator():

unary_negative_token = True

else:

unary_negative_token = False

self.tokenizer.advance()

while self._not_terminal_token_for('expression'):

if self._operator_token() and not unary_negative_token:

self._write_current_terminal_token()

self.tokenizer.advance()

else:

self.compile_term()

self._write_current_outer_tag(body="/expression")

self._write_current_terminal_token()

def compile_expression_in_expression_list(self):

self._write_current_outer_tag(body="expression")

# (

while self._not_terminal_token_for('expression'):

if self._operator_token():

self._write_current_terminal_token()

self.tokenizer.advance()

else:

self.compile_term()

# termina.

self._write_current_outer_tag(body="/expression")

# (expresión (',' expresión)* )?

def compile_expression_list(self):

# Escribe (

self._write_current_terminal_token()

self._write_current_outer_tag(body="expressionList")

# se salta el ( inicial

self.tokenizer.advance()

while self._not_terminal_token_for('expression_list'):

self.compile_expression_in_expression_list()

if self._another_expression_coming():

self._write_current_terminal_token()

self.tokenizer.advance()

self._write_current_outer_tag(body="/expressionList")

# escribe )

self._write_current_terminal_token()

def compile_term(self):

self._write_current_outer_tag(body="term")

while self._not_terminal_condition_for_term():

if self.tokenizer.part_of_subroutine_call():

self.compile_expression_list()

elif self._starting_token_for('expression'):

self.compile_expression()

elif self.tokenizer.current_token in self.UNARY_OPERATORS:

self._write_current_terminal_token()

if self._starting_token_for(keyword_token='expression', position='next'):

self.tokenizer.advance()

self.compile_term()

break

else:

self.tokenizer.advance()

# escribe el término interno

self._write_current_outer_tag(body="term")

self._write_current_terminal_token()

self._write_current_outer_tag(body="/term")

else:

self._write_current_terminal_token()

# es decir ., i *

if self._next_token_is_operation_not_in_expression():

self.tokenizer.advance()

break

self.tokenizer.advance()

self._write_current_outer_tag(body="/term")

def compile_return(self):

self._write_current_outer_tag(body="returnStatement")

if self._not_terminal_token_for(keyword_token='return', position='next'):

self.compile_expression()

else: # escribe return y ;

self._write_current_terminal_token()

self.tokenizer.advance()

self._write_current_terminal_token()

self._write_current_outer_tag(body="/returnStatement")

def _write_current_outer_tag(self, body):

self.output_file.write("<{}>\n".format(body))

def _write_current_terminal_token(self):

# conforme al xml esperado

if self.tokenizer.current_token_type() == "STRING_CONST":

tag_name = "stringConstant"

elif self.tokenizer.current_token_type() == "INT_CONST":

tag_name = "integerConstant"

else:

tag_name = self.tokenizer.current_token_type().lower()

if self.tokenizer.current_token_type() == "STRING_CONST":

value = self.tokenizer.current_token.replace("\"", "")

else:

value = self.tokenizer.current_token

self.output_file.write(

"<{}> {} </{}>\n".format(

tag_name,

value,

tag_name

)

)

def _terminal_token_type(self):

return self.tokenizer.current_token_type() in self.TERMINAL_TOKEN_TYPES

def _terminal_keyword(self):

return self.tokenizer.current_token in self.TERMINAL_KEYWORDS

def _not_terminal_token_for(self, keyword_token, position='current'):

if position == 'current':

return not self.tokenizer.current_token in self.TERMINATING_TOKENS[keyword_token]

elif position == 'next':

return not self.tokenizer.next_token in self.TERMINATING_TOKENS[keyword_token]

def _starting_token_for(self, keyword_token, position='current'):

if position == 'current':

return self.tokenizer.current_token in self.STARTING_TOKENS[keyword_token]

elif position == 'next':

return self.tokenizer.next_token in self.STARTING_TOKENS[keyword_token]

def _statement_token(self):

return self.tokenizer.current_token in self.STATEMENT_TOKENS

def _operator_token(self, position='current'):

if position == 'current':

return self.tokenizer.current_token in self.OPERATORS

elif position == 'next':

return self.tokenizer.next_token in self.OPERATORS

def _next_token_is_negative_unary_operator(self):

return self.tokenizer.next_token == "-"

def _another_expression_coming(self):

return self.tokenizer.current_token == ","

def _not_terminal_condition_for_term(self):

# la expresión cubre todas las bases

return self._not_terminal_token_for('expression')

def _next_token_is_operation_not_in_expression(self):

return self._operator_token(position='next') and not self._starting_token_for('expression')