diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 000000000..7cbe27504 Binary files /dev/null and b/.DS_Store differ diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 62ff3680b..9fb3b7bf2 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -1,83 +1,83 @@ -name: Tests - -on: [push, pull_request] - -jobs: - lexer: - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - - name: Setup Python - uses: actions/setup-python@v2 - - - name: Install requirements - run: pip install -r requirements.txt - - - name: Run tests - run: | - cd src - make clean - make - make test TAG=lexer - - parser: - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - - name: Setup Python - uses: actions/setup-python@v2 - - - name: Install requirements - run: pip install -r requirements.txt - - - name: Run tests - run: | - cd src - make clean - make - make test TAG=parser - - semantic: - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - - name: Setup Python - uses: actions/setup-python@v2 - - - name: Install requirements - run: pip install -r requirements.txt - - - name: Run tests - run: | - cd src - make clean - make - make test TAG=semantic - - codegen: - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - - name: Setup Python - uses: actions/setup-python@v2 - - - name: Install requirements - run: pip install -r requirements.txt - - - name: Install spim - run: sudo apt-get install spim - - - name: Run tests - run: | - cd src - make clean - make - make test TAG=codegen +name: Tests + +on: [push, pull_request] + +jobs: + lexer: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Setup Python + uses: actions/setup-python@v2 + + - name: Install requirements + run: pip install -r requirements.txt + + - name: Run tests + run: | + cd src + make clean + make + make test TAG=lexer + + parser: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Setup Python + uses: actions/setup-python@v2 + + - name: Install requirements + run: pip install -r requirements.txt + + - name: Run tests + run: | + cd src + make clean + make + make test TAG=parser + + semantic: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Setup Python + uses: actions/setup-python@v2 + + - name: Install requirements + run: pip install -r requirements.txt + + - name: Run tests + run: | + cd src + make clean + make + make test TAG=semantic + + codegen: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + + - name: Setup Python + uses: actions/setup-python@v2 + + - name: Install requirements + run: pip install -r requirements.txt + + - name: Install spim + run: sudo apt-get install spim + + - name: Run tests + run: | + cd src + make clean + make + make test TAG=codegen diff --git a/.gitignore b/.gitignore index 4acafde18..0b07f7b23 100644 --- a/.gitignore +++ b/.gitignore @@ -1,410 +1,410 @@ -# File created using '.gitignore Generator' for Visual Studio Code: https://bit.ly/vscode-gig - -# Created by https://www.gitignore.io/api/visualstudiocode,linux,latex,python -# Edit at https://www.gitignore.io/?templates=visualstudiocode,linux,latex,python - -### LaTeX ### -## Core latex/pdflatex auxiliary files: -*.aux -*.lof -*.log -*.lot -*.fls -*.out -*.toc -*.fmt -*.fot -*.cb -*.cb2 -.*.lb - -## Intermediate documents: -*.dvi -*.xdv -*-converted-to.* -# these rules might exclude image files for figures etc. -# *.ps -# *.eps -# *.pdf - -## Generated if empty string is given at "Please type another file name for output:" -.pdf - -## Bibliography auxiliary files (bibtex/biblatex/biber): -*.bbl -*.bcf -*.blg -*-blx.aux -*-blx.bib -*.run.xml - -## Build tool auxiliary files: -*.fdb_latexmk -*.synctex -*.synctex(busy) -*.synctex.gz -*.synctex.gz(busy) -*.pdfsync - -## Build tool directories for auxiliary files -# latexrun -latex.out/ - -## Auxiliary and intermediate files from other packages: -# algorithms -*.alg -*.loa - -# achemso -acs-*.bib - -# amsthm -*.thm - -# beamer -*.nav -*.pre -*.snm -*.vrb - -# changes -*.soc - -# comment -*.cut - -# cprotect -*.cpt - -# elsarticle (documentclass of Elsevier journals) -*.spl - -# endnotes -*.ent - -# fixme -*.lox - -# feynmf/feynmp -*.mf -*.mp -*.t[1-9] -*.t[1-9][0-9] -*.tfm - -#(r)(e)ledmac/(r)(e)ledpar -*.end -*.?end -*.[1-9] -*.[1-9][0-9] -*.[1-9][0-9][0-9] -*.[1-9]R -*.[1-9][0-9]R -*.[1-9][0-9][0-9]R -*.eledsec[1-9] -*.eledsec[1-9]R -*.eledsec[1-9][0-9] -*.eledsec[1-9][0-9]R -*.eledsec[1-9][0-9][0-9] -*.eledsec[1-9][0-9][0-9]R - -# glossaries -*.acn -*.acr -*.glg -*.glo -*.gls -*.glsdefs - -# uncomment this for glossaries-extra (will ignore makeindex's style files!) -# *.ist - -# gnuplottex -*-gnuplottex-* - -# gregoriotex -*.gaux -*.gtex - -# htlatex -*.4ct -*.4tc -*.idv -*.lg -*.trc -*.xref - -# hyperref -*.brf - -# knitr -*-concordance.tex -# TODO Comment the next line if you want to keep your tikz graphics files -*.tikz -*-tikzDictionary - -# listings -*.lol - -# luatexja-ruby -*.ltjruby - -# makeidx -*.idx -*.ilg -*.ind - -# minitoc -*.maf -*.mlf -*.mlt -*.mtc[0-9]* -*.slf[0-9]* -*.slt[0-9]* -*.stc[0-9]* - -# minted -_minted* -*.pyg - -# morewrites -*.mw - -# nomencl -*.nlg -*.nlo -*.nls - -# pax -*.pax - -# pdfpcnotes -*.pdfpc - -# sagetex -*.sagetex.sage -*.sagetex.py -*.sagetex.scmd - -# scrwfile -*.wrt - -# sympy -*.sout -*.sympy -sympy-plots-for-*.tex/ - -# pdfcomment -*.upa -*.upb - -# pythontex -*.pytxcode -pythontex-files-*/ - -# tcolorbox -*.listing - -# thmtools -*.loe - -# TikZ & PGF -*.dpth -*.md5 -*.auxlock - -# todonotes -*.tdo - -# vhistory -*.hst -*.ver - -# easy-todo -*.lod - -# xcolor -*.xcp - -# xmpincl -*.xmpi - -# xindy -*.xdy - -# xypic precompiled matrices -*.xyc - -# endfloat -*.ttt -*.fff - -# Latexian -TSWLatexianTemp* - -## Editors: -# WinEdt -*.bak -*.sav - -# Texpad -.texpadtmp - -# LyX -*.lyx~ - -# Kile -*.backup - -# KBibTeX -*~[0-9]* - -# auto folder when using emacs and auctex -./auto/* -*.el - -# expex forward references with \gathertags -*-tags.tex - -# standalone packages -*.sta - -### LaTeX Patch ### -# glossaries -*.glstex - -### Linux ### -*~ - -# temporary files which can be created if a process still has a handle open of a deleted file -.fuse_hidden* - -# KDE directory preferences -.directory - -# Linux trash folder which might appear on any partition or disk -.Trash-* - -# .nfs files are created when an open file is removed but is still being accessed -.nfs* - -### Python ### -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] -*$py.class - -# C extensions -*.so - -# Distribution / packaging -.Python -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -pip-wheel-metadata/ -share/python-wheels/ -*.egg-info/ -.installed.cfg -*.egg -MANIFEST - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.nox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -.hypothesis/ -.pytest_cache/ - -# Translations -*.mo -*.pot - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -target/ - -# pyenv -.python-version - -# pipenv -# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. -# However, in case of collaboration, if having platform-specific dependencies or dependencies -# having no cross-platform support, pipenv may install dependencies that don't work, or not -# install all needed dependencies. -#Pipfile.lock - -# celery beat schedule file -celerybeat-schedule - -# SageMath parsed files -*.sage.py - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# Mr Developer -.mr.developer.cfg -.project -.pydevproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ -.dmypy.json -dmypy.json - -# Pyre type checker -.pyre/ - -### VisualStudioCode ### -.vscode/* -!.vscode/settings.json -!.vscode/tasks.json -!.vscode/launch.json -!.vscode/extensions.json - -### VisualStudioCode Patch ### -# Ignore all local history of files -.history - -# End of https://www.gitignore.io/api/visualstudiocode,linux,latex,python - -# Custom rules (everything added below won't be overriden by 'Generate .gitignore File' if you use 'Update' option) - +# File created using '.gitignore Generator' for Visual Studio Code: https://bit.ly/vscode-gig + +# Created by https://www.gitignore.io/api/visualstudiocode,linux,latex,python +# Edit at https://www.gitignore.io/?templates=visualstudiocode,linux,latex,python + +### LaTeX ### +## Core latex/pdflatex auxiliary files: +*.aux +*.lof +*.log +*.lot +*.fls +*.out +*.toc +*.fmt +*.fot +*.cb +*.cb2 +.*.lb + +## Intermediate documents: +*.dvi +*.xdv +*-converted-to.* +# these rules might exclude image files for figures etc. +# *.ps +# *.eps +# *.pdf + +## Generated if empty string is given at "Please type another file name for output:" +.pdf + +## Bibliography auxiliary files (bibtex/biblatex/biber): +*.bbl +*.bcf +*.blg +*-blx.aux +*-blx.bib +*.run.xml + +## Build tool auxiliary files: +*.fdb_latexmk +*.synctex +*.synctex(busy) +*.synctex.gz +*.synctex.gz(busy) +*.pdfsync + +## Build tool directories for auxiliary files +# latexrun +latex.out/ + +## Auxiliary and intermediate files from other packages: +# algorithms +*.alg +*.loa + +# achemso +acs-*.bib + +# amsthm +*.thm + +# beamer +*.nav +*.pre +*.snm +*.vrb + +# changes +*.soc + +# comment +*.cut + +# cprotect +*.cpt + +# elsarticle (documentclass of Elsevier journals) +*.spl + +# endnotes +*.ent + +# fixme +*.lox + +# feynmf/feynmp +*.mf +*.mp +*.t[1-9] +*.t[1-9][0-9] +*.tfm + +#(r)(e)ledmac/(r)(e)ledpar +*.end +*.?end +*.[1-9] +*.[1-9][0-9] +*.[1-9][0-9][0-9] +*.[1-9]R +*.[1-9][0-9]R +*.[1-9][0-9][0-9]R +*.eledsec[1-9] +*.eledsec[1-9]R +*.eledsec[1-9][0-9] +*.eledsec[1-9][0-9]R +*.eledsec[1-9][0-9][0-9] +*.eledsec[1-9][0-9][0-9]R + +# glossaries +*.acn +*.acr +*.glg +*.glo +*.gls +*.glsdefs + +# uncomment this for glossaries-extra (will ignore makeindex's style files!) +# *.ist + +# gnuplottex +*-gnuplottex-* + +# gregoriotex +*.gaux +*.gtex + +# htlatex +*.4ct +*.4tc +*.idv +*.lg +*.trc +*.xref + +# hyperref +*.brf + +# knitr +*-concordance.tex +# TODO Comment the next line if you want to keep your tikz graphics files +*.tikz +*-tikzDictionary + +# listings +*.lol + +# luatexja-ruby +*.ltjruby + +# makeidx +*.idx +*.ilg +*.ind + +# minitoc +*.maf +*.mlf +*.mlt +*.mtc[0-9]* +*.slf[0-9]* +*.slt[0-9]* +*.stc[0-9]* + +# minted +_minted* +*.pyg + +# morewrites +*.mw + +# nomencl +*.nlg +*.nlo +*.nls + +# pax +*.pax + +# pdfpcnotes +*.pdfpc + +# sagetex +*.sagetex.sage +*.sagetex.py +*.sagetex.scmd + +# scrwfile +*.wrt + +# sympy +*.sout +*.sympy +sympy-plots-for-*.tex/ + +# pdfcomment +*.upa +*.upb + +# pythontex +*.pytxcode +pythontex-files-*/ + +# tcolorbox +*.listing + +# thmtools +*.loe + +# TikZ & PGF +*.dpth +*.md5 +*.auxlock + +# todonotes +*.tdo + +# vhistory +*.hst +*.ver + +# easy-todo +*.lod + +# xcolor +*.xcp + +# xmpincl +*.xmpi + +# xindy +*.xdy + +# xypic precompiled matrices +*.xyc + +# endfloat +*.ttt +*.fff + +# Latexian +TSWLatexianTemp* + +## Editors: +# WinEdt +*.bak +*.sav + +# Texpad +.texpadtmp + +# LyX +*.lyx~ + +# Kile +*.backup + +# KBibTeX +*~[0-9]* + +# auto folder when using emacs and auctex +./auto/* +*.el + +# expex forward references with \gathertags +*-tags.tex + +# standalone packages +*.sta + +### LaTeX Patch ### +# glossaries +*.glstex + +### Linux ### +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* + +# .nfs files are created when an open file is removed but is still being accessed +.nfs* + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +### VisualStudioCode ### +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json + +### VisualStudioCode Patch ### +# Ignore all local history of files +.history + +# End of https://www.gitignore.io/api/visualstudiocode,linux,latex,python + +# Custom rules (everything added below won't be overriden by 'Generate .gitignore File' if you use 'Update' option) + diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 000000000..13566b81b --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/cool-compiler-2021.iml b/.idea/cool-compiler-2021.iml new file mode 100644 index 000000000..8b8c39547 --- /dev/null +++ b/.idea/cool-compiler-2021.iml @@ -0,0 +1,12 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 000000000..105ce2da2 --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 000000000..59e0b8397 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 000000000..b174ac29c --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 000000000..94a25f7f4 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 000000000..5ea983db6 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,5 @@ +{ + "recommendations": [ + "yzane.markdown-pdf" + ] +} \ No newline at end of file diff --git a/doc/Informe.md b/doc/Informe.md new file mode 100644 index 000000000..8bc7dfcf3 --- /dev/null +++ b/doc/Informe.md @@ -0,0 +1,127 @@ +# Informe de Complementos de Compilación +## Datos Generales +### Autores +- Luis Alejandro Lara Rojas +- Carlos Alejandro Arrieta Montes de Oca + + +## Ejecución +Para ejecutar el proyecto se necesita tener instalado `Python` y el conjunto de dependencias listado en [requirements.txt](https://github.com/Los-Mangotes-SA/cool-compiler-2021/blob/master/requirements.txt). + +Para instalar las dependencias desde la dirección `/src`, puede utilizar: +```bash +make install +``` +Una vez estén instaladas las dependencias, puede compilar y ejecutar cualquier archivo de código cool utilizando el comando: +```bash +make main .cl +``` + +### Sobre el proyecto +Para el diseño e implementación de este proyecto se toma como base los contenidos adquiridos durante tercer año de análisis lexicográfico, sintáctico y semántico de programas en lenguaje COOL. + +Este proyecto está basado en gran parte en las implementaciones hechas durante tercer año del Lexer, Parser y Semantic Checker. + + +## Estructura del proyecto +Como se puede ver en [main.py](https://github.com/Los-Mangotes-SA/cool-compiler-2021/blob/master/src/main.py) el proyecto está estructurado en 4 componentes principales: + +1. Lexer +2. Parser +3. Semantic Checker +4. Code Generator + +Cada una de estas componentes será explicada con mayor detenimiento a continuación. + +## Lexer + +Para esta componente se utilizó el paquete de Python PLY lex. + +Basicamente nos auxiliamos de todo el poder que nos brinda PLY y las expresiones regulares, lo que nos causó mayor problema +fueron los comentarios y los strings, en cuyos casos se utilizaron expresiones regulares para detectar el comienzo, y se usaron algoritmos +creados por nosotros para formar el string o ignorar el comentario hasta su fin, siempre manteniendo actualizado el número de línea +para poder brindar mejores mensajes de error y poder pasar los tests + +## Parser +Para el parser se ha utilizado el paquete de Python PLY yacc. + +Usamos la facilidad que nos brinda esta biblioteca, y usando una gramática generamos un ast de Cool + +## Semantic Checker +Esta componente se ha dividido a su vez en 3 componentes principales: +- Type Collector: encargado de recolectar los tipos. +- Type Builder: encargado de construir los tipos. +- Type Checker: encargado de hacer chequeo de tipos. + +Cada una de estas sub-componentes serán explicadas a continuación. +### Type Collector +Durante la recolección de tipos se visitan todas las declaraciones de clases, se crean los tipos asociados a ellas y se valida la correctitud de las mismas. + +**Errores detectados**: +- Herencia cíclica +- Redefinición de clases +- Nombres de clase no válidos + +### Type builder +A los tipos creados en la fase anterior se le añaden todos sus atributos y métodos. + +**Errores detectados**: +- Mal uso de herencia +- Uso de tipos no definidos +- Problemas de nombrado de atributos y métodos +- Redefinición de atributos +- Redefinición incorrecta de métodos + +### Type checker +En esta fase se evalúa la correctitud de todas las expresiones del lenguaje y se decide el tipo estático de cada una de ellas. + +**Errores detectados**: +- Incompatibilidad de tipos +- Uso de tipos no definidos +- Uso de variables, tipos y métodos no definidos +- mal usos de `self` y `SELF_TYPE` +- mal usos del `case` + +## Code Generator +Esta componente a su vez está constituida por 2 sub-componentes: +- COOL-CIL Converter: encargado de convertir el ast de Cool a un ast de CIL +- CIL-MIPS Converter: encargado de convertir ast de CIL ast de MIPS. + +### COOL-CIL Converter +En esta etapa del proceso de compilación, requirió especial atención la generación de las expresiones *case*. Para ello se requiere ordenar las instrucciones de tal modo que se asegure el emparejamiento del tipo de la expresión principal con el tipo más específico declarado en las ramas del *case*. + +**Errores detectados**: +- Dispatch estático o dinámico desde un objeto void +- Ejecución de un *case* sin que ocurra algún emparejamiento con alguna rama. +- División por cero +- Substring fuera de rango + +> Aunque estos errores realmente se detectan en ejecución, es en esta fase que se genera el código que permite detectarlos. + +### CIL-MIPS Converter +Para esta fase se ejecuta un recorrido por los nodos de CIL, creando las instrucciones equivalentes en MIPS. Como apoyo a la hora de generar las instrucciones en MIPS, se utilizó + +El código para llamar las funciones y crearlas tiene estrecha relación con el diseño del Registro de Activación. + +Las principales ideas durante la implementación del Registro de Activación son: +- El resultado siempre se guarda en el acumulador. +- Los parámetros son guardados en el Registro de Activación y son introducidos antes de llamar en orden inverso. +- Es necesario guardar la dirección de retorno. +- Se utiliza el $fp como guía para obtener tanto los parámetros como las variables locales, por lo que conviene guardarlo antes de llamar y recuperarlo al volver. +- El cuerpo es quien introduce las variables locales. +- El iésimo parámetro está en $fp + 4(i + 1) y la iésima variable local está en $fp -4(i + 1). + +En este caso se asume que los registros están sucios, entonces no hay necesidad de guardarlos y recuperarlos antes y después de los llamados, lo cual mantiene simple el código, y podría ser hasta más eficiente. + +La representación de los objetos se implementó siguiendo las siguientes ideas: +- Los objetos se guardan en memoria de forma contigua. +- Cada atributo está ubicado en el mismo compartimento del objeto. +- Cuando se llama a un método el objeto es self. +- El id de clase es la dirección asociada al string que contiene su nombre. +- El tamaño es el entero que representa la cantidad de word que componen el objeto. +- Se tiene un Dispatch Ptr, que representa un puntero a una tabla de métodos. +- Si X hereda de Y, la representación de X es igual a la de Y, excepto que se adicionan nuevos espacios para el resto de atributos. +- Los atributos están de forma consecutiva. +- Cada atributo está ubicado en el mismo corrimiento para todas las subclases. + +A cada clase se le asigna un puntero a una dirección de memoria que indexa todos sus métodos(Dispatch Ptr), incluyendo los heredados. De esta forma se logra que los métodos y los atributos de una clase A y todas sus subclases, se encuentren en los mismos compartimentos. \ No newline at end of file diff --git a/doc/Informe.pdf b/doc/Informe.pdf new file mode 100644 index 000000000..3dba4f2e6 Binary files /dev/null and b/doc/Informe.pdf differ diff --git a/requirements.txt b/requirements.txt index 9eb0cad1a..cba16ee2f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1,3 @@ pytest pytest-ordering +ply diff --git a/src/compiler_components/__init__.py b/src/compiler_components/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/src/compiler_components/ast.py b/src/compiler_components/ast.py new file mode 100644 index 000000000..0d4b37917 --- /dev/null +++ b/src/compiler_components/ast.py @@ -0,0 +1,361 @@ +class Node: + def visit(self, tabs = 0): + self.line = -1 + + +class ProgramNode(Node): + def __init__(self, declarations): + self.declarations = declarations + self.line = 1 + self.column = 1 + + + def visit(self, tabs = 0): + node = self + ans = '\t' * tabs + f'\\__ProgramNode [ ... ]' + statements = '\n'.join(child.visit( tabs + 1) for child in node.declarations) + return f'{ans}\n{statements}' + + +class DeclarationNode(Node): + pass + + +class ExpressionNode(Node): + pass + + +class AtomicNode(ExpressionNode): + def __init__(self, lex, line, column): + self.lex = lex + self.line = line + self.column = column + + def visit(self, tabs = 0): + node = self + return '\t' * tabs + f'\\__ {node.__class__.__name__}: {node.lex}' + + +class ClassDeclarationNode(DeclarationNode): + def __init__(self, idx, features, parent=None, line = -1, column=-1, line_father = -1, column_father = -1, type_line = -1, type_column = -1): + self.id = idx + self.parent = parent + self.features = features + self.line = line + self.column = column + self.line_father = line_father + self.column_father = column_father + self.type_line = type_line + self.type_column = type_column + + def visit(self, tabs = 0): + node = self + parent = '' if node.parent is None else f": {node.parent}" + ans = '\t' * tabs + f'\\__ClassDeclarationNode: class {node.id} {parent} {{ ... }}' + features = '\n'.join(child.visit( tabs + 1) for child in node.features) + return f'{ans}\n{features}' + + +class FuncDeclarationNode(DeclarationNode): + def __init__(self, idx, params, return_type, body, line = -1, column=-1): + self.id = idx + self.params = params + self.type = return_type + self.body = body + self.line = line + self.column = column + + def visit(self, tabs = 0): + node = self + params = ', '.join(':'.join(param) for param in node.params) + ans = '\t' * tabs + f'\\__FuncDeclarationNode: def {node.id}({params}) : {node.type} -> ' + body = node.body.visit( tabs + 1) + self.line = -1 + return f'{ans}\n{body}' + + +class AttrDeclarationNode(DeclarationNode): + def __init__(self, idx, typex, expr = None, line = -1, column=-1, type_line = -1, type_column = -1): + self.id = idx + self.type = typex + self.expr = expr + self.line = line + self.column = column + self.type_line = type_line + self.type_column = type_column + + def visit(self, tabs = 0): + node = self + ans = '\t' * tabs + f'\\__AttrDeclarationNode: {node.id} : {node.type} <-- ' + if not self.expr is None: + ans += "\n" + self.expr.visit(tabs+1) + return f'{ans}' + + +class VarDeclarationNode(ExpressionNode): + def __init__(self, idx, typex, expr, line = -1, column=-1): + self.id = idx + self.type = typex + self.expr = expr + self.line = line + self.column = column + + def visit(self, tabs = 0): + node = self + ans = '\t' * tabs + f'\\__VarDeclarationNode: let {node.id} : {node.type} = ' + expr = node.expr.visit( tabs + 1) + return f'{ans}\n{expr}' + + +class AssignNode(AtomicNode): + def __init__(self, idx, expr, line = -1, column=-1): + self.id = idx + self.expr = expr + self.line = line + self.column = column + + def visit(self, tabs = 0): + node = self + ans = '\t' * tabs + f'\\__AssignNode: let {node.id} = ' + expr = node.expr.visit( tabs + 1) + return f'{ans}\n{expr}' + + +class IsVoidNode(AtomicNode): + def __init__(self, expr, line = -1, column=-1): + self.expr = expr + self.line = line + self.column = column + + def visit(self, tabs = 0): + ans = '\t'*tabs + "\\__IsVoid " + return ans + '\n' + '\t'*(tabs+1) + self.expr.visit() + + +class NotNode(AtomicNode): + def __init__(self, expr, line = -1, column=-1): + self.expr = expr + self.line = line + self.column = column + + def visit(self, tabs = 0): + ans = '\t'*tabs + "\\__NOT " + return ans + '\n' + '\t'*(tabs+1) + self.expr.visit() + + +class NhanharaNode(AtomicNode): + def __init__(self, expr, line = -1, column=-1): + self.expr = expr + self.line = line + self.column = column + + def visit(self, tabs = 0): + ans = '\t'*tabs + "\\__~ " + return ans + '\n' + '\t'*(tabs+1) + self.expr.visit() + + +class CallNode(AtomicNode): + def __init__(self, obj, idx, args = None, type = None, line = -1, column=-1): + self.obj = obj + self.id = idx + if args is None: + self.args = [] + else: + self.args = args + self.type = type + self.line = line + self.column = column + + def visit(self, tabs = 0): + node = self + if not self.obj is None: + obj = node.obj.visit( tabs + 1) + else: + obj = "" + if not self.type is None: + arroba = f'@{self.type}' + else: + arroba = "" + + if not self.args is None: + ans = '\t' * tabs + f'\\__CallNode: {arroba}.{node.id}(, ..., )' + else: + ans = '\t' * tabs + f'\\__CallNode: {arroba}.{node.id}()' + if not self.args is None: + args = '\n'.join(arg.visit( tabs + 1) for arg in node.args) + else: + args = "" + + return f'{ans}\n{obj}\n{args}' + + +class IfNode(AtomicNode): + def __init__(self, if_c, then_c, else_c, line = -1, column=-1): + self.if_c = if_c + self.then_c = then_c + self.else_c = else_c + self.line = line + self.column = column + + def visit(self, tabs = 0): + node = self + ans = '\t'*tabs + 'if then else fi' + ans += "\n" + '\t'*(tabs +1) + "IF: " + self.if_c.visit() + ans += "\n" + '\t'*(tabs +1) + "then: " + self.then_c.visit() + ans += "\n" + '\t'*(tabs +1) + "else: " + self.else_c.visit() + return ans + + +class WhileNode(AtomicNode): + def __init__(self, condition, body, line = -1, column=-1): + self.condition = condition + self.body = body + self.line = line + self.column = column + + def visit(self, tabs = 0): + node = self + ans = '\t'*tabs + 'while loop pool' + ans += "\n" + '\t'*(tabs +1) + "condition: " + self.condition.visit() + ans += "\n" + '\t'*(tabs +1) + "body: " + self.body.visit() + + return ans + + +class BlockNode(AtomicNode): + def __init__(self, expr_list, line=-1, column=-1): + self.expr_list = expr_list + self.line = line + self.column = column + + def visit(self, tabs = 0): + ans = '\t'*tabs + " {; .... ;}\n" + exprs = '\n'.join(param.visit(tabs + 1) for param in self.expr_list) + return ans+exprs + + +class LetNode(AtomicNode): + def __init__(self, list_decl, expr, line = -1, column=-1): + self.list_decl = list_decl + self.expr = expr + self.line = line + self.column = column + + def visit(self, tabs = 0): + ans = '\t'*tabs + " LET , ... in \n " + decl = '\n'.join('\t'*(tabs+1) + "decl: " + param.visit() for param in self.list_decl) + expr = "\n" + "IN" + self.expr.visit(tabs+1) + return ans+decl+expr + + +class CaseNode(AtomicNode): + def __init__(self, expr, list_case, line = -1, column=-1): + self.list_case = list_case + self.expr = expr + self.line = line + self.column = column + + def visit(self, tabs = 0): + ans = '\t'*tabs + "\\__Case in esac" + expr = '\t'*(tabs+1) + self.expr.visit() + l = '\n'.join('\t'*(tabs+1) + "list_case[i]: " + e.visit() for e in self.list_case) + return ans+"\n"+expr+"\n" +l + + +class BinaryNode(ExpressionNode): + def __init__(self, left, right, line = -1, column=-1): + self.left = left + self.right = right + self.line = line + self.column = column + + def visit(self, tabs = 0): + node = self + ans = '\t' * tabs + f'\\__ {node.__class__.__name__} ' + left = node.left.visit( tabs + 1) + right = node.right.visit( tabs + 1) + return f'{ans}\n{left}\n{right}' + + +class ArithmeticNode(BinaryNode): + pass + +class MathNode(ArithmeticNode): + pass + +class ConstantNumNode(AtomicNode): + pass + + +class ConstantStringNode(AtomicNode): + pass + + +class ConstantBooleanNode(AtomicNode): + pass + + +class SelfNode(AtomicNode): + pass + + +class DispatchNode(ExpressionNode): + def __init__(self, expr, f, params, typex = None, line = -1, column=-1): + self.id = f + self.expr = expr + self.f = f + if params is None: + self.params = [] + else: + self.params = params + self.typex = typex + self.line = line + self.column = column + + def visit(self, tabs = 0): + node = self + if not self.typex: + ans = '\t' * tabs + f'\\__.{self.f} ' + else: + ans = '\t' * tabs + f'\\__@{self.typex}.{self.f} ' + expr = node.expr.visit( tabs + 1) + params = '\n'.join(param.visit( tabs + 1) for param in node.params) + return f'{ans}\n{expr}\n{params}' + + +class VariableNode(AtomicNode): + pass + + +class InstantiateNode(AtomicNode): + def visit(self, tabs): + node = self + return '\t' * tabs + f'\\__ InstantiateNode: new {node.lex}()' + + +class PlusNode(MathNode): + pass + + +class MinusNode(MathNode): + pass + + +class StarNode(MathNode): + pass + + +class DivNode(MathNode): + pass + + +class MinorNode(ArithmeticNode): + pass + + +class MinorEqualsNode(ArithmeticNode): + pass + + +class EqualsNode(ArithmeticNode): + pass diff --git a/src/compiler_components/base_to_cil.py b/src/compiler_components/base_to_cil.py new file mode 100644 index 000000000..a60fca574 --- /dev/null +++ b/src/compiler_components/base_to_cil.py @@ -0,0 +1,158 @@ +from . import cil +import sys +sys.path.append('./semantic') +from .semantic.structures import * +import queue + +class BaseToCil: + def __init__(self, context): + self.dottypes = [] + self.dotdata = [ cil.DataNode('_empty', '')] + self.dotcode = [] + self.current_type = None + self.current_method = None + self.current_function = None + self.context = context + self.basic_types() + + @property + def params(self): + return self.current_function.params + + @property + def localvars(self): + return self.current_function.localvars + + @property + def instructions(self): + return self.current_function.instructions + + @property + def labels(self): + return self.current_function.labels + + def basic_types(self): + for basicType in ['Int', 'String', 'Bool']: + cil_type = self.register_type(basicType) + cil_type.attributes.append(self.to_attribute_name('value', basicType)) + + for method , typeMethod in self.context.get_type(basicType).all_methods(): + cil_type.methods.append((method.name, self.to_function_name(method.name, typeMethod.name))) + + for basicType in ['Object', 'IO']: + cil_type = self.register_type(basicType) + for method , typeMethod in self.context.get_type(basicType).all_methods(): + cil_type.methods.append((method.name, self.to_function_name(method.name, typeMethod.name))) + + + def register_param(self, vinfo): + vinfo.cilName = vinfo.name # f'param_{self.current_function.name[9:]}_{vinfo.name}_{len(self.params)}' + param_node = cil.ParamNode(vinfo.cilName) + self.params.append(param_node) + return vinfo.cilName + + def register_local(self, vinfo): + vinfo.cilName = f'local_{self.current_function.name[9:]}_{vinfo.name}_{len(self.localvars)}' + local_node = cil.LocalNode(vinfo.cilName) + self.localvars.append(local_node) + return vinfo.cilName + + def register_label(self): + name = f'label_{self.current_function.name[9:]}_{len(self.labels)}' + self.labels.append(name) + return name + + def define_internal_local(self): + vinfo = VariableInfo('internal', None) + return self.register_local(vinfo) + + def register_instruction(self, instruction): + self.instructions.append(instruction) + return instruction + + def to_function_name(self, method_name, type_name): + return f'function_{method_name}_at_{type_name}' + + def to_attribute_name(self, attr_name, attr_type): + return f'attribute_{attr_name}' + + def register_function(self, function_name): + function_node = cil.FunctionNode(function_name, [], [], [], []) + self.dotcode.append(function_node) + return function_node + + def register_type(self, name): + type_node = cil.TypeNode(name) + self.dottypes.append(type_node) + return type_node + + def register_data(self, value): + for dataNode in self.dotdata: + if dataNode.value == value: + return dataNode + + vname = f'data_{len(self.dotdata)}' + data_node = cil.DataNode(vname, value) + self.dotdata.append(data_node) + return data_node + + + def get_attr(self, function_name, attribute): + for dottype in self.dottypes: + if dottype.name == function_name: + break + + + # for attrib in dottype.attributes: + # if self.to_attribute_name(attribute, None) == attrib: + # break + + return dottype.attributes.index(self.to_attribute_name(attribute,None)) + + def get_method(self, type_name, method_name): + for typeContext in self.context.types: + if typeContext == type_name: + break + + methods = list(self.context.types[typeContext].all_methods()) + + for m in methods: + if m[0].name == method_name: + break + + return methods.index(m) + + def sort_types(self, types): + q = queue.deque() + lst = [] + for tp1 in types: + if not any ([x for x in types if x!= tp1 and tp1.conforms_to(x) ]): + q.append(tp1) + + while len(q) != 0: + tp = q.popleft() + if tp in types: + lst.append(tp) + for s in tp.sons: + q.append(s) + lst = list(reversed(lst)) + return lst + + def get_preordenTypes(self, typex): + ret_lis = [] + + for son in typex.sons: + ret_lis.extend(self.get_preordenTypes(son)) + + ret_lis.append(typex) + return ret_lis + + + def box(self, typeName, value): + obj_internal = self.define_internal_local() + self.register_instruction(cil.AllocateNode(typeName, obj_internal)) + self.register_instruction(cil.SetAttribNode(obj_internal, 0, value)) + self.register_instruction(cil.LoadNode(obj_internal, f'{typeName}_name')) + self.register_instruction(cil.LoadIntNode(obj_internal, f'{typeName}_size', 4)) + self.register_instruction(cil.LoadNode(obj_internal, f'__virtual_table__{typeName}', 8)) + return obj_internal \ No newline at end of file diff --git a/src/compiler_components/cil.py b/src/compiler_components/cil.py new file mode 100644 index 000000000..0795ace17 --- /dev/null +++ b/src/compiler_components/cil.py @@ -0,0 +1,353 @@ +from . import visitor + + +class Node: + pass + +class ProgramNode(Node): + def __init__(self, dottypes, dotdata, dotcode): + self.dottypes = dottypes + self.dotdata = dotdata + self.dotcode = dotcode + +class TypeNode(Node): + def __init__(self, name): + self.name = name + self.attributes = [] + self.methods = [] + +class DataNode(Node): + def __init__(self, vname, value): + self.name = vname + self.value = value + +class FunctionNode(Node): + def __init__(self, fname, params, localvars, instructions, labels): + self.name = fname + self.params = params + self.localvars = localvars + self.instructions = instructions + self.labels = labels + +class ParamNode(Node): + def __init__(self, name): + self.name = name + +class LocalNode(Node): + def __init__(self, name): + self.name = name + +class InstructionNode(Node): + pass + +class AssignNode(InstructionNode): + def __init__(self, dest, source): + self.dest = dest + self.source = source + +class ArithmeticNode(InstructionNode): + def __init__(self, dest, left, right): + self.dest = dest + self.left = left + self.right = right + +class ComplementNode(InstructionNode): + def __init__(self, expression, dest): + self.expression = expression + self.dest = dest + +class PlusNode(ArithmeticNode): + pass + +class MinusNode(ArithmeticNode): + pass + +class StarNode(ArithmeticNode): + pass + +class DivNode(ArithmeticNode): + pass + +class LessNode(InstructionNode): + def __init__(self, result, left, right, labelTrue, labelEnd): + self.result = result + self.left = left + self.right =right + self.labelTrue = labelTrue + self.labelEnd = labelEnd + +class LessEqualNode(ArithmeticNode): + def __init__(self, result, left, right, labelTrue, labelEnd): + self.result = result + self.left = left + self.right =right + self.labelTrue = labelTrue + self.labelEnd = labelEnd + +class GetAttribNode(InstructionNode): + def __init__(self, ins,att,dest): + self.ins = ins + self.att = att + self.dest = dest + +class SetAttribNode(InstructionNode): + def __init__(self, ins,att, value): + self.ins = ins + self.att = att + self.value = value + +class GetIndexNode(InstructionNode): + pass + +class SetIndexNode(InstructionNode): + pass + +class AllocateNode(InstructionNode): + def __init__(self, itype, dest): + self.type = itype + self.dest = dest + +class JumpNode(InstructionNode): + def __init__(self, method, dest): + self.method = method + self.dest = dest + +class ArrayNode(InstructionNode): + pass + +class TypeOfNode(InstructionNode): + def __init__(self, obj, dest): + self.obj = obj + self.dest = dest + +class IsVoidNode(InstructionNode): + def __init__(self, obj, dest, label): + self.obj = obj + self.dest = dest + self.label = label + +class CaseOption(InstructionNode): + def __init__(self, expression, label, typex): + self.expression = expression + self.label = label + self.typex = typex + +class LabelNode(InstructionNode): + def __init__(self, name): + self.name = name + +class GotoNode(InstructionNode): + def __init__(self, name): + self.name = name + +class GotoIfNode(InstructionNode): + def __init__(self, name, condition): + self.name = name + self.condition = condition + +class StaticCallNode(InstructionNode): + def __init__(self, function, dest): + self.function = function + self.dest = dest + +class DynamicCallNode(InstructionNode): + def __init__(self, xtype, method, dest,ins): + self.type = xtype + self.method = method + self.dest = dest + self.ins = ins + +class ArgsNode(InstructionNode): + def __init__(self, names): + self.names = names + +class ReturnNode(InstructionNode): + def __init__(self, value=None): + self.value = value + +class LoadNode(InstructionNode): + def __init__(self, dest, msg, desp=0): + self.dest = dest + self.msg = msg + self.desp = desp + +class LoadAddressNode(LoadNode): + pass + +class LoadIntNode(InstructionNode): + def __init__(self, dest, msg, desp): + self.dest = dest + self.msg = msg + self.desp = desp + +class LengthNode(InstructionNode): + pass + +class ConcatNode(InstructionNode): + pass + +class PrefixNode(InstructionNode): + pass + +class SubstringNode(InstructionNode): + pass + +class StringComparer(InstructionNode): + def __init__(self, result, left, right): + self.result = result + self.left = left + self.right = right + +class ToStrNode(InstructionNode): + def __init__(self, dest, ivalue): + self.dest = dest + self.ivalue = ivalue + +class ReadNode(InstructionNode): + def __init__(self, dest): + self.dest = dest + +class PrintNode(InstructionNode): + def __init__(self, str_addr): + self.str_addr = str_addr + +def get_formatter(): + + class PrintVisitor(object): + @visitor.on('node') + def visit(self, node): + pass + + @visitor.when(ProgramNode) + def visit(self, node): + dottypes = '\n'.join(self.visit(t) for t in node.dottypes) + dotdata = '\n'.join(self.visit(t) for t in node.dotdata) + dotcode = '\n'.join(self.visit(t) for t in node.dotcode) + + return f'.TYPES\n{dottypes}\n\n.DATA\n{dotdata}\n\n.CODE\n{dotcode}' + + @visitor.when(DataNode) + def visit(self, node): + return f'{node.name}: "{node.value}"' + + @visitor.when(TypeNode) + def visit(self, node): + attributes = '\n\t'.join(f'attribute {x}' for x in node.attributes) + methods = '\n\t'.join(f'method {x}: {y}' for x,y in node.methods) + + return f'type {node.name} {{\n\t{attributes}\n\n\t{methods}\n}}' + + @visitor.when(FunctionNode) + def visit(self, node): + params = '\n\t'.join(self.visit(x) for x in node.params) + localvars = '\n\t'.join(self.visit(x) for x in node.localvars) + instructions = '\n\t'.join(self.visit(x) for x in node.instructions) + + return f'function {node.name} {{\n\t{params}\n\n\t{localvars}\n\n\t{instructions}\n}}' + + # @visitor.when(Node) + # def visit(self, node): + # return f'----------------------------------{node.__class__.__name__}' + + @visitor.when(ParamNode) + def visit(self, node): + return f'PARAM {node.name}' + + @visitor.when(LocalNode) + def visit(self, node): + return f'LOCAL {node.name}' + + @visitor.when(AssignNode) + def visit(self, node:AssignNode): + return f'{node.dest} = {node.source}' + + @visitor.when(GetAttribNode) + def visit(self, node:GetAttribNode): + return f'{node.dest} = GETATTR {node.ins} {node.att}' + + @visitor.when(SetAttribNode) + def visit(self, node:SetAttribNode): + return f'SETATTR {node.ins} {node.att} {node.value}' + + @visitor.when(PlusNode) + def visit(self, node): + return f'{node.dest} = {node.left} + {node.right}' + + @visitor.when(MinusNode) + def visit(self, node): + return f'{node.dest} = {node.left} - {node.right}' + + @visitor.when(StarNode) + def visit(self, node): + return f'{node.dest} = {node.left} * {node.right}' + + @visitor.when(DivNode) + def visit(self, node): + return f'{node.dest} = {node.left} / {node.right}' + + @visitor.when(LessEqualNode) + def visit(self, node): + return f'{node.dest} = {node.left} <= {node.right}' + + @visitor.when(LessNode) + def visit(self, node): + return f'{node.result} = {node.left} < {node.right}' + + @visitor.when(AllocateNode) + def visit(self, node): + return f'{node.dest} = ALLOCATE {node.type}' + + @visitor.when(LabelNode) + def visit(self, node): + return f'LABEL {node.name}' + + @visitor.when(JumpNode) + def visit(self, node): + return f'JUMP {node.method}' + + @visitor.when(GotoNode) + def visit(self, node): + return f'GOTO {node.name}' + + @visitor.when(GotoIfNode) + def visit(self, node): + return f'IF {node.condition} GOTO {node.name}' + + @visitor.when(TypeOfNode) + def visit(self, node): + return f'{node.dest} = TYPEOF {node.type}' + + @visitor.when(StaticCallNode) + def visit(self, node): + return f'{node.dest} = CALL {node.function}' + + @visitor.when(DynamicCallNode) + def visit(self, node): + return f'{node.dest} = VCALL {node.type} {node.method}' + + @visitor.when(ArgsNode) + def visit(self, node): + return '\n\t'.join(f'ARG {x}' for x in node.names) + + @visitor.when(ReturnNode) + def visit(self, node): + return f'RETURN {node.value if node.value is not None else ""}' + + @visitor.when(LoadNode) + def visit(self, node): + return f'LOAD {node.dest} {node.msg} {node.desp}' + + @visitor.when(LoadAddressNode) + def visit(self, node): + return f'LOAD_ADDRESS {node.dest} {node.msg} {node.desp}' + + @visitor.when(LoadIntNode) + def visit(self, node): + return f'LOAD_INT {node.dest} {node.msg} {node.desp}' + + @visitor.when(StringComparer) + def visit(self,node): + return f'STRCOMP {node.result}, {node.left}, {node.right}' + + printer = PrintVisitor() + return (lambda ast: printer.visit(ast)) \ No newline at end of file diff --git a/src/compiler_components/cil_mips_converter.py b/src/compiler_components/cil_mips_converter.py new file mode 100644 index 000000000..e7b3fa084 --- /dev/null +++ b/src/compiler_components/cil_mips_converter.py @@ -0,0 +1,431 @@ +from . import visitor +from .cil_nodes import * +from .mips import * + + +class CilToMipsConverter: + def __init__(self): + self.data = [] + self.text = [] + self.function = None + self.types = None + + @visitor.on('node') + def visit(self, node): + pass + + @visitor.when(CilProgramNode) + def visit(self, node): + self.types = node.dottypes + + for typePN in node.dottypes: + self.visit(typePN) + + for dataNode in node.dotdata: + self.visit(dataNode) + + for instructionNode in node.dotcode: + self.visit(instructionNode) + + return MipsProgramNode(self.data, self.text) + + @visitor.when(CilTypeNode) + def visit(self, node): + self.data.append(MipsStringNode(f'{node.name}_name', node.name)) + self.data.append(MipsWordNode(f'{node.name}_size', 4 * (len(node.attributes) + 3))) + self.data.append(MipsTableNode(node.name, [met[1] for met in node.methods])) + + @visitor.when(CilDataNode) + def visit(self, node): + self.data.append(MipsStringNode(node.name, node.value)) + + @visitor.when(CilJumpNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('comienzo llamada al constructor')) + self.register_instruction(MipsJumpAtAddressNode(node.method)) + + num = int(node.dest.split('_')[-1]) + self.register_instruction(MipsSWNode('$a0', f'-{(num + 1) * 4}($fp)')) + self.register_instruction(MipsCommentNode('fin llamada dinamica')) + + @visitor.when(CilFunctionNode) + def visit(self, node): + self.function = node + self.register_instruction(MipsLabelNode(node.name)) + + self.register_instruction(MipsCommentNode('muevo el fp al sp, pongo en sp ra y avanzo la pila')) + self.register_instruction(MipsMoveNode('$fp', '$sp')) + self.register_instruction(MipsSWNode('$ra', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + + self.register_instruction(MipsCommentNode('muevo la pila x las variables locales')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', f'-{len(node.localvars) * 4}')) + + for ins in node.instructions: + self.visit(ins) + + self.register_instruction(MipsCommentNode('return sp, fp, ra')) + self.register_instruction(MipsLWNode('$ra', '0($fp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', f'{len(node.localvars) * 4 + 8 + len(node.params) * 4}')) + self.register_instruction(MipsLWNode('$fp', '0($sp)')) + self.register_instruction(MipsJRNode('$ra')) + + @visitor.when(CilArgsNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('guardando los parametros')) + self.register_instruction(MipsSWNode('$fp', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + + for name in node.names: + pos = self.request_pos(name) + if not pos is None: + self.register_instruction(MipsLWNode('$a0', pos)) + else: + self.register_instruction(MipsLINode('$a0', name)) + + self.register_instruction(MipsSWNode('$a0', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + self.register_instruction(MipsCommentNode(' fin guardando los parametros')) + + @visitor.when(CilReturnNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('retornando el valor')) + pos = self.request_pos(node.value) + + if not pos is None: + self.register_instruction(MipsLWNode('$a0', pos)) + else: + self.register_instruction(MipsLINode('$a0', node.value)) + + @visitor.when(CilAllocateNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('init allocate')) + self.register_instruction(MipsLINode('$v0', '9')) + self.register_instruction(MipsLWNode('$a0', f'{node.type}_size')) + self.register_instruction(MipsSyscallNode()) + + num = int(node.dest.split('_')[-1]) + self.register_instruction(MipsSWNode('$v0', f'-{(num + 1) * 4}($fp)')) + self.register_instruction(MipsCommentNode('end allocate')) + + @visitor.when(CilStaticCallNode) + def visit(self, node): + self.register_instruction(MipsLWNode('$a0', '4($fp)')) + self.register_instruction(MipsLWNode('$a0', '8($a0)')) + self.register_instruction(MipsLWNode('$a0', f'{node.function * 4}($a0)')) + self.register_instruction(MipsJALRNode('$a0')) + + num = int(node.dest.split('_')[-1]) + self.register_instruction(MipsSWNode('$a0', f'-{(num + 1) * 4}($fp)')) + + @visitor.when(CilDynamicCallNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('comienzo llamada dinamica')) + + if node.type is None: + pos = self.request_pos(node.ins) + self.register_instruction(MipsLWNode('$a0', pos)) + self.register_instruction(MipsLWNode('$a0', '8($a0)')) + else: + self.register_instruction(MipsLANode('$a0', f'__virtual_table__{node.type}')) + + self.register_instruction(MipsLWNode('$a0', f'{node.method * 4}($a0)')) + self.register_instruction(MipsJALRNode('$a0')) + + num = int(node.dest.split('_')[-1]) + self.register_instruction(MipsSWNode('$a0', f'-{(num + 1) * 4}($fp)')) + self.register_instruction(MipsCommentNode('fin llamada dinamica')) + + @visitor.when(CilSetAttribNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('init set attribute')) + + pos = self.request_pos(node.ins) + self.register_instruction(MipsLWNode('$a0', pos)) + + # nameType = node.att.split('_')[1] + # num = -1 + + # for typeAct in self.types: + # if typeAct.name == nameType: + # num = typeAct.attributes.index(node.att) + # break + + pos = self.request_pos(node.value) + if not pos is None: + self.register_instruction(MipsLWNode('$t1', pos)) + else: + self.register_instruction(MipsLINode('$t1', node.value)) + + self.register_instruction(MipsSWNode('$t1', f'{node.att * 4 + 12}($a0)')) + self.register_instruction(MipsCommentNode('end set attribute')) + + @visitor.when(CilGetAttribNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('init get attribute')) + + pos_result = self.request_pos(node.dest) + pos = self.request_pos(node.ins) + self.register_instruction(MipsLWNode('$a0', pos)) + + self.register_instruction(MipsLWNode('$a0', f'{node.att * 4 + 12}($a0)')) + self.register_instruction(MipsSWNode('$a0', pos_result)) + + @visitor.when(CilLoadNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('LOAD inicia')) + self.register_instruction(MipsLANode('$t1', node.msg)) + dest = self.request_pos(node.dest) + self.register_instruction(MipsLWNode("$t2", dest)) + self.register_instruction(MipsSWNode('$t1', f"{node.desp}($t2)")) + + @visitor.when(CilLoadAddressNode) + def visit(self, node): + pos = self.request_pos(node.dest) + self.register_instruction(MipsLANode('$t1', node.msg)) + self.register_instruction(MipsSWNode('$t1', pos)) + + @visitor.when(CilLoadIntNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('LOAD inicia')) + self.register_instruction(MipsLWNode('$t1', node.msg)) + dest = self.request_pos(node.dest) + self.register_instruction(MipsLWNode("$t2", dest)) + self.register_instruction(MipsSWNode('$t1', f"{node.desp}($t2)")) + + @visitor.when(CilAssignNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_src = self.request_pos(node.source) + + if not pos_src is None: + self.register_instruction(MipsLWNode('$t1', pos_src)) + else: + self.register_instruction(MipsLINode('$t1', node.source)) + + self.register_instruction(MipsSWNode('$t1', pos_dest)) + + @visitor.when(CilGotoNode) + def visit(self, node): + self.register_instruction(MipsJumpNode(node.name)) + + @visitor.when(CilGotoIfNode) + def visit(self, node): + pos = self.request_pos(node.condition) + + if not pos is None: + self.register_instruction(MipsLWNode('$a0', pos)) + else: + self.register_instruction(MipsLINode('$a0', node.condition)) + + self.register_instruction(MipsBNENode('$a0', '$zero', node.name)) + + @visitor.when(CilLabelNode) + def visit(self, node): + self.register_instruction(MipsLabelNode(node.name)) + + @visitor.when(CilPlusNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsAddNode('$a0', '$a0', '$t1')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(CilMinusNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsMinusNode('$a0', '$t1', '$a0')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(CilStarNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsStarNode('$a0', '$t1', '$a0')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(CilDivNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsDivNode('$a0', '$t1', '$a0')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(CilComplementNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_expression = self.request_pos(node.expression) + + if not pos_expression is None: + self.register_instruction(MipsLWNode('$t1', pos_expression)) + else: + self.register_instruction(MipsLINode('$t1', node.expression)) + + self.register_instruction(MipsLINode('$t2', -1)) + self.register_instruction(MipsStarNode('$t1', '$t1', '$t2')) + self.register_instruction(MipsSWNode('$t1', pos_dest)) + + @visitor.when(CilIsVoidNode) + def visit(self, node): + pos_obj = self.request_pos(node.obj) + pos_dest = self.request_pos(node.dest) + + if not pos_obj is None: + self.register_instruction(MipsLWNode('$t1', pos_obj)) + else: + self.register_instruction(MipsLINode('$a0', 1)) + self.register_instruction(MipsJumpNode(node.label)) + + self.register_instruction(MipsLINode('$a0', 1)) + self.register_instruction(MipsLANode('$t2', '_void')) + self.register_instruction(MipsBNENode('$t1', '$t2', node.label)) + self.register_instruction(MipsLINode('$a0', 0)) + self.register_instruction(MipsLabelNode(node.label)) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(CilLessNode) + def visit(self, node): + pos_dest = self.request_pos(node.result) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsBLTNode('$t1', '$a0', node.labelTrue)) + self.register_instruction(MipsLINode('$a0', 0)) + self.register_instruction(MipsJumpNode(node.labelEnd)) + self.register_instruction(MipsLabelNode(node.labelTrue)) + self.register_instruction(MipsLINode('$a0', 1)) + self.register_instruction(MipsLabelNode(node.labelEnd)) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(CilLessEqualNode) + def visit(self, node): + pos_dest = self.request_pos(node.result) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsBLENode('$t1', '$a0', node.labelTrue)) + self.register_instruction(MipsLINode('$a0', 0)) + self.register_instruction(MipsJumpNode(node.labelEnd)) + self.register_instruction(MipsLabelNode(node.labelTrue)) + self.register_instruction(MipsLINode('$a0', 1)) + self.register_instruction(MipsLabelNode(node.labelEnd)) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(CilStringComparer) + def visit(self, node): + pos_dest = self.request_pos(node.result) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + self.register_instruction(MipsSWNode('$fp', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + + self.register_instruction(MipsLWNode('$a0', pos_left)) + self.register_instruction(MipsSWNode('$a0', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + + self.register_instruction(MipsLWNode('$a0', pos_right)) + self.register_instruction(MipsSWNode('$a0', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + + self.register_instruction(MipsJumpAtAddressNode('function_comparer_string')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(CilCaseOption) + def visit(self, node): + pos_expression = self.request_pos(node.expression) + + if not pos_expression is None: + self.register_instruction(MipsLANode('$a0', f'{node.typex.name}_name')) + self.register_instruction(MipsLWNode('$t1', pos_expression)) + self.register_instruction(MipsLWNode('$t1', '0($t1)')) + self.register_instruction(MipsBEQNode('$t1', '$a0', node.label)) + else: + pass + + # registers + def register_data(self, instruction): + self.data.append(instruction) + + def register_instruction(self, instruction): + self.text.append(instruction) + + # utils + def request_pos(self, name): + if name in [x.name for x in self.function.localvars]: + numb = int(name.split('_')[-1]) + return f'-{(numb + 1) * 4}($fp)' + elif name in [x.name for x in self.function.params]: + numb = [param.name for param in self.function.params].index(name) + return f'{(numb + 1) * 4}($fp)' + else: + return None \ No newline at end of file diff --git a/src/compiler_components/cil_nodes.py b/src/compiler_components/cil_nodes.py new file mode 100644 index 000000000..0035e5e8e --- /dev/null +++ b/src/compiler_components/cil_nodes.py @@ -0,0 +1,254 @@ +class CilNode: + pass + + +class CilProgramNode(CilNode): + def __init__(self, dottypes, dotdata, dotcode): + self.dottypes = dottypes + self.dotdata = dotdata + self.dotcode = dotcode + + +class CilTypeNode(CilNode): + def __init__(self, name): + self.name = name + self.attributes = [] + self.methods = [] + + +class CilDataNode(CilNode): + def __init__(self, vname, value): + self.name = vname + self.value = value + + +class CilFunctionNode(CilNode): + def __init__(self, fname, params, localvars, instructions, labels): + self.name = fname + self.params = params + self.localvars = localvars + self.instructions = instructions + self.labels = labels + + +class CilParamNode(CilNode): + def __init__(self, name): + self.name = name + + +class CilLocalNode(CilNode): + def __init__(self, name): + self.name = name + + +class CilInstructionNode(CilNode): + pass + + +class CilAssignNode(CilInstructionNode): + def __init__(self, dest, source): + self.dest = dest + self.source = source + + +class CilArithmeticNode(CilInstructionNode): + def __init__(self, dest, left, right): + self.dest = dest + self.left = left + self.right = right + + +class CilComplementNode(CilInstructionNode): + def __init__(self, expression, dest): + self.expression = expression + self.dest = dest + + +class CilPlusNode(CilArithmeticNode): + pass + + +class CilMinusNode(CilArithmeticNode): + pass + + +class CilStarNode(CilArithmeticNode): + pass + + +class CilDivNode(CilArithmeticNode): + pass + + +class CilLessNode(CilInstructionNode): + def __init__(self, result, left, right, labelTrue, labelEnd): + self.result = result + self.left = left + self.right = right + self.labelTrue = labelTrue + self.labelEnd = labelEnd + + +class CilLessEqualNode(CilArithmeticNode): + def __init__(self, result, left, right, labelTrue, labelEnd): + self.result = result + self.left = left + self.right =right + self.labelTrue = labelTrue + self.labelEnd = labelEnd + + +class CilGetAttribNode(CilInstructionNode): + def __init__(self, ins,att,dest): + self.ins = ins + self.att = att + self.dest = dest + + +class CilSetAttribNode(CilInstructionNode): + def __init__(self, ins,att, value): + self.ins = ins + self.att = att + + self.value = value + + +class CilGetIndexNode(CilInstructionNode): + pass + + +class CilSetIndexNode(CilInstructionNode): + pass + + +class CilAllocateNode(CilInstructionNode): + def __init__(self, itype, dest): + self.type = itype + self.dest = dest + + +class CilJumpNode(CilInstructionNode): + def __init__(self, method, dest): + self.method = method + self.dest = dest + + +class CilArrayNode(CilInstructionNode): + pass + + +class CilTypeOfNode(CilInstructionNode): + def __init__(self, obj, dest): + self.obj = obj + self.dest = dest + + +class CilIsVoidNode(CilInstructionNode): + def __init__(self, obj, dest, label): + self.obj = obj + self.dest = dest + self.label = label + + +class CilCaseOption(CilInstructionNode): + def __init__(self, expression, label, typex): + self.expression = expression + self.label = label + self.typex = typex + + +class CilLabelNode(CilInstructionNode): + def __init__(self, name): + self.name = name + + +class CilGotoNode(CilInstructionNode): + def __init__(self, name): + self.name = name + + +class CilGotoIfNode(CilInstructionNode): + def __init__(self, name, condition): + self.name = name + self.condition = condition + + +class CilStaticCallNode(CilInstructionNode): + def __init__(self, function, dest): + self.function = function + self.dest = dest + + +class CilDynamicCallNode(CilInstructionNode): + def __init__(self, xtype, method, dest,ins): + self.type = xtype + self.method = method + self.dest = dest + self.ins = ins + + +class CilArgsNode(CilInstructionNode): + def __init__(self, names): + self.names = names + + +class CilReturnNode(CilInstructionNode): + def __init__(self, value=None): + self.value = value + + +class CilLoadNode(CilInstructionNode): + def __init__(self, dest, msg, desp=0): + self.dest = dest + self.msg = msg + self.desp = desp + + +class CilLoadAddressNode(CilLoadNode): + pass + + +class CilLoadIntNode(CilInstructionNode): + def __init__(self, dest, msg, desp): + self.dest = dest + self.msg = msg + self.desp = desp + + +class CilLengthNode(CilInstructionNode): + pass + + +class CilConcatNode(CilInstructionNode): + pass + + +class CilPrefixNode(CilInstructionNode): + pass + + +class CilSubstringNode(CilInstructionNode): + pass + + +class CilStringComparer(CilInstructionNode): + def __init__(self, result, left, right): + self.result = result + self.left = left + self.right = right + + +class CilToStrNode(CilInstructionNode): + def __init__(self, dest, ivalue): + self.dest = dest + self.ivalue = ivalue + + +class CilReadNode(CilInstructionNode): + def __init__(self, dest): + self.dest = dest + + +class CilPrintNode(CilInstructionNode): + def __init__(self, str_addr): + self.str_addr = str_addr diff --git a/src/compiler_components/cil_to_mips.py b/src/compiler_components/cil_to_mips.py new file mode 100644 index 000000000..30c29a340 --- /dev/null +++ b/src/compiler_components/cil_to_mips.py @@ -0,0 +1,463 @@ +from . import visitor +from . import cil +from .mips import * +from .cil import * + +class CilToMips: + def __init__(self): + self.data = [] + self.text = [] + self.function = None + self.types = None + + @visitor.on('node') + def visit(self, node): + pass + + @visitor.when(ProgramNode) + def visit(self, node): + self.types = node.dottypes + + for typePN in node.dottypes: + self.visit(typePN) + + for dataNode in node.dotdata: + self.visit(dataNode) + + for instructionNode in node.dotcode: + self.visit(instructionNode) + + return MipsProgramNode(self.data, self.text) + + + @visitor.when(TypeNode) + def visit(self, node:TypeNode): + self.data.append(MipsStringNode(f'{node.name}_name', node.name)) + self.data.append(MipsWordNode(f'{node.name}_size', 4*(len(node.attributes) + 3))) + self.data.append(MipsTableNode(node.name , [ met[1] for met in node.methods])) + + + @visitor.when(DataNode) + def visit(self, node): + self.data.append(MipsStringNode(node.name, node.value)) + + @visitor.when(JumpNode) + def visit(self, node:DynamicCallNode): + self.register_instruction(MipsCommentNode('comienzo llamada al constructor')) + self.register_instruction(MipsJumpAtAddressNode(node.method)) + + num = int(node.dest.split('_')[-1]) + self.register_instruction(MipsSWNode('$a0', f'-{(num+1) * 4}($fp)')) + self.register_instruction(MipsCommentNode('fin llamada dinamica')) + + + @visitor.when(FunctionNode) + def visit(self, node:FunctionNode): + self.function = node + self.register_instruction(MipsLabelNode(node.name)) + + self.register_instruction(MipsCommentNode('muevo el fp al sp, pongo en sp ra y avanzo la pila')) + self.register_instruction(MipsMoveNode('$fp', '$sp')) + self.register_instruction(MipsSWNode('$ra', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + + self.register_instruction(MipsCommentNode('muevo la pila x las variables locales')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', f'-{len(node.localvars) * 4}')) + + for ins in node.instructions: + self.visit(ins) + + self.register_instruction(MipsCommentNode('return sp, fp, ra')) + self.register_instruction(MipsLWNode('$ra', '0($fp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', f'{len(node.localvars) * 4 + 8 + len(node.params) * 4}')) + self.register_instruction(MipsLWNode('$fp', '0($sp)')) + self.register_instruction(MipsJRNode('$ra')) + + + @visitor.when(ArgsNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('guardando los parametros')) + self.register_instruction(MipsSWNode('$fp', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp' ,'-4')) + + for name in node.names: + pos = self.request_pos(name) + if not pos is None: + self.register_instruction(MipsLWNode('$a0', pos)) + else: + self.register_instruction(MipsLINode('$a0', name)) + + self.register_instruction(MipsSWNode('$a0', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + self.register_instruction(MipsCommentNode(' fin guardando los parametros')) + + + + + @visitor.when(ReturnNode) + def visit(self, node:ReturnNode): + self.register_instruction(MipsCommentNode('retornando el valor')) + pos = self.request_pos(node.value) + + if not pos is None: + self.register_instruction(MipsLWNode('$a0', pos)) + else: + self.register_instruction(MipsLINode('$a0', node.value)) + + @visitor.when(AllocateNode) + def visit(self, node:AllocateNode): + self.register_instruction(MipsCommentNode('init allocate')) + self.register_instruction(MipsLINode('$v0', '9')) + self.register_instruction(MipsLWNode('$a0', f'{node.type}_size')) + self.register_instruction(MipsSyscallNode()) + + num = int(node.dest.split('_')[-1]) + self.register_instruction(MipsSWNode('$v0', f'-{(num+1) * 4}($fp)')) + self.register_instruction(MipsCommentNode('end allocate')) + + + + @visitor.when(StaticCallNode) + def visit(self, node:StaticCallNode): + self.register_instruction(MipsLWNode('$a0', '4($fp)')) + self.register_instruction(MipsLWNode('$a0', '8($a0)')) + self.register_instruction(MipsLWNode('$a0', f'{node.function * 4}($a0)')) + self.register_instruction(MipsJALRNode('$a0')) + + num = int(node.dest.split('_')[-1]) + self.register_instruction(MipsSWNode('$a0', f'-{(num+1) * 4}($fp)')) + + @visitor.when(DynamicCallNode) + def visit(self, node:DynamicCallNode): + self.register_instruction(MipsCommentNode('comienzo llamada dinamica')) + + if node.type is None: + pos = self.request_pos(node.ins) + self.register_instruction(MipsLWNode('$a0', pos)) + self.register_instruction(MipsLWNode('$a0', '8($a0)')) + else: + self.register_instruction(MipsLANode('$a0', f'__virtual_table__{node.type}')) + + self.register_instruction(MipsLWNode('$a0', f'{node.method * 4}($a0)')) + self.register_instruction(MipsJALRNode('$a0')) + + num = int(node.dest.split('_')[-1]) + self.register_instruction(MipsSWNode('$a0', f'-{(num+1) * 4}($fp)')) + self.register_instruction(MipsCommentNode('fin llamada dinamica')) + + + + @visitor.when(SetAttribNode) + def visit(self, node:SetAttribNode): + self.register_instruction(MipsCommentNode('init set attribute')) + + pos = self.request_pos(node.ins) + self.register_instruction(MipsLWNode('$a0', pos)) + + # nameType = node.att.split('_')[1] + # num = -1 + + # for typeAct in self.types: + # if typeAct.name == nameType: + # num = typeAct.attributes.index(node.att) + # break + + + pos = self.request_pos(node.value) + if not pos is None: + self.register_instruction(MipsLWNode('$t1', pos)) + else: + self.register_instruction(MipsLINode('$t1', node.value)) + + self.register_instruction(MipsSWNode('$t1', f'{node.att * 4 + 12}($a0)')) + self.register_instruction(MipsCommentNode('end set attribute')) + + @visitor.when(GetAttribNode) + def visit(self, node:GetAttribNode): + self.register_instruction(MipsCommentNode('init get attribute')) + + pos_result = self.request_pos(node.dest) + pos = self.request_pos(node.ins) + self.register_instruction(MipsLWNode('$a0', pos)) + + # nameType = node.att.split('_')[1] + # num = -1 + + # for typeAct in self.types: + # if typeAct.name == nameType: + # num = typeAct.attributes.index(node.att) + # break + + + self.register_instruction(MipsLWNode('$a0', f'{node.att * 4 + 12}($a0)')) + self.register_instruction(MipsSWNode('$a0', pos_result)) + + + + @visitor.when(LoadNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('LOAD inicia')) + self.register_instruction(MipsLANode('$t1', node.msg)) + dest = self.request_pos(node.dest) + self.register_instruction(MipsLWNode("$t2",dest)) + self.register_instruction(MipsSWNode('$t1', f"{node.desp}($t2)")) + + @visitor.when(LoadAddressNode) + def visit(self, node): + pos = self.request_pos(node.dest) + self.register_instruction(MipsLANode('$t1', node.msg)) + self.register_instruction(MipsSWNode('$t1', pos)) + + @visitor.when(LoadIntNode) + def visit(self, node): + self.register_instruction(MipsCommentNode('LOAD inicia')) + self.register_instruction(MipsLWNode('$t1', node.msg)) + dest = self.request_pos(node.dest) + self.register_instruction(MipsLWNode("$t2",dest)) + self.register_instruction(MipsSWNode('$t1', f"{node.desp}($t2)")) + + + + @visitor.when(AssignNode) + def visit(self, node:AssignNode): + pos_dest = self.request_pos(node.dest) + pos_src = self.request_pos(node.source) + + if not pos_src is None: + self.register_instruction(MipsLWNode('$t1', pos_src)) + else: + self.register_instruction(MipsLINode('$t1', node.source)) + + self.register_instruction(MipsSWNode('$t1', pos_dest)) + + @visitor.when(GotoNode) + def visit(self, node): + self.register_instruction(MipsJumpNode(node.name)) + + @visitor.when(GotoIfNode) + def visit(self, node): + pos = self.request_pos(node.condition) + + if not pos is None: + self.register_instruction(MipsLWNode('$a0', pos)) + else: + self.register_instruction(MipsLINode('$a0', node.condition)) + + self.register_instruction(MipsBNENode('$a0', '$zero', node.name)) + + @visitor.when(LabelNode) + def visit(self, node): + self.register_instruction(MipsLabelNode(node.name)) + + + + @visitor.when(PlusNode) + def visit(self, node:PlusNode): + pos_dest = self.request_pos(node.dest) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsAddNode('$a0', '$a0', '$t1')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(MinusNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsMinusNode('$a0', '$t1', '$a0')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + + @visitor.when(StarNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsStarNode('$a0', '$t1', '$a0')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(DivNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsDivNode('$a0', '$t1', '$a0')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(ComplementNode) + def visit(self, node): + pos_dest = self.request_pos(node.dest) + pos_expression = self.request_pos(node.expression) + + if not pos_expression is None: + self.register_instruction(MipsLWNode('$t1', pos_expression)) + else: + self.register_instruction(MipsLINode('$t1', node.expression)) + + self.register_instruction(MipsLINode('$t2', -1)) + self.register_instruction(MipsStarNode('$t1','$t1' ,'$t2')) + self.register_instruction(MipsSWNode('$t1', pos_dest)) + + @visitor.when(IsVoidNode) + def visit(self, node): + pos_obj = self.request_pos(node.obj) + pos_dest = self.request_pos(node.dest) + + if not pos_obj is None: + self.register_instruction(MipsLWNode('$t1', pos_obj)) + else: + self.register_instruction(MipsLINode('$a0', 1)) + self.register_instruction(MipsJumpNode(node.label)) + + self.register_instruction(MipsLINode('$a0', 1)) + self.register_instruction(MipsLANode('$t2', '_void')) + self.register_instruction(MipsBNENode('$t1', '$t2', node.label)) + self.register_instruction(MipsLINode('$a0', 0)) + self.register_instruction(MipsLabelNode(node.label)) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(LessNode) + def visit(self, node): + pos_dest = self.request_pos(node.result) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsBLTNode('$t1', '$a0', node.labelTrue)) + self.register_instruction(MipsLINode('$a0', 0)) + self.register_instruction(MipsJumpNode(node.labelEnd)) + self.register_instruction(MipsLabelNode(node.labelTrue)) + self.register_instruction(MipsLINode('$a0', 1)) + self.register_instruction(MipsLabelNode(node.labelEnd)) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(LessEqualNode) + def visit(self, node): + pos_dest = self.request_pos(node.result) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + if not pos_left is None: + self.register_instruction(MipsLWNode('$t1', pos_left)) + else: + self.register_instruction(MipsLINode('$t1', node.left)) + + if not pos_right is None: + self.register_instruction(MipsLWNode('$a0', pos_right)) + else: + self.register_instruction(MipsLINode('$a0', node.right)) + + self.register_instruction(MipsBLENode('$t1', '$a0', node.labelTrue)) + self.register_instruction(MipsLINode('$a0', 0)) + self.register_instruction(MipsJumpNode(node.labelEnd)) + self.register_instruction(MipsLabelNode(node.labelTrue)) + self.register_instruction(MipsLINode('$a0', 1)) + self.register_instruction(MipsLabelNode(node.labelEnd)) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + @visitor.when(StringComparer) + def visit(self, node): + pos_dest = self.request_pos(node.result) + pos_left = self.request_pos(node.left) + pos_right = self.request_pos(node.right) + + self.register_instruction(MipsSWNode('$fp', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp' ,'-4')) + + self.register_instruction(MipsLWNode('$a0', pos_left)) + self.register_instruction(MipsSWNode('$a0', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + + self.register_instruction(MipsLWNode('$a0', pos_right)) + self.register_instruction(MipsSWNode('$a0', '0($sp)')) + self.register_instruction(MipsAddiuNode('$sp', '$sp', '-4')) + + self.register_instruction(MipsJumpAtAddressNode('function_comparer_string')) + self.register_instruction(MipsSWNode('$a0', pos_dest)) + + + @visitor.when(CaseOption) + def visit(self, node): + pos_expression = self.request_pos(node.expression) + + if not pos_expression is None: + self.register_instruction(MipsLANode('$a0', f'{node.typex.name}_name')) + self.register_instruction(MipsLWNode('$t1', pos_expression)) + self.register_instruction(MipsLWNode('$t1', '0($t1)')) + self.register_instruction(MipsBEQNode('$t1', '$a0', node.label)) + else: + pass + + # registers + def register_data(self, instruction): + self.data.append(instruction) + + def register_instruction(self, instruction): + self.text.append(instruction) + + + + + # utils + def request_pos(self, name): + if name in [x.name for x in self.function.localvars]: + numb = int( name.split('_')[-1]) + return f'-{(numb+1) * 4}($fp)' + elif name in [x.name for x in self.function.params]: + numb = [param.name for param in self.function.params].index(name) + return f'{(numb + 1) * 4}($fp)' + else: + return None \ No newline at end of file diff --git a/src/compiler_components/code_gen.py b/src/compiler_components/code_gen.py new file mode 100644 index 000000000..fe9795b87 --- /dev/null +++ b/src/compiler_components/code_gen.py @@ -0,0 +1,40 @@ +from .compiler_component import CompilerComponent +from .semantic_checker import SemanticChecker +from .cool_to_cil import CoolToCil +from .cil_mips_converter import CilToMipsConverter +from . import cil +from .cil_to_mips import CilToMips +from .cil import get_formatter +from . import mips + + +class CodeGenerator(CompilerComponent): + def __init__(self, semantic_checker: SemanticChecker) -> None: + super().__init__() + self.semantic_checker = semantic_checker + self.context = None + self.scope = None + self.ast = None + self.mips_text = None + + def execute(self): + self.context = self.semantic_checker.context + self.scope = self.semantic_checker.scope + self.ast = self.semantic_checker.ast + + cool2cil = CoolToCil(self.context) + f = cil.get_formatter() + c = cool2cil.visit(self.ast, self.scope) + # print(f(c)) + + cil2mips = CilToMips() + d = cil2mips.visit(c) + e = mips.get_formatter() + + self.mips_text = e(d) + + def has_errors(self): + return False + + def print_errors(self): + pass diff --git a/src/compiler_components/compiler_component.py b/src/compiler_components/compiler_component.py new file mode 100644 index 000000000..6767e1151 --- /dev/null +++ b/src/compiler_components/compiler_component.py @@ -0,0 +1,9 @@ +class CompilerComponent(): + def execute(self): + pass + + def has_errors(self): + pass + + def print_errors(self): + pass \ No newline at end of file diff --git a/src/compiler_components/cool_cil_converter.py b/src/compiler_components/cool_cil_converter.py new file mode 100644 index 000000000..8a5ec4de2 --- /dev/null +++ b/src/compiler_components/cool_cil_converter.py @@ -0,0 +1,487 @@ +from .code_generator.converter import Converter +from .code_generator.converter_utils import * +from .code_generator.cil_nodes import * +from .code_generator import visitor +from .ast import * + + +class CoolToCilConverter(Converter): + @visitor.on('node') + def visit(self, node): + pass + + @visitor.when(ProgramNode) + def visit(self, node, scope): + self.current_function = register_function(self, 'main') + instance = define_internal_local(self) + result = define_internal_local(self) + result2 = define_internal_local(self) + + register_instruction(self, CilAllocateNode('Main', instance)) + register_instruction(self, CilArgsNode([instance])) + + register_instruction(self, CilJumpNode(to_function_name('Ctr', 'Main'), result)) + register_instruction(self, CilArgsNode([result])) + + real_method = get_method(self, self.context.get_type('Main').name, 'main') + register_instruction(self, CilDynamicCallNode('Main', real_method, result2, result)) + register_instruction(self, CilReturnNode(0)) + self.current_function = None + + for declaration, child_scope in zip(node.declarations, scope.children): + self.visit(declaration, child_scope) + + return CilProgramNode(self.dottypes, self.dotdata, self.dotcode) + + @visitor.when(ClassDeclarationNode) + def visit(self, node, scope): + self.current_type = self.context.get_type(node.id) + + cil_type = register_type(self, node.id) + + for attr, type_attr in self.current_type.all_attributes(): + cil_type.attributes.append(to_attribute_name(attr.name)) + + for func, type_func in self.current_type.all_methods(): + cil_type.methods.append((func.name, to_function_name(func.name, type_func.name))) + + nodeFunctions = [x for x in node.features if isinstance(x, FuncDeclarationNode)] + for feature, child_scope in zip(nodeFunctions, scope.children[0].children): + self.visit(feature, child_scope) + + name = to_function_name("Ctr", self.current_type.name) + self.current_function = register_function(self, name) + register_param(self, VariableInfo('self', self.current_type)) + + register_instruction(self, CilLoadNode('self', f'{self.current_type.name}_name')) + register_instruction(self, CilLoadIntNode('self', f'{self.current_type.name}_size', 4)) + register_instruction(self, CilLoadNode('self', f'__virtual_table__{self.current_type.name}', 8)) + + initResult = define_internal_local(self) + register_instruction(self, CilArgsNode(['self'])) + register_instruction(self, CilJumpNode(to_function_name('Init', self.current_type.name), initResult)) + + register_instruction(self, CilReturnNode('self')) + + name = to_function_name('Init', self.current_type.name) + self.current_function = register_function(self, name) + register_param(self, VariableInfo('self', self.current_type)) + + parentResult = define_internal_local(self) + register_instruction(self, CilArgsNode(['self'])) + register_instruction(self, CilJumpNode(to_function_name('Init', self.current_type.parent.name), parentResult)) + + nodeatt = [x for x in node.features if isinstance(x, AttrDeclarationNode)] + for feature, child_scope in zip(nodeatt, scope.children[1].children): + self.visit(feature, child_scope) + + register_instruction(self, CilReturnNode('self')) + + self.current_type = None + + @visitor.when(FuncDeclarationNode) + def visit(self, node, scope): + self.current_method = self.current_type.get_method(node.id) + + name = to_function_name(node.id, self.current_type.name) + self.current_function = register_function(self, name) + + register_param(self, VariableInfo('self', self.current_type)) + for param in scope.locals: + register_param(self, param) + + value = self.visit(node.body, scope.children[0]) + + register_instruction(self, CilReturnNode(value)) + self.current_method = None + + @visitor.when(AttrDeclarationNode) + def visit(self, node, scope): + if not node.expr is None and len(scope.children) > 0: + value = self.visit(node.expr, scope.children[0]) + + if node.type == 'Object' and node.expr.type.name in ['Int', 'Bool', 'String']: + value = box(self, node.expr.type.name, value) + + else: + if node.type == 'String': + internal = define_internal_local(self) + register_instruction(self, CilLoadAddressNode(internal, "_empty")) + value = internal + elif node.type == 'Bool' or node.type == 'Int': + value = 0 + else: + internal = define_internal_local(self) + register_instruction(self, CilLoadAddressNode(internal, "_void")) + value = internal + + attrib = get_attr(self, self.current_type.name, node.id) + register_instruction(self, CilSetAttribNode('self', attrib, value)) + + @visitor.when(LetNode) + def visit(self, node, scope): + scope_open = scope.children[0] + + for init in node.list_decl: + if not init.expr is None: + value = self.visit(init.expr, scope_open) + + if init.expr.type.name in ['Int', 'Bool', 'String'] and init.type == 'Object': + value = box(self, init.expr.type.name, value) + else: + if init.type == 'String': + internal = define_internal_local(self) + register_instruction(self, CilLoadAddressNode(internal, "_empty")) + value = internal + elif init.type == 'Bool' or init.type == 'Int': + value = 0 + else: + internal = define_internal_local(self) + register_instruction(self, CilLoadAddressNode(internal, "_void")) + value = internal + + scope_open = scope_open.children[-1] + var_info = scope_open.find_variable(init.id) + vname = register_local(self, var_info) + register_instruction(self, CilAssignNode(vname, value)) + + return self.visit(node.expr, scope_open.children[0]) + + @visitor.when(CaseNode) + def visit(self, node, scope): + result = define_internal_local(self) + + if len(scope.children) == 0: + return result + + internal_expression = define_internal_local(self) + value_expression = self.visit(node.expr, scope.children[0]) + register_instruction(self, CilAssignNode(internal_expression, value_expression)) + + types_ordered = sort_types([self.context.get_type(x.type) for x in node.list_case]) + list_label = [] + labels = dict() + + for typex in types_ordered: + label_typex = register_label(self) + labels[typex.name] = label_typex + pre = get_preorder_types(self, typex) + for typex2 in pre: + if not typex2 in [x[0] for x in list_label]: + list_label.append((typex2, label_typex)) + + for typex in list_label: + register_instruction(self, CilCaseOption(value_expression, typex[1], typex[0])) + + label_end = register_label(self) + for branch, scopeBranch in zip(node.list_case, scope.children[1].children): + var_info = scopeBranch.find_variable(branch.id) + xxx = register_local(self, var_info) + register_instruction(self, CilLabelNode(labels[branch.type])) + register_instruction(self, CilAssignNode(xxx, value_expression)) + + value_branch = self.visit(branch.expr, scopeBranch) + register_instruction(self, CilAssignNode(result, value_branch)) + register_instruction(self, CilGotoNode(label_end)) + + register_instruction(self, CilLabelNode(label_end)) + return result + + @visitor.when(BlockNode) + def visit(self, node, scope): + + for expression, child in zip(node.expr_list, scope.children): + value = self.visit(expression, child) + + + return value + + @visitor.when(IfNode) + def visit(self, node, scope): + cond = self.visit(node.if_c, scope.children[0]) + + label_true = register_label(self) + label_false = register_label(self) + result = define_internal_local(self) + + register_instruction(self, CilGotoIfNode(label_true, cond)) + vfalse = self.visit(node.else_c, scope.children[2]) + register_instruction(self, CilAssignNode(result, vfalse)) + register_instruction(self, CilGotoNode(label_false)) + register_instruction(self, CilLabelNode(label_true)) + vtrue = self.visit(node.then_c, scope.children[1]) + register_instruction(self, CilAssignNode(result, vtrue)) + register_instruction(self, CilLabelNode(label_false)) + + return result + + @visitor.when(WhileNode) + def visit(self, node, scope): + label_while_start = register_label(self) + label_while_continue = register_label(self) + label_while_break = register_label(self) + + register_instruction(self, CilLabelNode(label_while_start)) + + cond = self.visit(node.condition, scope.children[0]) + + register_instruction(self, CilGotoIfNode(label_while_continue, cond)) + register_instruction(self, CilGotoNode(label_while_break)) + register_instruction(self, CilLabelNode(label_while_continue)) + self.visit(node.body, scope.children[1]) + register_instruction(self, CilGotoNode(label_while_start)) + register_instruction(self, CilLabelNode(label_while_break)) + + result = define_internal_local(self) + register_instruction(self, CilLoadAddressNode(result, "_void")) + return result + + @visitor.when(AssignNode) + def visit(self, node, scope): + vinfo = scope.find_variable(node.id) + value = self.visit(node.expr, scope.children[0]) + + if vinfo is None: + attrib = get_attr(self, self.current_type.name, node.id) + register_instruction(self, CilSetAttribNode('self', attrib, value)) + else: + register_instruction(self, CilAssignNode(vinfo.cilName, value)) + + return value + + @visitor.when(DispatchNode) + def visit(self, node, scope): + result = define_internal_local(self) + if len(scope.children) == 0: + return result + + obj = self.visit(node.expr, scope.children[0]) + + if node.expr.type.name in ['Int', 'Bool', 'String']: + if node.id in ['abort', 'type_name', 'copy']: + obj = box(self, node.expr.type.name, obj) + + valuesArgs = [] + for arg, child in zip(node.params, scope.children[1:]): + value = self.visit(arg, child) + + if arg.type.name in ['Int', 'Bool', 'String']: + method = self.context.get_type(node.typex).get_method(node.id) + param_type = method.param_types[node.params.index(arg)] + + if param_type.name == 'Object': + valuesArgs.append(self.box(arg.type.name, value)) + continue + + valuesArgs.append(value) + + if node.typexa is None: + node.typex = node.expr.type.name + + register_instruction(self, CilArgsNode(list(reversed(valuesArgs)) + [obj])) + + if node.expr.type.name == 'String' and node.id in ['length', 'concat', 'substr']: + register_instruction(self, CilJumpNode(to_function_name(node.id, 'String'), result)) + else: + real_method = get_method(self, node.typex, node.id) + register_instruction(self, CilDynamicCallNode(node.typexa, real_method, result, obj)) + return result + + @visitor.when(CallNode) + def visit(self, node, scope): + result = define_internal_local(self) + + values_args = [] + for arg, child in zip(node.args, scope.children): + value = self.visit(arg, child) + + if arg.type.name in ['Int', 'Bool', 'String']: + method = self.current_type.get_method(node.id) + param_type = method.param_types[node.args.index(arg)] + + if param_type.name == 'Object': + values_args.append(self.box(arg.type.name, value)) + continue + + values_args.append(value) + + register_instruction(self, CilArgsNode(list(reversed(values_args)) + ['self'])) + + realMethod = get_method(self, self.current_type.name, node.id) + register_instruction(self, CilStaticCallNode(realMethod, result)) + return result + + @visitor.when(ConstantNumNode) + def visit(self, node, scope): + return int(node.lex) + + @visitor.when(ConstantBooleanNode) + def visit(self, node, scope): + if node.lex: + return 1 + return 0 + + @visitor.when(ConstantStringNode) + def visit(self, node, scope): + msg = register_data(self, node.lex).name + internal = define_internal_local(self) + register_instruction(self, CilLoadAddressNode(internal, msg)) + return internal + + @visitor.when(VariableNode) + def visit(self, node: VariableNode, scope): + if node.lex == 'self': + return 'self' + + vinfo = scope.find_variable(node.lex) + + if vinfo is None: + result = define_internal_local(self) + attrib = get_attr(self, self.current_type.name, node.lex) + + register_instruction(self, CilGetAttribNode('self', attrib, result)) + return result + + return vinfo.name + + @visitor.when(InstantiateNode) + def visit(self, node, scope): + if not node.type.name == "Int": + instance = define_internal_local(self) + result = define_internal_local(self) + register_instruction(self, CilAllocateNode(node.type.name, instance)) + register_instruction(self, CilArgsNode([instance])) + register_instruction(self, CilJumpNode(to_function_name('Ctr', node.type.name), result)) + return instance + else: + return 0 + + @visitor.when(PlusNode) + def visit(self, node, scope): + result = define_internal_local(self) + if len(scope.children) < 2: + return result + + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + register_instruction(self, CilPlusNode(result, left, right)) + return result + + @visitor.when(MinusNode) + def visit(self, node, scope): + result = define_internal_local(self) + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + + labelTrue = register_label(self) + labelEnd = register_label(self) + + register_instruction(self, CilLessNode(result, left, right, labelTrue, labelEnd)) + return result + + @visitor.when(MinorNode) + def visit(self, node, scope): + result = define_internal_local(self) + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + register_instruction(self, CilMinusNode(result, left, right)) + return result + + @visitor.when(StarNode) + def visit(self, node, scope): + result = define_internal_local(self) + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + register_instruction(self, CilStarNode(result, left, right)) + return result + + @visitor.when(DivNode) + def visit(self, node, scope): + result = define_internal_local(self) + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + register_instruction(self, CilDivNode(result, left, right)) + return result + + @visitor.when(EqualsNode) + def visit(self, node, scope): + result = define_internal_local(self) + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + + if node.left.type.name == 'String': + register_instruction(self, CilStringComparer(result, left, right)) + else: + label_equals = register_label(self) + labels_end = register_label(self) + + result_comparer = define_internal_local(self) + register_instruction(self, CilMinusNode(result_comparer, left, right)) + + register_instruction(self, CilGotoIfNode(label_equals, result_comparer)) + register_instruction(self, CilAssignNode(result, 1)) + register_instruction(self, CilGotoNode(labels_end)) + register_instruction(self, CilLabelNode(label_equals)) + register_instruction(self, CilAssignNode(result, 0)) + register_instruction(self, CilLabelNode(labels_end)) + + return result + + @visitor.when(MinusNode) + def visit(self, node, scope): + result = define_internal_local(self) + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + + label_true = register_label(self) + label_end = register_label(self) + + register_instruction(self, CilLessNode(result, left, right, label_true, label_end)) + return result + + @visitor.when(MinorEqualsNode) + def visit(self, node, scope): + result = define_internal_local(self) + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + + label_true = register_label(self) + label_end = register_label(self) + + register_instruction(self, CilLessEqualNode(result, left, right, label_true, label_end)) + return result + + @visitor.when(NotNode) + def visit(self, node, scope): + result = define_internal_local(self) + value = self.visit(node.expr, scope.children[0]) + + label_true = register_label(self) + label_end = register_label(self) + + register_instruction(self, CilGotoIfNode(label_true, value)) + register_instruction(self, CilAssignNode(result, 1)) + register_instruction(self, CilGotoNode(label_end)) + register_instruction(self, CilLabelNode(label_true)) + register_instruction(self, CilAssignNode(result, 0)) + register_instruction(self, CilLabelNode(label_end)) + + return result + + @visitor.when(NhanharaNode) + def visit(self, node, scope): + result = define_internal_local(self) + expression = self.visit(node.expr, scope.children[0]) + + register_instruction(self, CilComplementNode(expression, result)) + return result + + @visitor.when(IsVoidNode) + def visit(self, node, scope): + result = define_internal_local(self) + expression = self.visit(node.expr, scope.children[0]) + + label_end = register_label(self) + + register_instruction(self, CilIsVoidNode(expression, result, label_end)) + return result diff --git a/src/compiler_components/cool_parser.py b/src/compiler_components/cool_parser.py new file mode 100644 index 000000000..f00a5c769 --- /dev/null +++ b/src/compiler_components/cool_parser.py @@ -0,0 +1,359 @@ +from .compiler_component import CompilerComponent +from .lexer import Tokenizer, Lexer +from .ast import * +import ply.yacc as yacc +import ply.lex as lex + +t = Tokenizer() +tokens = t.tokens +lexer = lex.lex(t) +errors = [] + +##### Grammar #################### +def p_program(p): + 'program : class_list' + p[0] = ProgramNode(p[1]) + +def p_class_list(p): + '''class_list : def_class SEMICOLON + | def_class SEMICOLON class_list + ''' + if len(p) == 3: + p[0] = [p[1]] + else: + p[0] = [p[1]] + p[3] + +def p_def_class(p): + '''def_class : CLASS type_id LBRACE feature_list RBRACE + | CLASS type_id INHERITS type_inherit LBRACE feature_list RBRACE + ''' + + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + + if len(p) == 6: + p[0] = ClassDeclarationNode(p[2]['value'], p[4], line = line, column = column, type_line = p[2]['line'], type_column = p[2]['column']) + else: + p[0] = ClassDeclarationNode(p[2]['value'], p[6], p[4]['value'], line = line, column = column, line_father = p[4]['line'], column_father = p[4]['column'], type_line = p[2]['line'], type_column = p[2]['column']) + +def p_type_inherit(p): + 'type_inherit : TYPE_ID' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = {'value':p[1], 'line':line, 'column':column} + +def p_type_id(p): + 'type_id : TYPE_ID' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = {'value':p[1], 'line':line, 'column':column} + +def p_empty(p): + 'empty :' + pass + +def p_feature_list(p): + '''feature_list : def_attr SEMICOLON feature_list + | def_func SEMICOLON feature_list + | empty + ''' + if len(p) == 2: + p[0] = [] + else: + p[0] = [p[1]] + p[3] + +def p_def_attr(p): + '''def_attr : id DOUBLE_DOT type_id + | id DOUBLE_DOT type_id LEFT_ARROW expr + ''' + if len(p) == 4: + p[0] = AttrDeclarationNode(p[1]['value'], p[3]['value'], line = p[1]['line'], column = p[1]['column'], type_line = p[3]['line'], type_column = p[3]['column']) + else: + p[0] = AttrDeclarationNode(p[1]['value'], p[3]['value'], p[5], line = p[1]['line'], column = p[1]['column'], type_line = p[3]['line'], type_column = p[3]['column']) + +def p_def_func(p): + '''def_func : ID LPAREN param_list RPAREN DOUBLE_DOT TYPE_ID LBRACE expr RBRACE + ''' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = FuncDeclarationNode(p[1], p[3], p[6], p[8], line = line, column = column) + +def p_param_list(p): + '''param_list : param param_list2 + | empty + ''' + if len(p) == 3: + p[0] = [p[1]] + p[2] + else: + p[0] = [] + +def p_param_list2(p): + '''param_list2 : COMMA param param_list2 + | empty + ''' + if len(p) == 4: + p[0] = [p[2]] + p[3] + else: + p[0] = [] + +def p_param(p): + '''param : ID DOUBLE_DOT TYPE_ID + ''' + p[0] = [p[1], p[3]] + +def p_expr_list(p): + '''expr_list : expr SEMICOLON + | expr SEMICOLON expr_list + ''' + if len(p) == 3: + p[0] = [p[1]] + else: + p[0] = [p[1]] + p[3] + +def p_expr(p): + 'expr : bool' + p[0] = p[1] + +def p_bool(p): + '''bool : NOT bool + | arith MINOR arith + | arith MINOR_EQUALS arith + | arith EQUALS arith + | arith + ''' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + if len(p) == 3: + p[0] = NotNode(p[2], line = line, column = column) + + elif len(p) == 2: + p[0] = p[1] + else: + if p[2] == '<': + p[0] = MinorNode(p[1], p[3], line = line, column = column) + elif p[2] == '<=': + p[0] = MinorEqualsNode(p[1], p[3], line = line, column = column) + else: + p[0] = EqualsNode(p[1], p[3], line = line, column = column) + +def p_expr2(p): + 'expr : ID LEFT_ARROW expr' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = AssignNode(p[1], p[3], line = line, column = column) + +def p_arith(p): + '''arith : term + | NOT bool + | arith PLUS term + | arith MINUS term + ''' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + if len(p) == 2: + p[0] = p[1] + elif len(p) == 3: + p[0] = NotNode(p[2], line = line, column = column) + else: + if p[2] == '+': + p[0] = PlusNode(p[1], p[3], line = line, column = column) + else: + p[0] = MinusNode(p[1], p[3], line = line, column = column) + +def p_term(p): + '''term : factor + | term TIMES factor + | term DIVIDE factor + ''' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + if len(p) == 2: + p[0] = p[1] + else: + if p[2] == '*': + p[0] = StarNode(p[1], p[3], line = line, column = column) + else: + p[0] = DivNode(p[1], p[3], line = line, column = column) + +def p_factor(p): + '''factor : atom + | LPAREN expr RPAREN + ''' + if len(p) == 2: + p[0] = p[1] + else: + p[0] = p[2] + +#4 (por ahora) metodos para el no-terminal 'atom' +def p_atom1(p): + 'atom : ID' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = VariableNode(p[1], line = line, column = column) + +def p_atom2(p): + 'atom : NUMBER' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = ConstantNumNode(p[1], line = line, column = column) + +def p_atom3(p): + 'atom : func_call' + p[0] = p[1] + +def p_atom4(p): + '''atom : NEW TYPE_ID + ''' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = InstantiateNode(p[2], line = line, column = column) + +def p_atomString(p): + 'atom : STRING' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = ConstantStringNode(p[1][1:len(p[1]) -1 ], line = line, column = column) + +def p_atomBool(p): + '''atom : TRUE + | FALSE + ''' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + if p[1].lower() == "true": + p[0] = ConstantBooleanNode(True, line = line, column = column) + else: + p[0] = ConstantBooleanNode(False, line = line, column = column) + +#def p_atomSelf(p): + #'atom : SELF' + #p[0] = SelfNode(None) + +def p_atomIF(p): + 'atom : IF expr THEN expr ELSE expr FI' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = IfNode(p[2], p[4], p[6], line = line, column = column) + +def p_atomCicle(p): + 'atom : WHILE expr LOOP expr POOL' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = WhileNode(p[2], p[4], line = line, column = column) + +def p_atomBlock(p): + 'atom : LBRACE expr_list RBRACE' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = BlockNode(p[2], line = line, column = column) + +def p_atomLet(p): + 'atom : LET atr_decl_list IN expr' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = LetNode(p[2], p[4], line = line, column = column) + +def p_atr_decl_list(p): + '''atr_decl_list : def_attr + | def_attr COMMA atr_decl_list + + ''' + if len(p) == 2: + p[0] = [p[1]] + else: + p[0] = [p[1]] + p[3] + +def p_atomCase(p): + 'atom : CASE expr OF case_list ESAC' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = CaseNode(p[2], p[4], line = line, column = column) + +def p_caseList(p): + '''case_list : id DOUBLE_DOT TYPE_ID RIGHT_ARROW expr SEMICOLON + | id DOUBLE_DOT TYPE_ID RIGHT_ARROW expr SEMICOLON case_list + ''' + + if len(p) == 7: + p[0] = [AttrDeclarationNode(p[1]['value'], p[3], p[5], line = p[1]['line'], column = p[1]['column'])] + else: + p[0] = [AttrDeclarationNode(p[1]['value'], p[3], p[5], line = p[1]['line'], column = p[1]['column'])] + p[7] + +def p_id(p): + 'id : ID' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] ={'value':p[1], 'line':line, 'column':column} + +def p_atomIsVoid(p): + 'atom : ISVOID factor' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = IsVoidNode(p[2], line = line, column = column) + +''' +def p_atomNot(p): + 'atom : NOT factor' + p[0] = NotNode(p[2]) +''' + +def p_atomNhanhara(p): + 'atom : NHANHARA factor' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = NhanharaNode(p[2], line = line, column = column) + +def p_func_call(p): + '''func_call : factor DOT ID LPAREN arg_list RPAREN + ''' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = DispatchNode(p[1], p[3], p[5], line = line, column = column) + +def p_func_call2(p): + 'func_call : ID LPAREN arg_list RPAREN' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = CallNode(None, p[1], p[3], line = line, column = column) + +def p_func_call3(p): + 'func_call : factor ARROBA TYPE_ID DOT ID LPAREN arg_list RPAREN' + line, column = calculate_position(p.lexer.lexdata, p.lexer.lexpos) + p[0] = DispatchNode(p[1], p[5], params = p[7], typex = p[3], line = line, column = column) + + + +def p_arg_list(p): + '''arg_list : expr arg_list2 + | empty + ''' + if len(p) == 3: + p[0] = [p[1]] + p[2] + else: + p[0] = [] + +def p_arg_list2(p): + '''arg_list2 : COMMA expr arg_list2 + | empty + ''' + if len(p) == 4: + p[0] = [p[2]] + p[3] + else: + p[0] = [] + + +def p_error(p): + if p: + line, column = calculate_position(p.lexer.lexdata, p.lexpos) + errors.append(f'({line},{column}) - SyntacticError: ERROR at or near "{p.value}"') + + else: + errors.append(f'(0, 0) - SyntacticError: ERROR at or near EOF)') + +############## End Grammar ############################ + +def calculate_position(data, pos): + data_array = data.split('\n') + count = 0 + number_line = 0 + for line in data_array: + number_line += 1 + if count + len(line) >= pos: + return (number_line, pos - count + 1) + count += len(line) + 1 + + +class Parser(CompilerComponent): + + def __init__(self, lexer: Lexer) -> None: + super().__init__() + self.lexer = lexer + + def execute(self): + parser = yacc.yacc() + errors = [] + self.ast = parser.parse(self.lexer.cool_program) + + def has_errors(self): + return len(errors) > 0 + + def print_errors(self): + for e in errors: + print(e) \ No newline at end of file diff --git a/src/compiler_components/cool_to_cil.py b/src/compiler_components/cool_to_cil.py new file mode 100644 index 000000000..b12202fbe --- /dev/null +++ b/src/compiler_components/cool_to_cil.py @@ -0,0 +1,500 @@ +from . import cil +import sys +from .base_to_cil import BaseToCil +from .ast import * +sys.path.append('./semantic') +from .semantic.structures import * +from . import visitor + +class CoolToCil(BaseToCil): + @visitor.on('node') + def visit(self, node): + pass + + @visitor.when(ProgramNode) + def visit(self, node, scope): + self.current_function = self.register_function('main') + instance = self.define_internal_local() + result = self.define_internal_local() + result2 = self.define_internal_local() + + self.register_instruction(cil.AllocateNode('Main', instance)) + self.register_instruction(cil.ArgsNode([instance])) + + self.register_instruction(cil.JumpNode(self.to_function_name('Ctr', 'Main'), result)) + self.register_instruction(cil.ArgsNode([result])) + + realMethod = self.get_method(self.context.get_type('Main').name, 'main') + self.register_instruction(cil.DynamicCallNode('Main', realMethod , result2, result)) + self.register_instruction(cil.ReturnNode(0)) + self.current_function = None + + for declaration, child_scope in zip(node.declarations, scope.children): + self.visit(declaration, child_scope) + + return cil.ProgramNode(self.dottypes, self.dotdata, self.dotcode) + + @visitor.when(ClassDeclarationNode) + def visit(self, node, scope): + self.current_type = self.context.get_type(node.id) + + cil_type = self.register_type(node.id) + + for attr, type_attr in self.current_type.all_attributes(): + cil_type.attributes.append(self.to_attribute_name(attr.name, type_attr.name)) + + for func, type_func in self.current_type.all_methods(): + cil_type.methods.append((func.name, self.to_function_name(func.name, type_func.name))) + + nodeFunctions = [x for x in node.features if isinstance(x, FuncDeclarationNode)] + for feature, child_scope in zip(nodeFunctions, scope.children[0].children): + self.visit(feature, child_scope) + + #ctr + name = self.to_function_name("Ctr", self.current_type.name) + self.current_function = self.register_function(name) + self.register_param(VariableInfo('self', self.current_type)) + + self.register_instruction(cil.LoadNode('self', f'{self.current_type.name}_name')) + self.register_instruction(cil.LoadIntNode('self', f'{self.current_type.name}_size', 4)) + self.register_instruction(cil.LoadNode('self', f'__virtual_table__{self.current_type.name}', 8)) + + initResult = self.define_internal_local() + self.register_instruction(cil.ArgsNode(['self'])) + self.register_instruction(cil.JumpNode(self.to_function_name('Init', self.current_type.name), initResult)) + self.register_instruction(cil.ReturnNode('self')) + + + #init + name = self.to_function_name('Init', self.current_type.name) + self.current_function = self.register_function(name) + self.register_param(VariableInfo('self', self.current_type)) + + parentResult = self.define_internal_local() + self.register_instruction(cil.ArgsNode(['self'])) + self.register_instruction(cil.JumpNode(self.to_function_name('Init', self.current_type.parent.name), parentResult)) + + nodeatt = [x for x in node.features if isinstance(x, AttrDeclarationNode)] + for feature, child_scope in zip(nodeatt, scope.children[1].children): + self.visit(feature, child_scope) + + self.register_instruction(cil.ReturnNode('self')) + + self.current_type = None + + @visitor.when(FuncDeclarationNode) + def visit(self, node, scope): + self.current_method = self.current_type.get_method(node.id) + + name = self.to_function_name(node.id, self.current_type.name) + self.current_function = self.register_function(name) + + self.register_param(VariableInfo('self', self.current_type)) + for param in scope.locals: + self.register_param(param) + + value = self.visit(node.body, scope.children[0]) + + self.register_instruction(cil.ReturnNode(value)) + self.current_method = None + + + @visitor.when(AttrDeclarationNode) + def visit(self, node, scope): + if not node.expr is None: + value = self.visit(node.expr, scope.children[0]) + + if node.type == 'Object' and node.expr.type.name in ['Int', 'Bool', 'String']: + value = self.box(node.expr.type.name, value) + + else: + if node.type == 'String': + internal = self.define_internal_local() + self.register_instruction(cil.LoadAddressNode(internal, "_empty")) + value = internal + elif node.type == 'Bool' or node.type == 'Int': + value = 0 + else: + internal = self.define_internal_local() + self.register_instruction(cil.LoadAddressNode(internal, "_void")) + value = internal + + attrib = self.get_attr(self.current_type.name, node.id) + self.register_instruction(cil.SetAttribNode('self', attrib, value)) + + @visitor.when(LetNode) + def visit(self, node, scope): + scopeOpen = scope.children[0] + + value = None + for init in node.list_decl: + if not init.expr is None: + value = self.visit(init.expr, scopeOpen) + + if init.expr.type.name in ['Int', 'Bool', 'String'] and init.type == 'Object': + value = self.box(init.expr.type.name, value) + + else: + if init.type == 'String': + internal = self.define_internal_local() + self.register_instruction(cil.LoadAddressNode(internal, "_empty")) + value = internal + elif init.type == 'Bool' or init.type == 'Int': + value = 0 + else: + internal = self.define_internal_local() + self.register_instruction(cil.LoadAddressNode(internal, "_void")) + value = internal + + scopeOpen = scopeOpen.children[-1] + vinfo = scopeOpen.find_variable(init.id) + vname = self.register_local(vinfo) + self.register_instruction(cil.AssignNode(vname, value)) + + return self.visit(node.expr, scopeOpen.children[0]) + + @visitor.when(CaseNode) + def visit(self, node, scope): + result = self.define_internal_local() + + internal_expression = self.define_internal_local() + value_expression = self.visit(node.expr, scope.children[0]) + self.register_instruction(cil.AssignNode(internal_expression, value_expression)) + + types_ordered = self.sort_types([self.context.get_type(x.type) for x in node.list_case]) + list_label = [] + labels = dict() + + for typex in types_ordered: + labelTypex = self.register_label() + labels[typex.name] = labelTypex + pre = self.get_preordenTypes(typex) + for typex2 in pre: + if not typex2 in [x[0] for x in list_label]: + list_label.append((typex2, labelTypex)) + + for typex in list_label: + self.register_instruction(cil.CaseOption(value_expression, typex[1], typex[0])) + #error + + labelEnd = self.register_label() + for branch, scopeBranch in zip(node.list_case, scope.children[1].children): + vinfo = scopeBranch.find_variable(branch.id) + xxx = self.register_local(vinfo) + self.register_instruction(cil.LabelNode(labels[branch.type])) + self.register_instruction(cil.AssignNode(xxx, value_expression)) + + valueBranch = self.visit(branch.expr, scopeBranch) + self.register_instruction(cil.AssignNode(result, valueBranch)) + self.register_instruction(cil.GotoNode(labelEnd)) + + self.register_instruction(cil.LabelNode(labelEnd)) + return result + + + @visitor.when(BlockNode) + def visit(self, node, scope): + for expression, child in zip(node.expr_list, scope.children): + value = self.visit(expression, child) + + return value + + @visitor.when(IfNode) + def visit(self, node, scope): + cond = self.visit(node.if_c, scope.children[0]) + + labelTrue = self.register_label() + labelFalse = self.register_label() + result = self.define_internal_local() + + self.register_instruction(cil.GotoIfNode(labelTrue, cond)) + vfalse = self.visit(node.else_c, scope.children[2]) + self.register_instruction(cil.AssignNode(result, vfalse)) + self.register_instruction(cil.GotoNode(labelFalse)) + self.register_instruction(cil.LabelNode(labelTrue)) + vtrue = self.visit(node.then_c, scope.children[1]) + self.register_instruction(cil.AssignNode(result, vtrue)) + self.register_instruction(cil.LabelNode(labelFalse)) + + return result + + @visitor.when(WhileNode) + def visit(self, node, scope): + labelWhileStart = self.register_label() + labelWhileContinue = self.register_label() + labelWhileBreak = self.register_label() + + self.register_instruction(cil.LabelNode(labelWhileStart)) + + cond = self.visit(node.condition, scope.children[0]) + + self.register_instruction(cil.GotoIfNode(labelWhileContinue, cond)) + self.register_instruction(cil.GotoNode(labelWhileBreak)) + self.register_instruction(cil.LabelNode(labelWhileContinue)) + self.visit(node.body, scope.children[1]) + self.register_instruction(cil.GotoNode(labelWhileStart)) + self.register_instruction(cil.LabelNode(labelWhileBreak)) + + result = self.define_internal_local() + self.register_instruction(cil.LoadAddressNode(result, "_void")) + return result + + @visitor.when(AssignNode) + def visit(self, node, scope): + vinfo = scope.find_variable(node.id) + value = self.visit(node.expr, scope.children[0]) + + if vinfo is None: + attrib = self.get_attr(self.current_type.name, node.id) + self.register_instruction(cil.SetAttribNode('self', attrib, value)) + else: + self.register_instruction(cil.AssignNode(vinfo.cilName, value)) + + return value + + @visitor.when(DispatchNode) + def visit(self, node, scope): + result = self.define_internal_local() + obj = self.visit(node.expr, scope.children[0]) + + if node.expr.type.name in ['Int', 'Bool', 'String']: + if node.id in ['abort', 'type_name', 'copy']: + obj = self.box(node.expr.type.name, obj) + + valuesArgs = [] + for arg, child in zip(node.params, scope.children[1:]): + value = self.visit(arg, child) + + if arg.type.name in ['Int', 'Bool', 'String']: + method = self.context.get_type(node.typex).get_method(node.id) + param_type = method.param_types[node.params.index(arg)] + + if param_type.name == 'Object': + valuesArgs.append(self.box(arg.type.name, value)) + continue + + valuesArgs.append(value) + + if node.typexa is None: + node.typex = node.expr.type.name + + self.register_instruction(cil.ArgsNode( list(reversed(valuesArgs)) + [obj])) + + if node.expr.type.name == 'String' and node.id in ['length', 'concat', 'substr']: + self.register_instruction(cil.JumpNode(self.to_function_name(node.id, 'String'), result)) + else: + realMethod = self.get_method(node.typex, node.id) + self.register_instruction(cil.DynamicCallNode(node.typexa, realMethod, result, obj)) + return result + + @visitor.when(CallNode) + def visit(self, node, scope): + result = self.define_internal_local() + + valuesArgs = [] + for arg, child in zip(node.args, scope.children): + value = self.visit(arg, child) + + if arg.type.name in ['Int', 'Bool', 'String']: + method = self.current_type.get_method(node.id) + param_type = method.param_types[node.args.index(arg)] + + if param_type.name == 'Object': + valuesArgs.append(self.box(arg.type.name, value)) + continue + + valuesArgs.append(value) + + self.register_instruction(cil.ArgsNode( list(reversed(valuesArgs)) + ['self'])) + + realMethod = self.get_method(self.current_type.name, node.id) + self.register_instruction(cil.StaticCallNode(realMethod, result)) + return result + + @visitor.when(ConstantNumNode) + def visit(self, node, scope): + return int(node.lex) + + + @visitor.when(ConstantBooleanNode) + def visit(self, node, scope): + if node.lex: + return 1 + return 0 + + + @visitor.when(ConstantStringNode) + def visit(self, node, scope): + msg = self.register_data(node.lex).name + internal = self.define_internal_local() + self.register_instruction(cil.LoadAddressNode(internal, msg)) + return internal + + + @visitor.when(VariableNode) + def visit(self, node, scope): + if node.lex == 'self': + return 'self' + + vinfo = scope.find_variable(node.lex) + + if vinfo is None: + result = self.define_internal_local() + attrib = self.get_attr(self.current_type.name, node.lex) + + self.register_instruction(cil.GetAttribNode('self', attrib, result)) + return result + + return vinfo.cilName + + + @visitor.when(InstantiateNode) + def visit(self, node, scope): + if not node.type.name == "Int": + instance = self.define_internal_local() + result = self.define_internal_local() + self.register_instruction(cil.AllocateNode(node.type.name, instance)) + self.register_instruction(cil.ArgsNode([instance])) + self.register_instruction(cil.JumpNode(self.to_function_name('Ctr', node.type.name), result)) + return instance + else: + return 0 + + + + @visitor.when(PlusNode) + def visit(self, node, scope): + result = self.define_internal_local() + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + self.register_instruction(cil.PlusNode(result, left, right)) + return result + + + @visitor.when(MinusNode) + def visit(self, node, scope): + result = self.define_internal_local() + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + self.register_instruction(cil.MinusNode(result, left, right)) + return result + + + @visitor.when(StarNode) + def visit(self, node, scope): + result = self.define_internal_local() + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + self.register_instruction(cil.StarNode(result, left, right)) + return result + + @visitor.when(DivNode) + def visit(self, node, scope): + result = self.define_internal_local() + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + self.register_instruction(cil.DivNode(result, left, right)) + return result + + @visitor.when(EqualsNode) + def visit(self, node, scope): + result = self.define_internal_local() + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + + if node.left.type.name == 'String': + self.register_instruction(cil.StringComparer(result, left, right)) + else: + labelEquals = self.register_label() + labelsEnd = self.register_label() + + resultComparer = self.define_internal_local() + self.register_instruction(cil.MinusNode(resultComparer, left, right)) + + self.register_instruction(cil.GotoIfNode(labelEquals, resultComparer)) + self.register_instruction(cil.AssignNode(result, 1)) + self.register_instruction(cil.GotoNode(labelsEnd)) + self.register_instruction(cil.LabelNode(labelEquals)) + self.register_instruction(cil.AssignNode(result, 0)) + self.register_instruction(cil.LabelNode(labelsEnd)) + + return result + + @visitor.when(MinusNode) + def visit(self, node, scope): + result = self.define_internal_local() + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + self.register_instruction(cil.MinusNode(result, left, right)) + return result + + @visitor.when(MinorNode) + def visit(self, node, scope): + result = self.define_internal_local() + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + + labelTrue = self.register_label() + labelEnd = self.register_label() + + self.register_instruction(cil.LessNode(result, left, right, labelTrue, labelEnd)) + return result + + @visitor.when(MinorEqualsNode) + def visit(self, node, scope): + result = self.define_internal_local() + left = self.visit(node.left, scope.children[0]) + right = self.visit(node.right, scope.children[1]) + + labelTrue = self.register_label() + labelEnd = self.register_label() + + self.register_instruction(cil.LessEqualNode(result, left, right, labelTrue,labelEnd)) + return result + + @visitor.when(NotNode) + def visit(self, node, scope): + result = self.define_internal_local() + value = self.visit(node.expr, scope.children[0]) + + labelTrue = self.register_label() + labelEnd = self.register_label() + + self.register_instruction(cil.GotoIfNode(labelTrue, value)) + self.register_instruction(cil.AssignNode(result, 1)) + self.register_instruction(cil.GotoNode(labelEnd)) + self.register_instruction(cil.LabelNode(labelTrue)) + self.register_instruction(cil.AssignNode(result, 0)) + self.register_instruction(cil.LabelNode(labelEnd)) + + return result + + @visitor.when(NhanharaNode) + def visit(self, node, scope): + result = self.define_internal_local() + expression = self.visit(node.expr, scope.children[0]) + + self.register_instruction(cil.ComplementNode(expression, result)) + return result + + @visitor.when(IsVoidNode) + def visit(self, node, scope): + result = self.define_internal_local() + expression = self.visit(node.expr, scope.children[0]) + + labelEnd = self.register_label() + + self.register_instruction(cil.IsVoidNode(expression, result, labelEnd)) + return result + + + # utils + def request_pos(self, name): + if name in [x.name for x in self.current_function.localvars]: + numb = int( name.split('_')[-1]) + return f'-{(numb+1) * 4}($fp)' + elif name in [x.name for x in self.current_function.params]: + numb = [param.name for param in self.function.params].index(name) + return f'{(numb + 1) * 4}($fp)' + else: + return None diff --git a/src/compiler_components/lexer.py b/src/compiler_components/lexer.py new file mode 100644 index 000000000..3e9e6643b --- /dev/null +++ b/src/compiler_components/lexer.py @@ -0,0 +1,276 @@ +from .compiler_component import CompilerComponent +import ply.lex as lex + +# funcion que retorna el texto de la linea donde hubo un error lexico +def printLine(text, lineno): #text = texto a tokenizar, lineno: linea donde hubo error + count = 0 + start_index = 0 + last_index = 0 + for i in range(len(text)): + if text[i] == '\n': + count += 1 + if count == lineno: + last_index = i + break + + if count == lineno-1: + start_index = i + + return text[start_index +1: last_index] + +class Tokenizer: + + def __init__(self): + self.errors = [] + + reserved = { + 'class':'CLASS', + 'else':'ELSE', + 'false':'FALSE', + 'fi':'FI', + 'if':"IF", + 'in':'IN', + 'inherits': 'INHERITS', + 'isvoid':'ISVOID', + 'let':'LET', + 'loop':'LOOP', + 'pool':'POOL', + 'then':'THEN', + 'while':'WHILE', + 'case':'CASE', + 'esac':'ESAC', + 'new':'NEW', + 'of':'OF', + 'not':'NOT', + 'true':'TRUE' + + } + + tokens = ['STRING', 'LPAREN', 'RPAREN', 'LBRACE' , 'RBRACE', 'PLUS', 'MINUS', + 'TIMES', 'DIVIDE', 'SEMICOLON', 'COMMA', 'ID', 'MINOR', 'MINOR_EQUALS', "EQUALS", + 'LEFT_ARROW', 'RIGHT_ARROW', 'DOT', 'DOUBLE_DOT', "ARROBA", 'NUMBER', 'NHANHARA', 'TYPE_ID'] + list(reserved.values()) + + t_LPAREN = r'\(' + t_RPAREN = r'\)' + t_LBRACE = r'\{' + t_RBRACE = r'\}' + t_PLUS = r'\+' + t_MINUS = r'-' + t_TIMES = r'\*' + t_DIVIDE = r'/' + t_SEMICOLON = r';' + t_COMMA = r',' + t_MINOR = r'<' + t_MINOR_EQUALS = r'<=' + t_EQUALS = r'=' + t_LEFT_ARROW = r'<-' + t_RIGHT_ARROW = r'=>' + t_DOT = r'\.' + t_DOUBLE_DOT = r':' + t_ARROBA = r'@' + t_NHANHARA = r'~' + + #def t_SELF(self, t): + #r'self' + #return t + + def t_NUMBER(self, t): + r'\d+' + t.value = int(t.value) + return t + + def t_STRING(self, t): + r'"' + rest_data = t.lexer.lexdata[t.lexer.lexpos:] + s = '' + ok = False + index = 0 + while index < len(rest_data): + if rest_data[index] == '"': + ok = True + t.lexer.skip(1) + s += rest_data[index] + break + + if rest_data[index] == '\n' or rest_data[index] == "\0": + s = t.lexer.lexdata.split('\n') + count = 0 + for i in range(t.lexer.lineno - 1): + count += len(s[i]) + + posAtLine = t.lexer.lexpos - count - t.lexer.lineno + 2 + if rest_data[index] == '\n': + self.errors.append("(" + str(t.lexer.lineno) + ", " + str(posAtLine) + ") - LexicographicError: Unterminated string constant") + if rest_data[index] == '\0': + self.errors.append("(" + str(t.lexer.lineno) + ", " + str(posAtLine) + ") - LexicographicError: String contains null character") + t.lexer.lineno+=1 + return + + + if rest_data[index] == '\\': + t.lexer.skip(1) + index += 1 + if index == len(rest_data) - 1: + s = t.lexer.lexdata.split('\n') + count = 0 + for i in range(t.lexer.lineno - 1): + count += len(s[i]) + + posAtLine = t.lexer.lexpos - count - t.lexer.lineno + 2 + self.errors.append("(" + str(t.lexer.lineno) + ", " + str(posAtLine) + ") - LexicographicError: EOF in string constant") + return + if rest_data[index] == 'b': + s = s[0:len(s) - 1] + + elif rest_data[index] == 't': + s+='\t' + elif rest_data[index] == 'f': + s+='\f' + elif rest_data[index] == '\n' or rest_data[index] == 'n': + s+='\n' + if rest_data[index] == '\n': + t.lexer.lineno += 1 + else: + s+= rest_data[index] + else: + s+= rest_data[index] + + t.lexer.skip(1) + index+=1 + + if ok: + t.value += s + return t + else: + s = t.lexer.lexdata.split('\n') + count = 0 + for i in range(t.lexer.lineno - 1): + count += len(s[i]) + + posAtLine = t.lexer.lexpos - count - t.lexer.lineno + 2 + self.errors.append("(" + str(t.lexer.lineno) + ", " + str(posAtLine) + ") - LexicographicError: EOF in string constant") + + def t_ID(self, t): + r'[a-z][a-zA-Z_0-9]*' + v = t.value.lower() + #true o false tienen que escribirse en letra inicial minuscula, de lo contrario son IDs + if v == 'true' or v == 'false': + if t.value[0] == 'T' or t.value[0] == 'F': + return t + + t.type = self.reserved.get(t.value.lower(), 'ID') + return t + + def t_TYPE_ID(self, t): + r'[A-Z][a-zA-Z_0-9]*' + v = t.value.lower() + #true o false tienen que escribirse en letra inicial minuscula, de lo contrario son IDs + if v == 'true' or v == 'false': + if t.value[0] == 'T' or t.value[0] == 'F': + return t + + t.type = self.reserved.get(t.value.lower(), 'TYPE_ID') + return t + + def t_comment(self, t): + r'--[^\n]*\n' + t.lexer.lineno += 1 + + def t_commentMultiline(self, t): + r'\(\*' + s = '' + count = 1 + end_re = lex.re.compile('\*\)') + open_re = lex.re.compile('\(\*') + any_re = lex.re.compile('[^\(\)\*]*') + while count > 0: + if t.lexer.lexpos == len(t.lexer.lexdata): + break + + m = end_re.match(t.lexer.lexdata[t.lexer.lexpos:]) + + if not m is None: + s+= m.group() + t.lexer.skip(2) + count -= 1 + continue + + m = open_re.match(t.lexer.lexdata[t.lexer.lexpos:]) + if not m is None: + s+=m.group() + t.lexer.skip(2) + count += 1 + continue + + m = any_re.match(t.lexer.lexdata[t.lexer.lexpos:]) + if m.group() == '': + s+= str(t.lexer.lexdata[t.lexer.lexpos]) + t.lexer.skip(1) + else: + s += m.group() + t.lexer.skip(len(m.group())) + + t.lexer.lineno += len(s.split('\n')) - 1 + if count > 0: + posAtLine = len(t.lexer.lexdata.split('\n')[t.lexer.lineno - 1]) + 1 + self.errors.append("(" + str(t.lexer.lineno) + ", " + str(posAtLine) + ") - LexicographicError: EOF in comment") + + + + + def t_comment_end_string(self, t): + r'--[^$]*$' + t.lexer.lineno += 1 + + def t_newline(self, t): + r'\n+' + t.lexer.lineno += len(t.value) + + def t_error(self, t): + #error = 'Error en la linea ' + str(t.lexer.lineno) + ': \'' + printLine(t.lexer.lexdata, t.lexer.lineno) + #error += '\' --> Problema con el caracter \'' + t.value[0] + '\'' + + + + s = t.lexer.lexdata.split('\n') + count = 0 + for i in range(t.lexer.lineno - 1): + count += len(s[i]) + + posAtLine = t.lexer.lexpos - count - t.lexer.lineno + 2 + error = "(" + str(t.lexer.lineno) + ", " + str(posAtLine) + ') - LexicographicError: ERROR "' + t.lexer.lexdata[t.lexer.lexpos] + '"' + self.errors.append(error) + t.lexer.skip(1) + + + t_ignore_WHITESPACE = r'\s' + + #funcion para tokenizar (devuelve una tupla: (tokens, errores)) + def tokenize(self, data, lexer): #data: texto a tokenizar, lexer: encargado de tokenizar, el campo object del lexer debe ser de tipo Tokenizer + self.errors = [] #se almacenan los errores en el proceso de tokenizar + + lexer.input(data) + tokens = [] + while True: + tok = lexer.token() + if not tok: + return (tokens, self.errors) + tokens.append(tok) + +class Lexer(CompilerComponent): + def __init__(self, cool_program: str) -> None: + super().__init__() + self.cool_program = cool_program + self.errors = [] + + def execute(self): + tokenizer = Tokenizer() + lexer = lex.lex(tokenizer) + tokens, self.errors = tokenizer.tokenize(self.cool_program, lexer) + + def has_errors(self): + return len(self.errors) > 0 + + def print_errors(self): + for e in self.errors: + print(e) diff --git a/src/compiler_components/mips.py b/src/compiler_components/mips.py new file mode 100644 index 000000000..fbc207c5a --- /dev/null +++ b/src/compiler_components/mips.py @@ -0,0 +1,698 @@ +from . import visitor +from .ast import * + +class MipsNode: + pass + +class MipsProgramNode(MipsNode): + def __init__(self, dotdata, dotcode): + self.dotdata = dotdata + self.dotcode = dotcode + +# string +class MipsStringNode(MipsNode): + def __init__(self, name, value): + self.name = name + self.value = value + +class MipsWordNode(MipsNode): + def __init__(self, name, value): + self.name = name + self.value = value + +class MipsTableNode(MipsNode): + def __init__(self , type_name,methods): + self.type_name = type_name + self.methods = methods + +# jumps +class MipsJumpNode(MipsNode): + def __init__(self, label): + self.label = label + +class MipsJumpAtAddressNode(MipsJumpNode): + pass + +class MipsJRNode(MipsJumpNode): + pass + +class MipsJALRNode(MipsJumpNode): + pass + + +# stack +class MipsLWNode(MipsNode): + def __init__(self, dest, src): + self.src = src + self.dest = dest + +class MipsLINode(MipsNode): + def __init__(self, dest, src): + self.src = src + self.dest = dest + +class MipsLANode(MipsNode): + def __init__(self, dest, src): + self.src = src + self.dest = dest + +class MipsSWNode(MipsNode): + def __init__(self, src, dest): + self.src = src + self.dest = dest + + +# syscall +class MipsSyscallNode(MipsNode): + pass + + +# move +class MipsMoveNode(MipsNode): + def __init__(self, dest, src): + self.src = src + self.dest = dest + + +# arithmetic +class MipsArithmeticNode: + def __init__(self, param1, param2, param3): + self.param1 = param1 + self.param2 = param2 + self.param3 = param3 + +class MipsAddNode(MipsArithmeticNode): + pass + +class MipsAddiuNode(MipsArithmeticNode): + pass + +class MipsMinusNode(MipsArithmeticNode): + pass + +class MipsStarNode(MipsArithmeticNode): + pass + +class MipsDivNode(MipsArithmeticNode): + pass + +class MipsNEGNode(MipsNode): + def __init__(self, dest, src): + self.dest = dest + self.src = src + +# comp +class MipsComparerNode(MipsNode): + def __init__(self, param1, param2, label): + self.param1 = param1 + self.param2 = param2 + self.label = label + +class MipsBEQNode(MipsComparerNode): + pass + +class MipsBNENode(MipsComparerNode): + pass + +class MipsBLTNode(MipsComparerNode): + pass + +class MipsBLENode(MipsComparerNode): + pass + + + +# label +class MipsLabelNode(MipsNode): + def __init__(self, name): + self.name = name + +class MipsCommentNode(MipsNode): + def __init__(self, comment): + self.comment = '\n #' + comment + '\n' + +def get_formatter(): + + class PrintVisitor(object): + @visitor.on('node') + def visit(self, node): + pass + + @visitor.when(MipsProgramNode) + def visit(self, node): + dotdata = '\n'.join(self.visit(t) for t in node.dotdata) + dotdata += ''' + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz "\n" + _buffer: .space 2048 + _void: .asciiz "" + ''' + + dotcode = '\n'.join(self.visit(t) for t in node.dotcode) + dotcode += '''\n + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + ''' + + return f'.data\n{dotdata}\n\n.text\n{dotcode}' + + @visitor.when(MipsStringNode) + def visit(self, node): + return f'\t\t\t{node.name}: .asciiz "{node.value}"' + + @visitor.when(MipsWordNode) + def visit(self, node): + return f'\t\t\t{node.name}: .word {node.value}' + + @visitor.when(MipsTableNode) + def visit(self , node:MipsTableNode): + return f'__virtual_table__{node.type_name}:\n' + '\n'.join( f"\t\t\t .word {m}" for m in node.methods) + + # jumps + @visitor.when(MipsJumpNode) + def visit(self, node): + return f'\t\t\tj {node.label}' + + @visitor.when(MipsJumpAtAddressNode) + def visit(self, node): + return f'\t\t\tjal {node.label}' + + @visitor.when(MipsJRNode) + def visit(self, node): + return f'\t\t\tjr {node.label}' + + @visitor.when(MipsJALRNode) + def visit(self, node): + return f'\t\t\tjalr {node.label}' + + # stack + @visitor.when(MipsLWNode) + def visit(self, node): + return f'\t\t\tlw {node.dest}, {node.src}' + + @visitor.when(MipsLINode) + def visit(self, node): + return f'\t\t\tli {node.dest}, {node.src}' + + @visitor.when(MipsLANode) + def visit(self, node): + return f'\t\t\tla {node.dest}, {node.src}' + + @visitor.when(MipsSWNode) + def visit(self, node): + return f'\t\t\tsw {node.src}, {node.dest}' + + + # syscall + @visitor.when(MipsSyscallNode) + def visit(self, node): + return '\t\t\tsyscall' + + + # move + @visitor.when(MipsMoveNode) + def visit(self, node): + return f'\t\t\tmove {node.dest}, {node.src}' + + + + # arithmetic + @visitor.when(MipsAddNode) + def visit(self, node): + return f'\t\t\tadd {node.param1}, {node.param2}, {node.param3}' + + @visitor.when(MipsAddiuNode) + def visit(self, node): + return f'\t\t\taddiu {node.param1}, {node.param2}, {node.param3}' + + @visitor.when(MipsMinusNode) + def visit(self, node): + return f'\t\t\tsub {node.param1}, {node.param2}, {node.param3}' + + @visitor.when(MipsStarNode) + def visit(self, node): + return f'\t\t\tmul {node.param1} {node.param2} {node.param3}' + + @visitor.when(MipsNEGNode) + def visit(self, node): + return f'\t\t\tneg {node.dest}, {node.src}' + + @visitor.when(MipsDivNode) + def visit(self, node): + return f'\t\t\tdiv {node.param1}, {node.param2}, {node.param3}' + + # comp + @visitor.when(MipsBNENode) + def visit(self, node): + return f'\t\t\tbne {node.param1}, {node.param2}, {node.label}' + + @visitor.when(MipsBEQNode) + def visit(self, node): + return f'\t\t\tbeq {node.param1}, {node.param2}, {node.label}' + + @visitor.when(MipsBLTNode) + def visit(self, node): + return f'\t\t\tblt {node.param1}, {node.param2}, {node.label}' + + @visitor.when(MipsBLENode) + def visit(self, node): + return f'\t\t\tble {node.param1}, {node.param2}, {node.label}' + + + + # label + @visitor.when(MipsLabelNode) + def visit(self, node): + return f'{node.name}:' + + @visitor.when(MipsCommentNode) + def visit(self, node): + return node.comment + + printer = PrintVisitor() + return (lambda ast: printer.visit(ast)) \ No newline at end of file diff --git a/src/compiler_components/parsetab.py b/src/compiler_components/parsetab.py new file mode 100644 index 000000000..2f4d2e0dc --- /dev/null +++ b/src/compiler_components/parsetab.py @@ -0,0 +1,93 @@ + +# parsetab.py +# This file is automatically generated. Do not edit. +# pylint: disable=W,C,R +_tabversion = '3.10' + +_lr_method = 'LALR' + +_lr_signature = 'ARROBA CASE CLASS COMMA DIVIDE DOT DOUBLE_DOT ELSE EQUALS ESAC FALSE FI ID IF IN INHERITS ISVOID LBRACE LEFT_ARROW LET LOOP LPAREN MINOR MINOR_EQUALS MINUS NEW NHANHARA NOT NUMBER OF PLUS POOL RBRACE RIGHT_ARROW RPAREN SEMICOLON STRING THEN TIMES TRUE TYPE_ID WHILEprogram : class_listclass_list : def_class SEMICOLON\n | def_class SEMICOLON class_list\n def_class : CLASS type_id LBRACE feature_list RBRACE\n | CLASS type_id INHERITS type_inherit LBRACE feature_list RBRACE\n type_inherit : TYPE_IDtype_id : TYPE_IDempty :feature_list : def_attr SEMICOLON feature_list\n | def_func SEMICOLON feature_list\n | empty\n def_attr : id DOUBLE_DOT type_id\n | id DOUBLE_DOT type_id LEFT_ARROW expr\n def_func : ID LPAREN param_list RPAREN DOUBLE_DOT TYPE_ID LBRACE expr RBRACE\n param_list : param param_list2\n | empty\n param_list2 : COMMA param param_list2\n | empty\n param : ID DOUBLE_DOT TYPE_ID\n expr_list : expr SEMICOLON\n | expr SEMICOLON expr_list\n expr : boolbool : NOT bool\n | arith MINOR arith\n | arith MINOR_EQUALS arith\n | arith EQUALS arith\n | arith\n expr : ID LEFT_ARROW exprarith : term\n | NOT bool \n | arith PLUS term\n | arith MINUS term\n term : factor\n | term TIMES factor\n | term DIVIDE factor\n factor : atom\n | LPAREN expr RPAREN\n atom : IDatom : NUMBERatom : func_callatom : NEW TYPE_ID \n atom : STRINGatom : TRUE\n | FALSE\n atom : IF expr THEN expr ELSE expr FIatom : WHILE expr LOOP expr POOLatom : LBRACE expr_list RBRACEatom : LET atr_decl_list IN expratr_decl_list : def_attr\n | def_attr COMMA atr_decl_list \n \n atom : CASE expr OF case_list ESACcase_list : id DOUBLE_DOT TYPE_ID RIGHT_ARROW expr SEMICOLON\n | id DOUBLE_DOT TYPE_ID RIGHT_ARROW expr SEMICOLON case_list\n id : IDatom : ISVOID factoratom : NHANHARA factorfunc_call : factor DOT ID LPAREN arg_list RPAREN\n func_call : ID LPAREN arg_list RPARENfunc_call : factor ARROBA TYPE_ID DOT ID LPAREN arg_list RPARENarg_list : expr arg_list2\n | empty\n arg_list2 : COMMA expr arg_list2\n | empty\n ' + +_lr_action_items = {'CLASS':([0,5,],[4,4,]),'$end':([1,2,5,8,],[0,-1,-2,-3,]),'SEMICOLON':([3,7,12,13,19,27,39,40,41,42,44,45,46,47,49,50,52,53,54,67,68,79,83,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,137,139,144,146,147,],[5,-7,20,21,-4,-12,-5,-13,-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,110,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-14,-57,-45,-59,148,]),'TYPE_ID':([4,10,22,34,51,63,77,136,],[7,18,7,62,79,90,105,142,]),'LBRACE':([6,7,17,18,33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,90,97,107,108,110,111,114,117,120,133,140,145,],[9,-7,24,-6,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,57,114,57,57,57,57,57,57,57,57,57,57,57,]),'INHERITS':([6,7,],[10,-7,]),'LEFT_ARROW':([7,27,42,],[-7,33,65,]),'COMMA':([7,27,30,40,41,42,44,45,46,47,49,50,52,53,54,62,64,67,68,79,85,88,89,92,94,96,98,99,100,101,102,103,106,109,115,119,125,130,134,135,139,144,146,],[-7,-12,37,-13,-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-19,37,-23,-38,-41,112,-55,-56,-28,117,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,117,-46,-51,-57,-45,-59,]),'IN':([7,27,40,41,42,44,45,46,47,49,50,52,53,54,67,68,79,84,85,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,126,134,135,139,144,146,],[-7,-12,-13,-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,111,-49,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,-50,-46,-51,-57,-45,-59,]),'ID':([9,20,21,23,24,33,37,43,48,55,56,57,58,59,60,61,65,66,69,70,71,72,73,74,75,76,97,107,108,110,111,112,113,114,117,120,121,133,140,145,148,],[16,16,16,28,16,42,28,68,42,42,42,42,86,42,68,68,42,42,68,68,68,68,68,68,68,104,68,42,42,42,42,86,86,42,42,42,132,42,42,42,86,]),'RBRACE':([9,11,14,20,21,24,25,26,32,41,42,44,45,46,47,49,50,52,53,54,67,68,79,82,88,89,92,96,98,99,100,101,102,103,106,109,110,115,119,124,125,129,134,135,139,144,146,],[-8,19,-11,-8,-8,-8,-9,-10,39,-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,109,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-20,-58,-30,-21,-48,137,-46,-51,-57,-45,-59,]),'DOUBLE_DOT':([15,16,28,35,86,128,],[22,-54,34,63,-54,136,]),'LPAREN':([16,33,42,43,48,55,56,57,59,60,61,65,66,68,69,70,71,72,73,74,75,97,104,107,108,110,111,114,117,120,132,133,140,145,],[23,48,66,48,48,48,48,48,48,48,48,48,48,66,48,48,48,48,48,48,48,48,120,48,48,48,48,48,48,48,140,48,48,48,]),'RPAREN':([23,29,30,31,36,38,41,42,44,45,46,47,49,50,52,53,54,62,64,66,67,68,78,79,88,89,91,92,93,94,95,96,98,99,100,101,102,103,106,109,115,116,118,119,120,125,130,131,134,135,138,139,140,143,144,146,],[-8,35,-8,-16,-15,-18,-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-19,-8,-8,-23,-38,106,-41,-55,-56,-17,-28,115,-8,-61,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-60,-63,-30,-8,-48,-8,139,-46,-51,-62,-57,-8,146,-45,-59,]),'NOT':([33,43,48,55,56,57,59,65,66,69,70,71,97,107,108,110,111,114,117,120,133,140,145,],[43,43,43,43,43,43,43,43,43,97,97,97,43,43,43,43,43,43,43,43,43,43,43,]),'NUMBER':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,]),'NEW':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,]),'STRING':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,]),'TRUE':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,]),'FALSE':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,]),'IF':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,]),'WHILE':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,56,]),'LET':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,58,]),'CASE':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,59,]),'ISVOID':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,60,]),'NHANHARA':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,61,]),'THEN':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,80,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,107,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'LOOP':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,81,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,108,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'OF':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,87,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,113,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'MINOR':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,69,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'MINOR_EQUALS':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,70,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'EQUALS':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,71,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'PLUS':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,72,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,72,72,72,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'MINUS':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,73,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,73,73,73,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'ELSE':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,122,125,134,135,139,144,146,],[-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,133,-48,-46,-51,-57,-45,-59,]),'POOL':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,123,125,134,135,139,144,146,],[-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,134,-48,-46,-51,-57,-45,-59,]),'DOT':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,105,106,109,115,119,125,134,135,139,144,146,],[-22,-38,-27,-29,76,-36,-39,-40,-42,-43,-44,-23,-38,-41,76,76,-28,-24,-25,-26,-31,-32,76,76,121,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'ARROBA':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,-27,-29,77,-36,-39,-40,-42,-43,-44,-23,-38,-41,77,77,-28,-24,-25,-26,-31,-32,77,77,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'TIMES':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,-27,74,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,-24,-25,-26,74,74,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'DIVIDE':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,144,146,],[-22,-38,-27,75,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,-24,-25,-26,75,75,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,-45,-59,]),'FI':([41,42,44,45,46,47,49,50,52,53,54,67,68,79,88,89,92,96,98,99,100,101,102,103,106,109,115,119,125,134,135,139,141,144,146,],[-22,-38,-27,-29,-33,-36,-39,-40,-42,-43,-44,-23,-38,-41,-55,-56,-28,-24,-25,-26,-31,-32,-34,-35,-37,-47,-58,-30,-48,-46,-51,-57,144,-45,-59,]),'ESAC':([127,148,149,],[135,-52,-53,]),'RIGHT_ARROW':([142,],[145,]),} + +_lr_action = {} +for _k, _v in _lr_action_items.items(): + for _x,_y in zip(_v[0],_v[1]): + if not _x in _lr_action: _lr_action[_x] = {} + _lr_action[_x][_k] = _y +del _lr_action_items + +_lr_goto_items = {'program':([0,],[1,]),'class_list':([0,5,],[2,8,]),'def_class':([0,5,],[3,3,]),'type_id':([4,22,],[6,27,]),'feature_list':([9,20,21,24,],[11,25,26,32,]),'def_attr':([9,20,21,24,58,112,],[12,12,12,12,85,85,]),'def_func':([9,20,21,24,],[13,13,13,13,]),'empty':([9,20,21,23,24,30,64,66,94,120,130,140,],[14,14,14,31,14,38,38,95,118,95,118,95,]),'id':([9,20,21,24,58,112,113,148,],[15,15,15,15,15,15,128,128,]),'type_inherit':([10,],[17,]),'param_list':([23,],[29,]),'param':([23,37,],[30,64,]),'param_list2':([30,64,],[36,91,]),'expr':([33,48,55,56,57,59,65,66,107,108,110,111,114,117,120,133,140,145,],[40,78,80,81,83,87,92,94,122,123,83,125,129,130,94,141,94,147,]),'bool':([33,43,48,55,56,57,59,65,66,97,107,108,110,111,114,117,120,133,140,145,],[41,67,41,41,41,41,41,41,41,119,41,41,41,41,41,41,41,41,41,41,]),'arith':([33,43,48,55,56,57,59,65,66,69,70,71,97,107,108,110,111,114,117,120,133,140,145,],[44,44,44,44,44,44,44,44,44,96,98,99,44,44,44,44,44,44,44,44,44,44,44,]),'term':([33,43,48,55,56,57,59,65,66,69,70,71,72,73,97,107,108,110,111,114,117,120,133,140,145,],[45,45,45,45,45,45,45,45,45,45,45,45,100,101,45,45,45,45,45,45,45,45,45,45,45,]),'factor':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[46,46,46,46,46,46,46,88,89,46,46,46,46,46,46,46,102,103,46,46,46,46,46,46,46,46,46,46,46,]),'atom':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,]),'func_call':([33,43,48,55,56,57,59,60,61,65,66,69,70,71,72,73,74,75,97,107,108,110,111,114,117,120,133,140,145,],[50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,]),'expr_list':([57,110,],[82,124,]),'atr_decl_list':([58,112,],[84,126,]),'arg_list':([66,120,140,],[93,131,143,]),'arg_list2':([94,130,],[116,138,]),'case_list':([113,148,],[127,149,]),} + +_lr_goto = {} +for _k, _v in _lr_goto_items.items(): + for _x, _y in zip(_v[0], _v[1]): + if not _x in _lr_goto: _lr_goto[_x] = {} + _lr_goto[_x][_k] = _y +del _lr_goto_items +_lr_productions = [ + ("S' -> program","S'",1,None,None,None), + ('program -> class_list','program',1,'p_program','cool_parser.py',14), + ('class_list -> def_class SEMICOLON','class_list',2,'p_class_list','cool_parser.py',18), + ('class_list -> def_class SEMICOLON class_list','class_list',3,'p_class_list','cool_parser.py',19), + ('def_class -> CLASS type_id LBRACE feature_list RBRACE','def_class',5,'p_def_class','cool_parser.py',27), + ('def_class -> CLASS type_id INHERITS type_inherit LBRACE feature_list RBRACE','def_class',7,'p_def_class','cool_parser.py',28), + ('type_inherit -> TYPE_ID','type_inherit',1,'p_type_inherit','cool_parser.py',39), + ('type_id -> TYPE_ID','type_id',1,'p_type_id','cool_parser.py',44), + ('empty -> ','empty',0,'p_empty','cool_parser.py',49), + ('feature_list -> def_attr SEMICOLON feature_list','feature_list',3,'p_feature_list','cool_parser.py',53), + ('feature_list -> def_func SEMICOLON feature_list','feature_list',3,'p_feature_list','cool_parser.py',54), + ('feature_list -> empty','feature_list',1,'p_feature_list','cool_parser.py',55), + ('def_attr -> id DOUBLE_DOT type_id','def_attr',3,'p_def_attr','cool_parser.py',63), + ('def_attr -> id DOUBLE_DOT type_id LEFT_ARROW expr','def_attr',5,'p_def_attr','cool_parser.py',64), + ('def_func -> ID LPAREN param_list RPAREN DOUBLE_DOT TYPE_ID LBRACE expr RBRACE','def_func',9,'p_def_func','cool_parser.py',72), + ('param_list -> param param_list2','param_list',2,'p_param_list','cool_parser.py',78), + ('param_list -> empty','param_list',1,'p_param_list','cool_parser.py',79), + ('param_list2 -> COMMA param param_list2','param_list2',3,'p_param_list2','cool_parser.py',87), + ('param_list2 -> empty','param_list2',1,'p_param_list2','cool_parser.py',88), + ('param -> ID DOUBLE_DOT TYPE_ID','param',3,'p_param','cool_parser.py',96), + ('expr_list -> expr SEMICOLON','expr_list',2,'p_expr_list','cool_parser.py',101), + ('expr_list -> expr SEMICOLON expr_list','expr_list',3,'p_expr_list','cool_parser.py',102), + ('expr -> bool','expr',1,'p_expr','cool_parser.py',110), + ('bool -> NOT bool','bool',2,'p_bool','cool_parser.py',114), + ('bool -> arith MINOR arith','bool',3,'p_bool','cool_parser.py',115), + ('bool -> arith MINOR_EQUALS arith','bool',3,'p_bool','cool_parser.py',116), + ('bool -> arith EQUALS arith','bool',3,'p_bool','cool_parser.py',117), + ('bool -> arith','bool',1,'p_bool','cool_parser.py',118), + ('expr -> ID LEFT_ARROW expr','expr',3,'p_expr2','cool_parser.py',135), + ('arith -> term','arith',1,'p_arith','cool_parser.py',140), + ('arith -> NOT bool','arith',2,'p_arith','cool_parser.py',141), + ('arith -> arith PLUS term','arith',3,'p_arith','cool_parser.py',142), + ('arith -> arith MINUS term','arith',3,'p_arith','cool_parser.py',143), + ('term -> factor','term',1,'p_term','cool_parser.py',157), + ('term -> term TIMES factor','term',3,'p_term','cool_parser.py',158), + ('term -> term DIVIDE factor','term',3,'p_term','cool_parser.py',159), + ('factor -> atom','factor',1,'p_factor','cool_parser.py',171), + ('factor -> LPAREN expr RPAREN','factor',3,'p_factor','cool_parser.py',172), + ('atom -> ID','atom',1,'p_atom1','cool_parser.py',181), + ('atom -> NUMBER','atom',1,'p_atom2','cool_parser.py',186), + ('atom -> func_call','atom',1,'p_atom3','cool_parser.py',191), + ('atom -> NEW TYPE_ID','atom',2,'p_atom4','cool_parser.py',195), + ('atom -> STRING','atom',1,'p_atomString','cool_parser.py',201), + ('atom -> TRUE','atom',1,'p_atomBool','cool_parser.py',206), + ('atom -> FALSE','atom',1,'p_atomBool','cool_parser.py',207), + ('atom -> IF expr THEN expr ELSE expr FI','atom',7,'p_atomIF','cool_parser.py',220), + ('atom -> WHILE expr LOOP expr POOL','atom',5,'p_atomCicle','cool_parser.py',225), + ('atom -> LBRACE expr_list RBRACE','atom',3,'p_atomBlock','cool_parser.py',230), + ('atom -> LET atr_decl_list IN expr','atom',4,'p_atomLet','cool_parser.py',235), + ('atr_decl_list -> def_attr','atr_decl_list',1,'p_atr_decl_list','cool_parser.py',240), + ('atr_decl_list -> def_attr COMMA atr_decl_list','atr_decl_list',3,'p_atr_decl_list','cool_parser.py',241), + ('atom -> CASE expr OF case_list ESAC','atom',5,'p_atomCase','cool_parser.py',250), + ('case_list -> id DOUBLE_DOT TYPE_ID RIGHT_ARROW expr SEMICOLON','case_list',6,'p_caseList','cool_parser.py',255), + ('case_list -> id DOUBLE_DOT TYPE_ID RIGHT_ARROW expr SEMICOLON case_list','case_list',7,'p_caseList','cool_parser.py',256), + ('id -> ID','id',1,'p_id','cool_parser.py',265), + ('atom -> ISVOID factor','atom',2,'p_atomIsVoid','cool_parser.py',270), + ('atom -> NHANHARA factor','atom',2,'p_atomNhanhara','cool_parser.py',281), + ('func_call -> factor DOT ID LPAREN arg_list RPAREN','func_call',6,'p_func_call','cool_parser.py',286), + ('func_call -> ID LPAREN arg_list RPAREN','func_call',4,'p_func_call2','cool_parser.py',292), + ('func_call -> factor ARROBA TYPE_ID DOT ID LPAREN arg_list RPAREN','func_call',8,'p_func_call3','cool_parser.py',297), + ('arg_list -> expr arg_list2','arg_list',2,'p_arg_list','cool_parser.py',304), + ('arg_list -> empty','arg_list',1,'p_arg_list','cool_parser.py',305), + ('arg_list2 -> COMMA expr arg_list2','arg_list2',3,'p_arg_list2','cool_parser.py',313), + ('arg_list2 -> empty','arg_list2',1,'p_arg_list2','cool_parser.py',314), +] diff --git a/src/compiler_components/semantic/__init__.py b/src/compiler_components/semantic/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/src/compiler_components/semantic/structures.py b/src/compiler_components/semantic/structures.py new file mode 100644 index 000000000..0441d1517 --- /dev/null +++ b/src/compiler_components/semantic/structures.py @@ -0,0 +1,329 @@ +from collections import OrderedDict +import itertools as itt + +############# Semantic Errors ####################### +class SemanticError(Exception): + @property + def text(self): + return str(self.args[0]) +class TypeError(SemanticError): + pass +class NameError(SemanticError): + pass +class AttributeError(SemanticError): + pass +class ParamError(Exception): + pass +class ParentError(Exception): + pass +############## End Semantic Errors ############################# + +############ Class members ############################### +class Attribute: + def __init__(self, name, typex): + self.name = name + self.type = typex + + def __str__(self): + return f'[attrib] {self.name} : {self.type.name};' + + def __repr__(self): + return str(self) + +class Method: + def __init__(self, name, param_names, params_types, return_type): + self.name = name + self.param_names = param_names + self.param_types = params_types + self.return_type = return_type + + def __str__(self): + params = ', '.join(f'{n}:{t.name}' for n,t in zip(self.param_names, self.param_types)) + return f'[method] {self.name}({params}): {self.return_type.name};' + + def __eq__(self, other): + return other.name == self.name and \ + other.return_type == self.return_type and \ + other.param_types == self.param_types +################# End Class Members ######################################### + + +############# Type ####################################### +class Type: + def __init__(self, name:str,line=-1, column=-1): + self.name = name + self.attributes = [] + self.methods = [] + self.parent = None + self.sons = [] + self.line = line + self.column = column + + def set_parent(self, parent, pos=0): + if self.parent is not None: + raise SemanticError(f'Parent type is already set for {self.name}', pos) + self.parent = parent + parent.sons.append(self) + + def get_attribute(self, name:str,pos=0, parent={'value':False}): + try: + return next(attr for attr in self.attributes if attr.name == name) + except StopIteration: + if self.parent is None: + raise SemanticError(f'Attribute "{name}" is not defined in {self.name}',pos) + try: + parent['value'] = True + return self.parent.get_attribute(name, parent=parent) + except SemanticError: + raise SemanticError(f'Attribute "{name}" is not defined in {self.name}',pos) + + def define_attribute(self, name:str, typex, pos): + try: + parent = {} + parent['value'] = False + self.get_attribute(name, parent = parent) + except SemanticError: + a = Attribute(name, typex) + self.attributes.append(a) + return a + else: + if not parent['value']: + raise SemanticError(f'SemanticError:') + else: + raise SemanticError(f'SemanticError:') + + def get_method(self, name:str,line=0, col=0, own={'value':True}): + try: + return next(method for method in self.methods if method.name == name) + except StopIteration: + if self.parent is None: + raise AttributeError(f'{line},{col} - NameError: Undeclared identifier {name}') + try: + own['value'] = False + return self.parent.get_method(name, own) + except SemanticError: + raise AttributeError(f'{line},{col} - NameError: Undeclared identifier {name}') + + def define_method(self, name:str, param_names:list, param_types:list, return_type, pos): + try: + own ={'value':True} + method = self.get_method(name, pos, own = own) + if method.return_type != return_type or method.param_types != param_types: + raise SemanticError(f'Method "{name}" already defined in {self.name} with a different signature.', pos) + else: + if own['value']: + raise SemanticError(f'Method "{name}" already defined in {self.name} ', pos) + raise AttributeError() + + except AttributeError as e: + method = Method(name, param_names, param_types, return_type) + self.methods.append(method) + return method + + def all_attributes(self, clean=True): + plain = OrderedDict() if self.parent is None else self.parent.all_attributes(False) + for attr in self.attributes: + plain[attr.name] = (attr, self) + return plain.values() if clean else plain + + def all_methods(self, clean=True): + plain = OrderedDict() if self.parent is None else self.parent.all_methods(False) + for method in self.methods: + plain[method.name] = (method, self) + return plain.values() if clean else plain + + def conforms_to(self, other): + return other.bypass() or self == other or self.parent is not None and self.parent.conforms_to(other) + + def bypass(self): + return False + + def __str__(self): + output = f'Type {self.name}' + return output + + def __repr__(self): + return str(self) + +class ErrorType(Type): + def __init__(self): + Type.__init__(self, '') + + def conforms_to(self, other): + return True + + def bypass(self): + return True + + def __eq__(self, other): + return isinstance(other, Type) + +class VoidType(Type): + def __init__(self): + Type.__init__(self, '') + + def conforms_to(self, other): + raise Exception('Invalid type: void type.') + + def bypass(self): + return True + + def __eq__(self, other): + return isinstance(other, VoidType) + +class SELF_TYPE(Type): + def __init__(self): + Type.__init__(self, "SELF_TYPE") + + def __eq__(self, other): + return isinstance(other, SELF_TYPE) + +########### End Type ########################## + + +########## Context ################################### +class Context: + def __init__(self): + self.types = {} + self.built_in() + + def built_in(self): + Bool = Type("Bool") + self.types["Bool"] = Bool + + Int = Type("Int") + self.types["Int"] = Int + + Object = Type("Object") + self.types["Object"] =Object + + String = Type("String") + self.types["String"] = String + + IO = Type("IO") + self.types['IO']= IO + + Object.define_method("abort",[],[],Object,0) + Object.define_method("type_name",[],[],String,0) + Object.define_method("copy",[],[],SELF_TYPE(),0) + + String.define_method("length",[],[],Int,0) + String.define_method("concat",['s'],[String],String,0) + String.define_method("substr",['i','l'],[Int,Int],SELF_TYPE(),0) + + IO.define_method("out_string",["x"],[String],SELF_TYPE(),0) + IO.define_method("out_int",['x'],[Int],SELF_TYPE(),0) + IO.define_method("in_int",[],[],Int,0) + IO.define_method("in_string",[], [], String, 0) + + def check_type(self,x:Type,y:Type,pos): + if not x.conforms_to(y) : + raise(TypeError(f"Expr type {x.name} is no subclass of {y.name} ",pos)) + + def create_type(self, name:str,line=0, column=0): + if name in self.types: + raise SemanticError(f'Type with the same name ({name}) already in context.') + t = self.types[name] = Type(name, line, column) + return t + + def get_type(self, name:str,pos=0): + try: + return self.types[name] + except KeyError: + raise TypeError(f'TypeError:') + + def closest_common_antecesor(self, type1:Type, type2:Type): + antecesors = [] + while not type1 is None or not type2 is None : + if not type2 is None : + if type2 in antecesors: + return type2 + antecesors.append(type2) + + if not type1 is None: + if type1 in antecesors: + return type1 + antecesors.append(type1) + + if not type1 is None: + type1 = type1.parent + if not type2 is None: + type2 = type2.parent + + return self.get_type("Object") + + def circular_dependency(self): + visited = set() + on_cycle = {} + count = 0 + for tp in self.types: + temp = self.types[tp] + ancestors = set() + while True: + if temp.name in visited: + break + ancestors.add(temp.name) + visited.add(temp.name) + if temp.parent is None: + break + if temp.parent.name in ancestors: + on_cycle[count] = [] + on_cycle[count].append((temp.name,temp.line, temp.column)) + temp2 = temp.parent + while temp != temp2: + on_cycle[count].append((temp2.name,temp2.line, temp2.column)) + temp2 = temp2.parent + on_cycle[count].sort(key= lambda x:x[1],reverse=True) + count = count + 1 + break + temp = temp.parent + return on_cycle.values() +############ End Context ######################## + +class VariableInfo: + def __init__(self, name, typex): + self.name = name + self.type = typex + +################## Scope ############################## +class Scope: + def __init__(self, parent=None): + self.locals = [] + self.parent = parent + self.children = [] + self.id = 0 + self.index = 0 if parent is None else len(parent) + + def __len__(self): + return len(self.locals) + + def create_child(self): + child = Scope(self) + child.id = self.id*10 +len(self.children) + self.children.append(child) + return child + + def is_defined(self, vname): + return self.find_variable(vname) is not None + + def is_local(self, vname): + return any(True for x in self.locals if x.name == vname) + + def define_variable(self, vname, vtype,pos=0): + if self.is_local(vname): + raise SemanticError(f"Variable {vname} already define in scope " , pos) + v = VariableInfo(vname, vtype) + self.locals.append(v) + return v + + def find_variable(self, vname, index=None): + locals = self.locals if index is None else itt.islice(self.locals, index) + + for l in locals: + if l.name == vname: + return l + + if not self.parent is None: + return self.parent.find_variable(vname, self.index) + else: + return None \ No newline at end of file diff --git a/src/compiler_components/semantic/type_builder.py b/src/compiler_components/semantic/type_builder.py new file mode 100644 index 000000000..b5be263c3 --- /dev/null +++ b/src/compiler_components/semantic/type_builder.py @@ -0,0 +1,52 @@ +import sys +sys.path.append('../') +from ..ast import * +from . import visitor +import queue + +def sort_types(types): + q = queue.deque() + result = [] + for tp in types: + if types[tp].parent is None: + if tp != "Object": + types[tp].set_parent(types["Object"]) + + q.append("Object") + while len(q) != 0: + tp = q.popleft() + result.append(tp) + for son in types[tp].sons: + q.append(son.name) + return result + +class TypeBuilder: + def __init__(self, context, errors=[]): + self.context = context + self.errors = errors + + @visitor.on('node') + def visit(self, node): + pass + + @visitor.when(ProgramNode) + def visit(self, node): + nodec={ def_class.id:def_class for def_class in node.declarations} + sorted_types = sort_types(self.context.types) + for stypes in sorted_types: + if stypes in nodec: + self.visit(nodec[stypes]) + + @visitor.when(ProgramNode) + def visit(self, node): + nodec={ def_class.id:def_class for def_class in node.declarations} + sorted_types = sort_types(self.context.types) + for stypes in sorted_types: + if stypes in nodec: + self.visit(nodec[stypes]) + + @visitor.when(ClassDeclarationNode) + def visit(self, node): + self.current_type = self.context.get_type(node.id,-1) #change -1 for line number + for feature in node.features: + self.visit(feature) \ No newline at end of file diff --git a/src/compiler_components/semantic/type_checker.py b/src/compiler_components/semantic/type_checker.py new file mode 100644 index 000000000..ff9567876 --- /dev/null +++ b/src/compiler_components/semantic/type_checker.py @@ -0,0 +1,382 @@ +import sys +sys.path.append('../') +from ..ast import * +from .structures import * +from . import visitor + +class TypeChecker: + def __init__(self, context:Context, errors=[]): + self.context = context + self.current_type = None + self.errors = errors + + @visitor.on('node') + def visit(self, node): + pass + + @visitor.when(ProgramNode) + def visit(self, node:ProgramNode, scope=None): + for dec in node.declarations: + try: + self.visit(dec,scope.create_child()) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - SemanticError: " + str(e)) + + + @visitor.when(ClassDeclarationNode) + def visit(self, node:ClassDeclarationNode, scope:Scope): + try : + typex = self.context.get_type(node.id, node.line) + + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - TypeError: " + str(e)) + + self.current_type = typex + #for at in typex.all_attributes(): + # scope.define_variable(at[0].name, at[0].type,node.line) + scope.define_variable("self",typex,node.line) + mscope = scope.create_child() + ascope = scope.create_child() + for feat in node.features: + if isinstance(feat, FuncDeclarationNode): + self.visit(feat,mscope.create_child()) + else: + self.visit(feat, ascope.create_child()) + + @visitor.when(AttrDeclarationNode) + def visit(self, node:AttrDeclarationNode,scope:Scope): + node_type = self.context.get_type(node.type) + scope.define_variable(node.id, node_type) + if not node.expr is None: + self.visit(node.expr, scope.create_child()) + try: + + typex =self.current_type if node.type == "SELF_TYPE" else self.context.get_type(node.type,node.line) + self.context.check_type(node.expr.type,typex,node.line) + except SemanticError as e: + self.errors.append(f"({node.type_line},{node.type_column}) - TypeError: " + str(e)) + + @visitor.when(FuncDeclarationNode) + def visit(self, node:FuncDeclarationNode,scope:Scope): + + method = self.current_type.get_method(node.id, node.line, node.column) + + for i in range(len(method.param_names)): + try: + if method.param_names[i] == "self": + raise SemanticError('Trying to assign value to self' ,node.line) + + scope.define_variable(method.param_names[i],method.param_types[i],node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - SemanticError: " + str(e)) + + self.visit(node.body,scope.create_child()) + try: + typex = method.return_type if not isinstance(method.return_type,SELF_TYPE) else self.current_type + + self.context.check_type(node.body.type,typex,node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column-4}) - TypeError: " + str(e)) + except ParentError as p: + self.errors.append(f"({node.line},{node.column-4}) - SemanticError: " + str(e)) + + + @visitor.when(CaseNode) + def visit(self, node:CaseNode, scope:Scope): + node.type = ErrorType() + sce = scope.create_child() + self.visit(node.expr, sce) + scb = scope.create_child() + common_type = None + typesbr = set() + for branches in node.list_case: + tmpscope = scb.create_child() + if branches.type in typesbr: + self.errors.append(f"({branches.line},{branches.column}) - SemanticError: Type in more than one branch") + typesbr.add(branches.type) + try : + typex = self.context.get_type(branches.type,branches.expr.line) + except SemanticError as e: + self.errors.append(f"({branches.line},{branches.column}) - TypeError: {typex} is not defined") + tmpscope.define_variable(branches.id,typex,node.line) + self.visit(branches.expr,tmpscope) + if common_type is None: + common_type = branches.expr.type + else: + common_type = self.context.closest_common_antecesor(common_type,branches.expr.type) + + node.type = common_type + + + + + + @visitor.when(DispatchNode) + def visit(self, node:DispatchNode, scope:Scope): + self.visit(node.expr,scope.create_child()) + + node.type = ErrorType() + node.typexa = node.typex + for i in range(len(node.params)): + self.visit(node.params[i],scope.create_child()) + + if not node.typex is None: + try: + temp = self.context.get_type(node.typex,node.line) + self.context.check_type(node.expr.type,temp,node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - TypeError: " + str(e)) + return + else: + if isinstance( node.expr.type , ErrorType): + return + node.typex = node.expr.type.name + try: + typex = self.context.get_type(node.typex,node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - TypeError: " + str(e)) + return + try : + if isinstance( typex , ErrorType): + return + method = typex.get_method(node.id,node.line) + + ret_type = method.return_type if not isinstance(method.return_type,SELF_TYPE) else typex + node.type = ret_type + if len(method.param_types) != len(node.params): + raise ParamError() + for i in range(len(node.params)): + try: + self.context.check_type(node.params[i].type,method.param_types[i],node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - TypeError: " + str(e)) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - AttributeError: dispatch undeclared method {node.f}") + except ParamError as p: + self.errors.append(f'({node.line},{node.column}) - SemanticError: Method takes {len(method.param_types)} params but {len(node.params)} were given') + + @visitor.when(CallNode) + def visit(self, node:CallNode, scope:Scope): + node.type = ErrorType() + for i in range(len(node.args)): + self.visit(node.args[i],scope.create_child()) + + typex = self.current_type + try : + if isinstance( typex , ErrorType): + return + method = typex.get_method(node.id, node.line) + ret_type = method.return_type if not isinstance(method.return_type,SELF_TYPE) else typex + node.type = ret_type + if len(method.param_types) != len(node.args): + raise SemanticError (f'Method {node.id} takes {len(method.param_types)} params but {len(node.args)} were given') + for i in range(len(node.args)): + try: + self.context.check_type(node.args[i].type,method.param_types[i],node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - Type: " + str(e)) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - AttributeError: " + str(e)) + + + + + @visitor.when(IfNode) + def visit(self,node:IfNode,scope:Scope): + self.visit(node.if_c,scope.create_child()) + try: + self.context.check_type(node.if_c.type,self.context.get_type("Bool"),node.line) + except SemanticError as e: + self.errors.append(f"({node.if_c.line},{node.if_c.column}) - TypeError: " + str(e)) + + self.visit(node.then_c,scope.create_child()) + + self.visit(node.else_c, scope.create_child()) + try: + node.type = self.context.closest_common_antecesor(node.then_c.type, node.else_c.type) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - SemanticError: " + str(e)) + node.type = ErrorType() + + + @visitor.when(AssignNode) + def visit(self, node:AssignNode,scope:Scope): + self.visit(node.expr, scope.create_child()) + try: + if node.id == "self": + raise SemanticError('Trying to assign value to self' ,node.line) + + var = scope.find_variable(node.id) + + if var is None: + try: + at = [ at[0] for at in self.current_type.all_attributes() if at[0].name == node.id] + var = at[0] + except: + raise SemanticError(f"({node.line}, {node.column}) - NameError: Undeclared identifier {node.id}") + + typex = self.current_type if isinstance(var.type , SELF_TYPE) else var.type + + self.context.check_type(node.expr.type, typex, node.line) + node.type = node.expr.type + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - SemanticError: " + str(e)) + node.type = node.expr.type + + + @visitor.when(WhileNode) + def visit(self , node:WhileNode, scope:Scope): + self.visit(node.condition, scope.create_child()) + if self.context.get_type("Bool",node.line) != node.condition.type: + self.errors.append(f"({node.line},{node.column}) - TypeError: Expr should be boolean") + self.visit(node.body, scope.create_child()) + node.type = self.context.get_type("Object", node.line) + + + @visitor.when(BlockNode) + def visit (self, node:BlockNode, scope:Scope): + for expr in node.expr_list: + self.visit(expr,scope.create_child()) + node.type = node.expr_list[-1].type + + @visitor.when(SelfNode) + def visit(self, node:SelfNode, scope:Scope): + node.type = self.current_type + + @visitor.when(LetNode) + def visit(self, node:LetNode,scope:Scope): + sc = scope.create_child() + for init in node.list_decl: + if not init is None: + if(not init.expr is None): + self.visit(init.expr,sc) + try: + typex = self.context.get_type(init.expr.type.name,node.line) if init.expr.type != "SELF_TYPE" else self.current_type + typey = self.context.get_type(init.type,node.line) if init.expr.type != "SELF_TYPE" else self.current_type + self.context.check_type(typex,typey,node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - TypeError: " + str(e)) + + + sc = sc.create_child() + typex= None + try: + typex = self.context.get_type(init.type,node.line) if init.type != "SELF_TYPE" else self.current_type + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - TypeError: " + str(e)) + typex = ErrorType() + try: + if init.id == "self": + raise SemanticError('Trying to assign value to self' ,node.line) + sc.define_variable(init.id,typex,node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - SemanticError: " + str(e)) + + sc = sc.create_child() + node.body_scope=sc + self.visit(node.expr,sc) + node.type = node.expr.type + + + @visitor.when(InstantiateNode) + def visit(self, node:InstantiateNode,scope:Scope): + try: + if node.lex == "SELF_TYPE": + node.type= self.current_type + else: + node.type = self.context.get_type(node.lex,node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - TypeError: " + str(e)) + node.type = ErrorType() + + + + @visitor.when(IsVoidNode) + def visit(self, node:IsVoidNode, scope:Scope): + + self.visit(node.expr,scope.create_child()) + node.type = self.context.get_type("Bool", node.line) + + + @visitor.when(MathNode) + def visit(self, node:MathNode,scope:Scope): + self.visit(node.left,scope.create_child()) + self.visit(node.right,scope.create_child()) + if node.left.type != self.context.get_type("Int", node.line) or node.right.type != self.context.get_type("Int", node.line): + self.errors.append(f"({node.line},{node.column}) - TypeError: static types of the two sub-expressions must be Int.") + + node.type = self.context.get_type("Int", node.line) + + + + @visitor.when(MinorNode) + def visit(self, node:MinorNode,scope:Scope): + self.visit(node.left,scope.create_child()) + if node.left.type != self.context.get_type("Int", node.line): + self.errors.append(f"({node.line},{node.column}) - TypeError: Expr must be Int not " + str(node.left.type)) + self.visit(node.right,scope.create_child()) + if node.right.type != self.context.get_type("Int", node.line): + self.errors.append(f"({node.line},{node.column}) - TypeError: Expr must be Int not " + str(node.right.type)) + node.type = self.context.get_type("Bool", node.line) + + @visitor.when(MinorEqualsNode) + def visit(self, node:MinorEqualsNode, scope:Scope): + self.visit(node.left,scope.create_child()) + if node.left.type != self.context.get_type("Int", node.line): + self.errors.append(f"({node.line},{node.column}) - TypeError: Expr must be Int not " + str(node.left.type)) + self.visit(node.right,scope.create_child()) + if node.right.type != self.context.get_type("Int", node.line): + self.errors.append(f"({node.line},{node.column}) - TypeError: Expr must be Int not " + str(node.right.type)) + node.type = self.context.get_type("Bool", node.line) + + @visitor.when(EqualsNode) + def visit(self, node:EqualsNode, scope:Scope): + self.visit(node.left,scope.create_child()) + self.visit(node.right,scope.create_child()) + if node.left.type != node.right.type: + basic = ['Int', 'String', 'Bool'] + if node.left.type.name in basic or node.right.type.name in basic: + self.errors.append(f"({node.line},{node.column}) - TypeError: Ilegal comparison with a basic type") + node.type = self.context.get_type("Bool", node.line) + + @visitor.when(NhanharaNode) + def visit(self, node:NhanharaNode, scope:Scope): + self.visit(node.expr, scope.create_child()) + if node.expr.type != self.context.get_type("Int", node.line): + self.errors.append(f"({node.line},{node.column}) - TypeError: Expr must be an int not " + str(node.expr.type)) + node.type = self.context.get_type("Int", node.line) + + @visitor.when(NotNode) + def visit(self, node:NotNode, scope:Scope): + self.visit(node.expr, scope.create_child()) + if node.expr.type != self.context.get_type("Bool", node.line): + self.errors.append(f"({node.line},{node.column}) - TypeError: Expr must be Bool not " + str(node.expr.type)) + node.type = self.context.get_type("Bool", node.line) + + + @visitor.when(ConstantNumNode) + def visit (self, node:ConstantNumNode,scope:Scope): + node.type = self.context.get_type("Int", node.line) + + @visitor.when(ConstantStringNode) + def visit (self, node:ConstantStringNode, scope:Scope): + node.type = self.context.get_type("String", node.line) + + @visitor.when(ConstantBooleanNode) + def visit (self, node:ConstantBooleanNode, scope:Scope): + node.type = self.context.get_type("Bool",node.line) + + @visitor.when(VariableNode) + def visit (self, node:VariableNode,scope:Scope): + + x = scope.find_variable(node.lex) + if x is None: + try: + at = [at[0] for at in self.current_type.all_attributes() if at[0].name == node.lex] + x = at[0] + except: + node.type = ErrorType() + self.errors.append(f"({node.line}, {node.column}) - NameError: Undeclared identifier {node.lex}") + return + node.type = x.type if not isinstance(x.type , SELF_TYPE) else self.current_type + diff --git a/src/compiler_components/semantic/type_collector.py b/src/compiler_components/semantic/type_collector.py new file mode 100644 index 000000000..28f8b8ae9 --- /dev/null +++ b/src/compiler_components/semantic/type_collector.py @@ -0,0 +1,83 @@ + +import sys, os +sys.path.append('../') + +from . import visitor +from ..ast import * +import queue +from .structures import * + + +class TypeCollector(object): + def __init__(self, errors=[]): + self.context = None + self.errors = errors + + @visitor.on('node') + def visit(self, node): + pass + + @visitor.when(ProgramNode) + def visit(self, node): + self.context = Context() + classes = [] + for decl in node.declarations: + self.visit(decl) + classes.append(decl) + for dec_node in node.declarations: + try: + if dec_node.parent is not None: + if dec_node.parent in ["String","Int","Bool"]: + self.errors.append(f"({dec_node.line_father},{dec_node.column_father}) - SemanticError: Basic type as parent") + self.context.get_type(dec_node.id, dec_node.line).set_parent(self.context.get_type(dec_node.parent,dec_node.line),node.line) + except SemanticError as e: + self.errors.append(f"({dec_node.line_father},{dec_node.column_father}) - TypeError: " + str(e)) + + cycles = self.context.circular_dependency() + for cycle in cycles: + self.errors.append(f"({cycle[0][1]},{cycle[0][2]+1}) - SemanticError: Class {cycle[0][0]}, is involved in an inheritance cycle.") + return + + for decl in classes: + self.current_type = self.context.get_type(decl.id) + for feature in decl.features: + self.visit(feature) + + @visitor.when(ClassDeclarationNode) + def visit(self, node): + try: + self.current_type = self.context.create_type(node.id, node.type_line, node.type_column) + except SemanticError as e: + self.errors.append(f"({node.type_line},{node.type_column}) - SemanticError: " + str(e)) + return + + @visitor.when(AttrDeclarationNode) + def visit(self, node): + try: + attr_type = SELF_TYPE() if node.type == "SELF_TYPE" else self.context.get_type(node.type,-1) #change -1 for line number + if node.id == "self": + self.errors.append(f"({node.line},{node.column}) - SemanticError: Trying to assign value to self") + raise SemanticError('', -1) #change -1 for line number + self.current_type.define_attribute(node.id, attr_type, -1) #change -1 for line number + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - {str(e)} {node.id} already defined" ) + + @visitor.when(FuncDeclarationNode) + def visit(self, node): + arg_names = [param[0] for param in node.params] + arg_types = [] + for param in node.params: + try: + arg_types.append(self.context.get_type(param[1],node.line) ) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - TypeError: " + str(e)) + arg_types.append(ErrorType()) + try: + ret_type = SELF_TYPE() if node.type =="SELF_TYPE" else self.context.get_type(node.type,node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - TypeError: " + str(e)) + ret_type = ErrorType() + try: + self.current_type.define_method(node.id, arg_names, arg_types, ret_type, node.line) + except SemanticError as e: + self.errors.append(f"({node.line},{node.column}) - SemanticError: " + str(e)) \ No newline at end of file diff --git a/src/compiler_components/semantic/visitor.py b/src/compiler_components/semantic/visitor.py new file mode 100644 index 000000000..964842836 --- /dev/null +++ b/src/compiler_components/semantic/visitor.py @@ -0,0 +1,80 @@ +# The MIT License (MIT) +# +# Copyright (c) 2013 Curtis Schlak +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +import inspect + +__all__ = ['on', 'when'] + +def on(param_name): + def f(fn): + dispatcher = Dispatcher(param_name, fn) + return dispatcher + return f + + +def when(param_type): + def f(fn): + frame = inspect.currentframe().f_back + func_name = fn.func_name if 'func_name' in dir(fn) else fn.__name__ + dispatcher = frame.f_locals[func_name] + if not isinstance(dispatcher, Dispatcher): + dispatcher = dispatcher.dispatcher + dispatcher.add_target(param_type, fn) + def ff(*args, **kw): + return dispatcher(*args, **kw) + ff.dispatcher = dispatcher + return ff + return f + + +class Dispatcher(object): + def __init__(self, param_name, fn): + frame = inspect.currentframe().f_back.f_back + top_level = frame.f_locals == frame.f_globals + self.param_index = self.__argspec(fn).args.index(param_name) + self.param_name = param_name + self.targets = {} + + def __call__(self, *args, **kw): + typ = args[self.param_index].__class__ + d = self.targets.get(typ) + if d is not None: + return d(*args, **kw) + else: + issub = issubclass + t = self.targets + ks = t.keys() + ans = [t[k](*args, **kw) for k in ks if issub(typ, k)] + if len(ans) == 1: + return ans.pop() + return ans + + def add_target(self, typ, target): + self.targets[typ] = target + + @staticmethod + def __argspec(fn): + # Support for Python 3 type hints requires inspect.getfullargspec + if hasattr(inspect, 'getfullargspec'): + return inspect.getfullargspec(fn) + else: + return inspect.getargspec(fn) diff --git a/src/compiler_components/semantic_checker.py b/src/compiler_components/semantic_checker.py new file mode 100644 index 000000000..08868a55d --- /dev/null +++ b/src/compiler_components/semantic_checker.py @@ -0,0 +1,44 @@ +import sys +sys.path.append('./semantic') +from .semantic.type_collector import * +from .semantic.type_builder import * +from .semantic.type_checker import * +from .semantic.structures import * +from .compiler_component import CompilerComponent +from .cool_parser import Parser + + +class SemanticChecker(CompilerComponent): + def __init__(self, parser: Parser) -> None: + super().__init__() + self.parser = parser + self.context = None + self.scope = None + self.ast = None + + def execute(self): + self.errors = [] + self.ast = self.parser.ast + tcollector = TypeCollector(self.errors) + tcollector.visit(self.ast) + if(self.has_errors()): + return + self.context = tcollector.context + + tbuilder = TypeBuilder(self.context, self.errors) + + tbuilder.visit(self.ast) + if self.has_errors(): + return + + tchecking = TypeChecker(self.context,self.errors) + self.scope = Scope() + + tchecking.visit(self.ast, self.scope) + + def has_errors(self): + return len(self.errors) > 0 + + def print_errors(self): + for e in self.errors: + print(e) \ No newline at end of file diff --git a/src/compiler_components/visitor.py b/src/compiler_components/visitor.py new file mode 100644 index 000000000..964842836 --- /dev/null +++ b/src/compiler_components/visitor.py @@ -0,0 +1,80 @@ +# The MIT License (MIT) +# +# Copyright (c) 2013 Curtis Schlak +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +import inspect + +__all__ = ['on', 'when'] + +def on(param_name): + def f(fn): + dispatcher = Dispatcher(param_name, fn) + return dispatcher + return f + + +def when(param_type): + def f(fn): + frame = inspect.currentframe().f_back + func_name = fn.func_name if 'func_name' in dir(fn) else fn.__name__ + dispatcher = frame.f_locals[func_name] + if not isinstance(dispatcher, Dispatcher): + dispatcher = dispatcher.dispatcher + dispatcher.add_target(param_type, fn) + def ff(*args, **kw): + return dispatcher(*args, **kw) + ff.dispatcher = dispatcher + return ff + return f + + +class Dispatcher(object): + def __init__(self, param_name, fn): + frame = inspect.currentframe().f_back.f_back + top_level = frame.f_locals == frame.f_globals + self.param_index = self.__argspec(fn).args.index(param_name) + self.param_name = param_name + self.targets = {} + + def __call__(self, *args, **kw): + typ = args[self.param_index].__class__ + d = self.targets.get(typ) + if d is not None: + return d(*args, **kw) + else: + issub = issubclass + t = self.targets + ks = t.keys() + ans = [t[k](*args, **kw) for k in ks if issub(typ, k)] + if len(ans) == 1: + return ans.pop() + return ans + + def add_target(self, typ, target): + self.targets[typ] = target + + @staticmethod + def __argspec(fn): + # Support for Python 3 type hints requires inspect.getfullargspec + if hasattr(inspect, 'getfullargspec'): + return inspect.getfullargspec(fn) + else: + return inspect.getargspec(fn) diff --git a/src/coolc.sh b/src/coolc.sh index 3088de4f9..89bb3e933 100755 --- a/src/coolc.sh +++ b/src/coolc.sh @@ -1,11 +1,11 @@ # Incluya aquí las instrucciones necesarias para ejecutar su compilador +# Incluya aquí las instrucciones necesarias para ejecutar su compilador INPUT_FILE=$1 OUTPUT_FILE=${INPUT_FILE:0: -2}mips -# Si su compilador no lo hace ya, aquí puede imprimir la información de contacto -echo "LINEA_CON_NOMBRE_Y_VERSION_DEL_COMPILADOR" # TODO: Recuerde cambiar estas -echo "Copyright (c) 2019: Nombre1, Nombre2, Nombre3" # TODO: líneas a los valores correctos +echo "Cool Compiler v0.1" +echo "Copyright (c) 2022: Luis Lara, Carlos Arrieta" # Llamar al compilador -echo "Compiling $INPUT_FILE into $OUTPUT_FILE" +python3 main.py $INPUT_FILE diff --git a/src/main.py b/src/main.py new file mode 100644 index 000000000..9fb33aa5a --- /dev/null +++ b/src/main.py @@ -0,0 +1,42 @@ +import sys +from typing import List + +from compiler_components.compiler_component import CompilerComponent +from compiler_components.lexer import Lexer +from compiler_components.cool_parser import Parser +from compiler_components.semantic_checker import SemanticChecker +from compiler_components.code_gen import CodeGenerator + + +def execute_compiler(cool_program : str, input_file): + # Initialize compiler components + lexer = Lexer(cool_program) + cool_parser = Parser(lexer) + semantic_checker = SemanticChecker(cool_parser) + code_generator = CodeGenerator(semantic_checker) + + # Execute compiler components + compiler_components: List[CompilerComponent] = [lexer, cool_parser, semantic_checker, code_generator] + for component in compiler_components: + component.execute() + + if component.has_errors(): + component.print_errors() + return True + + open(input_file.split(".")[0] + ".mips", 'w').write(code_generator.mips_text) + + return False + + +if __name__ == '__main__': + # read input file + inputfile = sys.argv[1] + with open(inputfile, encoding="utf_8")as file: + coolprogram = file.read() + + with_errors: bool = execute_compiler(coolprogram, inputfile) + if with_errors: + exit(1) + else: + exit(0) \ No newline at end of file diff --git a/src/program.mips b/src/program.mips new file mode 100644 index 000000000..955e13cc2 --- /dev/null +++ b/src/program.mips @@ -0,0 +1,1076 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Main_name: .asciiz "Main" + Main_size: .word 16 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_pal_at_Main + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 32($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_pal_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -72 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_pal_at_Main_0 + li $t1, 1 + sw $t1, -4($fp) + j label_pal_at_Main_1 +label_pal_at_Main_0: + li $t1, 0 + sw $t1, -4($fp) +label_pal_at_Main_1: + lw $a0, -4($fp) + bne $a0, $zero, label_pal_at_Main_2 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -24($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + li $a0, 1 + sub $a0, $t1, $a0 + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_pal_at_Main_4 + li $t1, 1 + sw $t1, -20($fp) + j label_pal_at_Main_5 +label_pal_at_Main_4: + li $t1, 0 + sw $t1, -20($fp) +label_pal_at_Main_5: + lw $a0, -20($fp) + bne $a0, $zero, label_pal_at_Main_6 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 0 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -40($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -52($fp) + + #fin llamada dinamica + + lw $t1, -52($fp) + li $a0, 1 + blt $t1, $a0, label_pal_at_Main_8 + li $a0, 0 + j label_pal_at_Main_9 +label_pal_at_Main_8: + li $a0, 1 +label_pal_at_Main_9: + sw $a0, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -44($fp) + + #fin llamada dinamica + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_pal_at_Main_10 + li $t1, 0 + sw $t1, -56($fp) + j label_pal_at_Main_11 +label_pal_at_Main_10: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -72($fp) + + #fin llamada dinamica + + lw $t1, -72($fp) + li $a0, 2 + blt $t1, $a0, label_pal_at_Main_12 + li $a0, 0 + j label_pal_at_Main_13 +label_pal_at_Main_12: + li $a0, 1 +label_pal_at_Main_13: + sw $a0, -68($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -64($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -60($fp) + lw $t1, -60($fp) + sw $t1, -56($fp) +label_pal_at_Main_11: + lw $t1, -56($fp) + sw $t1, -32($fp) + j label_pal_at_Main_7 +label_pal_at_Main_6: + li $t1, 1 + sw $t1, -32($fp) +label_pal_at_Main_7: + lw $t1, -32($fp) + sw $t1, -16($fp) + j label_pal_at_Main_3 +label_pal_at_Main_2: + li $t1, 1 + sw $t1, -16($fp) +label_pal_at_Main_3: + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 88 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + li $t1, 1 + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -4($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -4($fp) + sw $t1, 12($a0) + + #end set attribute + + la $t1, data_1 + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_main_at_Main_0 + la $t1, data_1 + sw $t1, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + lw $t1, -28($fp) + sw $t1, -24($fp) + j label_main_at_Main_1 +label_main_at_Main_0: + la $t1, data_1 + sw $t1, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -24($fp) +label_main_at_Main_1: + + #retornando el valor + + lw $a0, -24($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 52 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/src/program.txt b/src/program.txt new file mode 100644 index 000000000..7f24789f9 --- /dev/null +++ b/src/program.txt @@ -0,0 +1,25 @@ +class Main inherits IO { + pal(s : String) : Bool { + if s.length() = 0 + then true + else if s.length() = 1 + then true + else if s.substr(0, 1) = s.substr(s.length() - 1, 1) + then pal(s.substr(1, s.length() -2)) + else false + fi fi fi + }; + + i : Int; + + main() : IO { + { + i <- ~1; + out_string("enter a string\n"); + if pal(in_string()) + then out_string("that was a palindrome\n") + else out_string("that was not a palindrome\n") + fi; + } + }; +}; diff --git a/tests/codegen/arith.mips b/tests/codegen/arith.mips new file mode 100644 index 000000000..ade506513 --- /dev/null +++ b/tests/codegen/arith.mips @@ -0,0 +1,7059 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + A_name: .asciiz "A" + A_size: .word 16 +__virtual_table__A: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_value_at_A + .word function_set_var_at_A + .word function_method1_at_A + .word function_method2_at_A + .word function_method3_at_A + .word function_method4_at_A + .word function_method5_at_A + B_name: .asciiz "B" + B_size: .word 16 +__virtual_table__B: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_value_at_A + .word function_set_var_at_A + .word function_method1_at_A + .word function_method2_at_A + .word function_method3_at_A + .word function_method4_at_A + .word function_method5_at_B + C_name: .asciiz "C" + C_size: .word 16 +__virtual_table__C: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_value_at_A + .word function_set_var_at_A + .word function_method1_at_A + .word function_method2_at_A + .word function_method3_at_A + .word function_method4_at_A + .word function_method5_at_C + .word function_method6_at_C + D_name: .asciiz "D" + D_size: .word 16 +__virtual_table__D: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_value_at_A + .word function_set_var_at_A + .word function_method1_at_A + .word function_method2_at_A + .word function_method3_at_A + .word function_method4_at_A + .word function_method5_at_B + .word function_method7_at_D + E_name: .asciiz "E" + E_size: .word 16 +__virtual_table__E: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_value_at_A + .word function_set_var_at_A + .word function_method1_at_A + .word function_method2_at_A + .word function_method3_at_A + .word function_method4_at_A + .word function_method5_at_B + .word function_method7_at_D + .word function_method6_at_E + A2I_name: .asciiz "A2I" + A2I_size: .word 12 +__virtual_table__A2I: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_c2i_at_A2I + .word function_i2c_at_A2I + .word function_a2i_at_A2I + .word function_a2i_aux_at_A2I + .word function_i2a_at_A2I + .word function_i2a_aux_at_A2I + Main_name: .asciiz "Main" + Main_size: .word 28 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_menu_at_Main + .word function_prompt_at_Main + .word function_get_int_at_Main + .word function_is_even_at_Main + .word function_class_type_at_Main + .word function_print_at_Main + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n " + data_2: .asciiz "n" + data_3: .asciiz " " + data_4: .asciiz " n" + data_5: .asciiz " nn" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 52($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_value_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_set_var_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_method1_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_method2_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + li $t1, 0 + sw $t1, -4($fp) + lw $t1, 8($fp) + lw $a0, 12($fp) + add $a0, $a0, $t1 + sw $a0, -8($fp) + lw $t1, -8($fp) + sw $t1, -4($fp) + + #init allocate + + li $v0, 9 + lw $a0, B_size + syscall + sw $v0, -16($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_B + sw $a0, -20($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 40 + lw $fp, 0($sp) + jr $ra +function_method3_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + li $t1, 0 + sw $t1, -4($fp) + lw $t1, 8($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -8($fp) + lw $t1, -8($fp) + sw $t1, -4($fp) + + #init allocate + + li $v0, 9 + lw $a0, C_size + syscall + sw $v0, -16($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_C + sw $a0, -20($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 36 + lw $fp, 0($sp) + jr $ra +function_method4_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -44 + li $a0, [] + bne $a0, $zero, label_method4_at_A_0 + li $t1, 0 + sw $t1, -8($fp) + lw $t1, 12($fp) + lw $a0, 8($fp) + blt $t1, $a0, label_method4_at_A_2 + li $a0, 0 + j label_method4_at_A_3 +label_method4_at_A_2: + li $a0, 1 +label_method4_at_A_3: + sw $a0, -12($fp) + lw $t1, -12($fp) + sw $t1, -8($fp) + + #init allocate + + li $v0, 9 + lw $a0, D_size + syscall + sw $v0, -20($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_D + sw $a0, -24($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -20($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + lw $t1, -16($fp) + sw $t1, -4($fp) + j label_method4_at_A_1 +label_method4_at_A_0: + li $t1, 0 + sw $t1, -28($fp) + lw $t1, 8($fp) + lw $a0, 12($fp) + blt $t1, $a0, label_method4_at_A_4 + li $a0, 0 + j label_method4_at_A_5 +label_method4_at_A_4: + li $a0, 1 +label_method4_at_A_5: + sw $a0, -32($fp) + lw $t1, -32($fp) + sw $t1, -28($fp) + + #init allocate + + li $v0, 9 + lw $a0, D_size + syscall + sw $v0, -40($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_D + sw $a0, -44($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -40($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -36($fp) + + #fin llamada dinamica + + lw $t1, -36($fp) + sw $t1, -4($fp) +label_method4_at_A_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 64 + lw $fp, 0($sp) + jr $ra +function_method5_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -36 + li $t1, 1 + sw $t1, -4($fp) + li $t1, 1 + sw $t1, -8($fp) +label_method5_at_A_0: + li $t1, y + lw $a0, 8($fp) + ble $t1, $a0, label_method5_at_A_3 + li $a0, 0 + j label_method5_at_A_4 +label_method5_at_A_3: + li $a0, 1 +label_method5_at_A_4: + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_method5_at_A_1 + j label_method5_at_A_2 +label_method5_at_A_1: + li $t1, x + li $a0, y + mul $a0 $t1 $a0 + sw $a0, -16($fp) + lw $t1, -16($fp) + sw $t1, -4($fp) + li $t1, y + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -20($fp) + lw $t1, -20($fp) + sw $t1, -8($fp) + j label_method5_at_A_0 +label_method5_at_A_2: + la $t1, _void + sw $t1, -24($fp) + + #init allocate + + li $v0, 9 + lw $a0, E_size + syscall + sw $v0, -32($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_E + sw $a0, -36($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -32($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -28($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -28($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 52 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, A_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, A_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__A + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_A + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 0 + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_method5_at_B: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + li $t1, 0 + sw $t1, -4($fp) + lw $t1, 8($fp) + lw $a0, 8($fp) + mul $a0 $t1 $a0 + sw $a0, -8($fp) + lw $t1, -8($fp) + sw $t1, -4($fp) + + #init allocate + + li $v0, 9 + lw $a0, E_size + syscall + sw $v0, -16($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_E + sw $a0, -20($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 36 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_B: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, B_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, B_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__B + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_B + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_B: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_A + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_method6_at_C: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + li $t1, 0 + sw $t1, -4($fp) + lw $t1, 8($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -8($fp) + lw $t1, -8($fp) + sw $t1, -4($fp) + + #init allocate + + li $v0, 9 + lw $a0, A_size + syscall + sw $v0, -16($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A + sw $a0, -20($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 36 + lw $fp, 0($sp) + jr $ra +function_method5_at_C: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -24 + li $t1, 0 + sw $t1, -4($fp) + lw $t1, 8($fp) + lw $a0, 8($fp) + mul $a0 $t1 $a0 + sw $a0, -12($fp) + lw $t1, -12($fp) + lw $a0, 8($fp) + mul $a0 $t1 $a0 + sw $a0, -8($fp) + lw $t1, -8($fp) + sw $t1, -4($fp) + + #init allocate + + li $v0, 9 + lw $a0, E_size + syscall + sw $v0, -20($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_E + sw $a0, -24($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -20($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 40 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_C: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, C_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, C_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__C + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_C + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_C: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_B + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_method7_at_D: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -60 + lw $t1, 8($fp) + sw $t1, -4($fp) + li $a0, [] + bne $a0, $zero, label_method7_at_D_0 + li $t1, 0 + li $a0, x + sub $a0, $t1, $a0 + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_method7_at_D_2 + li $t1, 1 + sw $t1, -12($fp) + j label_method7_at_D_3 +label_method7_at_D_2: + li $t1, 0 + sw $t1, -12($fp) +label_method7_at_D_3: + lw $a0, -12($fp) + bne $a0, $zero, label_method7_at_D_4 + li $t1, 1 + li $a0, x + sub $a0, $t1, $a0 + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_method7_at_D_6 + li $t1, 1 + sw $t1, -24($fp) + j label_method7_at_D_7 +label_method7_at_D_6: + li $t1, 0 + sw $t1, -24($fp) +label_method7_at_D_7: + lw $a0, -24($fp) + bne $a0, $zero, label_method7_at_D_8 + li $t1, 2 + li $a0, x + sub $a0, $t1, $a0 + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_method7_at_D_10 + li $t1, 1 + sw $t1, -36($fp) + j label_method7_at_D_11 +label_method7_at_D_10: + li $t1, 0 + sw $t1, -36($fp) +label_method7_at_D_11: + lw $a0, -36($fp) + bne $a0, $zero, label_method7_at_D_12 + li $t1, x + li $a0, 3 + blt $t1, $a0, label_method7_at_D_14 + li $a0, 0 + j label_method7_at_D_15 +label_method7_at_D_14: + li $a0, 1 +label_method7_at_D_15: + sw $a0, -52($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -52($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -48($fp) + lw $t1, -48($fp) + sw $t1, -44($fp) + j label_method7_at_D_13 +label_method7_at_D_12: + li $t1, 0 + sw $t1, -44($fp) +label_method7_at_D_13: + lw $t1, -44($fp) + sw $t1, -32($fp) + j label_method7_at_D_9 +label_method7_at_D_8: + li $t1, 0 + sw $t1, -32($fp) +label_method7_at_D_9: + lw $t1, -32($fp) + sw $t1, -20($fp) + j label_method7_at_D_5 +label_method7_at_D_4: + li $t1, 1 + sw $t1, -20($fp) +label_method7_at_D_5: + lw $t1, -20($fp) + sw $t1, -8($fp) + j label_method7_at_D_1 +label_method7_at_D_0: + li $t1, x + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -60($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -56($fp) + lw $t1, -56($fp) + sw $t1, -8($fp) +label_method7_at_D_1: + + #retornando el valor + + lw $a0, -8($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 76 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_D: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, D_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, D_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__D + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_D + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_D: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_B + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_method6_at_E: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + li $t1, 0 + sw $t1, -4($fp) + lw $t1, 8($fp) + li $a0, 8 + div $a0, $t1, $a0 + sw $a0, -8($fp) + lw $t1, -8($fp) + sw $t1, -4($fp) + + #init allocate + + li $v0, 9 + lw $a0, A_size + syscall + sw $v0, -16($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A + sw $a0, -20($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 36 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_E: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, E_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, E_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__E + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_E + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_E: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_D + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_c2i_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -124 + la $t1, _empty + sw $t1, -8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -4($fp) + lw $a0, -4($fp) + bne $a0, $zero, label_c2i_at_A2I_0 + la $t1, _empty + sw $t1, -20($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_c2i_at_A2I_2 + la $t1, _empty + sw $t1, -32($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_c2i_at_A2I_4 + la $t1, _empty + sw $t1, -44($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_c2i_at_A2I_6 + la $t1, _empty + sw $t1, -56($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -52($fp) + lw $a0, -52($fp) + bne $a0, $zero, label_c2i_at_A2I_8 + la $t1, _empty + sw $t1, -68($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -64($fp) + lw $a0, -64($fp) + bne $a0, $zero, label_c2i_at_A2I_10 + la $t1, _empty + sw $t1, -80($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -76($fp) + lw $a0, -76($fp) + bne $a0, $zero, label_c2i_at_A2I_12 + la $t1, _empty + sw $t1, -92($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -92($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -88($fp) + lw $a0, -88($fp) + bne $a0, $zero, label_c2i_at_A2I_14 + la $t1, _empty + sw $t1, -104($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -104($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -100($fp) + lw $a0, -100($fp) + bne $a0, $zero, label_c2i_at_A2I_16 + la $t1, _empty + sw $t1, -116($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -116($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -112($fp) + lw $a0, -112($fp) + bne $a0, $zero, label_c2i_at_A2I_18 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -124($fp) + li $t1, 0 + sw $t1, -120($fp) + j label_c2i_at_A2I_19 +label_c2i_at_A2I_18: + li $t1, 9 + sw $t1, -120($fp) +label_c2i_at_A2I_19: + lw $t1, -120($fp) + sw $t1, -108($fp) + j label_c2i_at_A2I_17 +label_c2i_at_A2I_16: + li $t1, 8 + sw $t1, -108($fp) +label_c2i_at_A2I_17: + lw $t1, -108($fp) + sw $t1, -96($fp) + j label_c2i_at_A2I_15 +label_c2i_at_A2I_14: + li $t1, 7 + sw $t1, -96($fp) +label_c2i_at_A2I_15: + lw $t1, -96($fp) + sw $t1, -84($fp) + j label_c2i_at_A2I_13 +label_c2i_at_A2I_12: + li $t1, 6 + sw $t1, -84($fp) +label_c2i_at_A2I_13: + lw $t1, -84($fp) + sw $t1, -72($fp) + j label_c2i_at_A2I_11 +label_c2i_at_A2I_10: + li $t1, 5 + sw $t1, -72($fp) +label_c2i_at_A2I_11: + lw $t1, -72($fp) + sw $t1, -60($fp) + j label_c2i_at_A2I_9 +label_c2i_at_A2I_8: + li $t1, 4 + sw $t1, -60($fp) +label_c2i_at_A2I_9: + lw $t1, -60($fp) + sw $t1, -48($fp) + j label_c2i_at_A2I_7 +label_c2i_at_A2I_6: + li $t1, 3 + sw $t1, -48($fp) +label_c2i_at_A2I_7: + lw $t1, -48($fp) + sw $t1, -36($fp) + j label_c2i_at_A2I_5 +label_c2i_at_A2I_4: + li $t1, 2 + sw $t1, -36($fp) +label_c2i_at_A2I_5: + lw $t1, -36($fp) + sw $t1, -24($fp) + j label_c2i_at_A2I_3 +label_c2i_at_A2I_2: + li $t1, 1 + sw $t1, -24($fp) +label_c2i_at_A2I_3: + lw $t1, -24($fp) + sw $t1, -12($fp) + j label_c2i_at_A2I_1 +label_c2i_at_A2I_0: + li $t1, 0 + sw $t1, -12($fp) +label_c2i_at_A2I_1: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 140 + lw $fp, 0($sp) + jr $ra +function_i2c_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -168 + lw $t1, 8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -8($fp) + lw $a0, -8($fp) + bne $a0, $zero, label_i2c_at_A2I_0 + li $t1, 1 + sw $t1, -4($fp) + j label_i2c_at_A2I_1 +label_i2c_at_A2I_0: + li $t1, 0 + sw $t1, -4($fp) +label_i2c_at_A2I_1: + lw $a0, -4($fp) + bne $a0, $zero, label_i2c_at_A2I_2 + lw $t1, 8($fp) + li $a0, 1 + sub $a0, $t1, $a0 + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_i2c_at_A2I_4 + li $t1, 1 + sw $t1, -16($fp) + j label_i2c_at_A2I_5 +label_i2c_at_A2I_4: + li $t1, 0 + sw $t1, -16($fp) +label_i2c_at_A2I_5: + lw $a0, -16($fp) + bne $a0, $zero, label_i2c_at_A2I_6 + lw $t1, 8($fp) + li $a0, 2 + sub $a0, $t1, $a0 + sw $a0, -32($fp) + lw $a0, -32($fp) + bne $a0, $zero, label_i2c_at_A2I_8 + li $t1, 1 + sw $t1, -28($fp) + j label_i2c_at_A2I_9 +label_i2c_at_A2I_8: + li $t1, 0 + sw $t1, -28($fp) +label_i2c_at_A2I_9: + lw $a0, -28($fp) + bne $a0, $zero, label_i2c_at_A2I_10 + lw $t1, 8($fp) + li $a0, 3 + sub $a0, $t1, $a0 + sw $a0, -44($fp) + lw $a0, -44($fp) + bne $a0, $zero, label_i2c_at_A2I_12 + li $t1, 1 + sw $t1, -40($fp) + j label_i2c_at_A2I_13 +label_i2c_at_A2I_12: + li $t1, 0 + sw $t1, -40($fp) +label_i2c_at_A2I_13: + lw $a0, -40($fp) + bne $a0, $zero, label_i2c_at_A2I_14 + lw $t1, 8($fp) + li $a0, 4 + sub $a0, $t1, $a0 + sw $a0, -56($fp) + lw $a0, -56($fp) + bne $a0, $zero, label_i2c_at_A2I_16 + li $t1, 1 + sw $t1, -52($fp) + j label_i2c_at_A2I_17 +label_i2c_at_A2I_16: + li $t1, 0 + sw $t1, -52($fp) +label_i2c_at_A2I_17: + lw $a0, -52($fp) + bne $a0, $zero, label_i2c_at_A2I_18 + lw $t1, 8($fp) + li $a0, 5 + sub $a0, $t1, $a0 + sw $a0, -68($fp) + lw $a0, -68($fp) + bne $a0, $zero, label_i2c_at_A2I_20 + li $t1, 1 + sw $t1, -64($fp) + j label_i2c_at_A2I_21 +label_i2c_at_A2I_20: + li $t1, 0 + sw $t1, -64($fp) +label_i2c_at_A2I_21: + lw $a0, -64($fp) + bne $a0, $zero, label_i2c_at_A2I_22 + lw $t1, 8($fp) + li $a0, 6 + sub $a0, $t1, $a0 + sw $a0, -80($fp) + lw $a0, -80($fp) + bne $a0, $zero, label_i2c_at_A2I_24 + li $t1, 1 + sw $t1, -76($fp) + j label_i2c_at_A2I_25 +label_i2c_at_A2I_24: + li $t1, 0 + sw $t1, -76($fp) +label_i2c_at_A2I_25: + lw $a0, -76($fp) + bne $a0, $zero, label_i2c_at_A2I_26 + lw $t1, 8($fp) + li $a0, 7 + sub $a0, $t1, $a0 + sw $a0, -92($fp) + lw $a0, -92($fp) + bne $a0, $zero, label_i2c_at_A2I_28 + li $t1, 1 + sw $t1, -88($fp) + j label_i2c_at_A2I_29 +label_i2c_at_A2I_28: + li $t1, 0 + sw $t1, -88($fp) +label_i2c_at_A2I_29: + lw $a0, -88($fp) + bne $a0, $zero, label_i2c_at_A2I_30 + lw $t1, 8($fp) + li $a0, 8 + sub $a0, $t1, $a0 + sw $a0, -104($fp) + lw $a0, -104($fp) + bne $a0, $zero, label_i2c_at_A2I_32 + li $t1, 1 + sw $t1, -100($fp) + j label_i2c_at_A2I_33 +label_i2c_at_A2I_32: + li $t1, 0 + sw $t1, -100($fp) +label_i2c_at_A2I_33: + lw $a0, -100($fp) + bne $a0, $zero, label_i2c_at_A2I_34 + lw $t1, 8($fp) + li $a0, 9 + sub $a0, $t1, $a0 + sw $a0, -116($fp) + lw $a0, -116($fp) + bne $a0, $zero, label_i2c_at_A2I_36 + li $t1, 1 + sw $t1, -112($fp) + j label_i2c_at_A2I_37 +label_i2c_at_A2I_36: + li $t1, 0 + sw $t1, -112($fp) +label_i2c_at_A2I_37: + lw $a0, -112($fp) + bne $a0, $zero, label_i2c_at_A2I_38 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -124($fp) + la $t1, _empty + sw $t1, -128($fp) + lw $t1, -128($fp) + sw $t1, -120($fp) + j label_i2c_at_A2I_39 +label_i2c_at_A2I_38: + la $t1, _empty + sw $t1, -132($fp) + lw $t1, -132($fp) + sw $t1, -120($fp) +label_i2c_at_A2I_39: + lw $t1, -120($fp) + sw $t1, -108($fp) + j label_i2c_at_A2I_35 +label_i2c_at_A2I_34: + la $t1, _empty + sw $t1, -136($fp) + lw $t1, -136($fp) + sw $t1, -108($fp) +label_i2c_at_A2I_35: + lw $t1, -108($fp) + sw $t1, -96($fp) + j label_i2c_at_A2I_31 +label_i2c_at_A2I_30: + la $t1, _empty + sw $t1, -140($fp) + lw $t1, -140($fp) + sw $t1, -96($fp) +label_i2c_at_A2I_31: + lw $t1, -96($fp) + sw $t1, -84($fp) + j label_i2c_at_A2I_27 +label_i2c_at_A2I_26: + la $t1, _empty + sw $t1, -144($fp) + lw $t1, -144($fp) + sw $t1, -84($fp) +label_i2c_at_A2I_27: + lw $t1, -84($fp) + sw $t1, -72($fp) + j label_i2c_at_A2I_23 +label_i2c_at_A2I_22: + la $t1, _empty + sw $t1, -148($fp) + lw $t1, -148($fp) + sw $t1, -72($fp) +label_i2c_at_A2I_23: + lw $t1, -72($fp) + sw $t1, -60($fp) + j label_i2c_at_A2I_19 +label_i2c_at_A2I_18: + la $t1, _empty + sw $t1, -152($fp) + lw $t1, -152($fp) + sw $t1, -60($fp) +label_i2c_at_A2I_19: + lw $t1, -60($fp) + sw $t1, -48($fp) + j label_i2c_at_A2I_15 +label_i2c_at_A2I_14: + la $t1, _empty + sw $t1, -156($fp) + lw $t1, -156($fp) + sw $t1, -48($fp) +label_i2c_at_A2I_15: + lw $t1, -48($fp) + sw $t1, -36($fp) + j label_i2c_at_A2I_11 +label_i2c_at_A2I_10: + la $t1, _empty + sw $t1, -160($fp) + lw $t1, -160($fp) + sw $t1, -36($fp) +label_i2c_at_A2I_11: + lw $t1, -36($fp) + sw $t1, -24($fp) + j label_i2c_at_A2I_7 +label_i2c_at_A2I_6: + la $t1, _empty + sw $t1, -164($fp) + lw $t1, -164($fp) + sw $t1, -24($fp) +label_i2c_at_A2I_7: + lw $t1, -24($fp) + sw $t1, -12($fp) + j label_i2c_at_A2I_3 +label_i2c_at_A2I_2: + la $t1, _empty + sw $t1, -168($fp) + lw $t1, -168($fp) + sw $t1, -12($fp) +label_i2c_at_A2I_3: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 184 + lw $fp, 0($sp) + jr $ra +function_a2i_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -88 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_a2i_at_A2I_0 + li $t1, 1 + sw $t1, -4($fp) + j label_a2i_at_A2I_1 +label_a2i_at_A2I_0: + li $t1, 0 + sw $t1, -4($fp) +label_a2i_at_A2I_1: + lw $a0, -4($fp) + bne $a0, $zero, label_a2i_at_A2I_2 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 0 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -24($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -28($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_a2i_at_A2I_4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 0 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -40($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -44($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_a2i_at_A2I_6 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -52($fp) + lw $t1, -52($fp) + sw $t1, -48($fp) + j label_a2i_at_A2I_7 +label_a2i_at_A2I_6: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -68($fp) + + #fin llamada dinamica + + lw $t1, -68($fp) + li $a0, 1 + blt $t1, $a0, label_a2i_at_A2I_8 + li $a0, 0 + j label_a2i_at_A2I_9 +label_a2i_at_A2I_8: + li $a0, 1 +label_a2i_at_A2I_9: + sw $a0, -64($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -60($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -56($fp) + lw $t1, -56($fp) + sw $t1, -48($fp) +label_a2i_at_A2I_7: + lw $t1, -48($fp) + sw $t1, -32($fp) + j label_a2i_at_A2I_5 +label_a2i_at_A2I_4: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -88($fp) + + #fin llamada dinamica + + lw $t1, -88($fp) + li $a0, 1 + blt $t1, $a0, label_a2i_at_A2I_10 + li $a0, 0 + j label_a2i_at_A2I_11 +label_a2i_at_A2I_10: + li $a0, 1 +label_a2i_at_A2I_11: + sw $a0, -84($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -84($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -80($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -76($fp) + lw $t1, -76($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -72($fp) + lw $t1, -72($fp) + sw $t1, -32($fp) +label_a2i_at_A2I_5: + lw $t1, -32($fp) + sw $t1, -16($fp) + j label_a2i_at_A2I_3 +label_a2i_at_A2I_2: + li $t1, 0 + sw $t1, -16($fp) +label_a2i_at_A2I_3: + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 104 + lw $fp, 0($sp) + jr $ra +function_a2i_aux_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + li $t1, 0 + sw $t1, -4($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + sw $t1, -12($fp) + li $t1, 0 + sw $t1, -16($fp) +label_a2i_aux_at_A2I_0: + li $a0, [] + bne $a0, $zero, label_a2i_aux_at_A2I_1 + j label_a2i_aux_at_A2I_2 +label_a2i_aux_at_A2I_1: + li $t1, int + li $a0, 10 + mul $a0 $t1 $a0 + sw $a0, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, i + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -32($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + lw $t1, -24($fp) + lw $a0, -28($fp) + add $a0, $a0, $t1 + sw $a0, -20($fp) + lw $t1, -20($fp) + sw $t1, -4($fp) + li $t1, i + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -16($fp) + j label_a2i_aux_at_A2I_0 +label_a2i_aux_at_A2I_2: + la $t1, _void + sw $t1, -40($fp) + + #retornando el valor + + li $a0, int + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 56 + lw $fp, 0($sp) + jr $ra +function_i2a_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -44 + lw $t1, 8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -8($fp) + lw $a0, -8($fp) + bne $a0, $zero, label_i2a_at_A2I_0 + li $t1, 1 + sw $t1, -4($fp) + j label_i2a_at_A2I_1 +label_i2a_at_A2I_0: + li $t1, 0 + sw $t1, -4($fp) +label_i2a_at_A2I_1: + lw $a0, -4($fp) + bne $a0, $zero, label_i2a_at_A2I_2 + li $a0, [] + bne $a0, $zero, label_i2a_at_A2I_4 + la $t1, _empty + sw $t1, -24($fp) + li $t1, 1 + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -36($fp) + lw $t1, 8($fp) + lw $a0, -36($fp) + mul $a0 $t1 $a0 + sw $a0, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_concat_at_String + sw $a0, -20($fp) + + #fin llamada dinamica + + lw $t1, -20($fp) + sw $t1, -16($fp) + j label_i2a_at_A2I_5 +label_i2a_at_A2I_4: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -40($fp) + lw $t1, -40($fp) + sw $t1, -16($fp) +label_i2a_at_A2I_5: + lw $t1, -16($fp) + sw $t1, -12($fp) + j label_i2a_at_A2I_3 +label_i2a_at_A2I_2: + la $t1, _empty + sw $t1, -44($fp) + lw $t1, -44($fp) + sw $t1, -12($fp) +label_i2a_at_A2I_3: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_i2a_aux_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -44 + lw $t1, 8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -8($fp) + lw $a0, -8($fp) + bne $a0, $zero, label_i2a_aux_at_A2I_0 + li $t1, 1 + sw $t1, -4($fp) + j label_i2a_aux_at_A2I_1 +label_i2a_aux_at_A2I_0: + li $t1, 0 + sw $t1, -4($fp) +label_i2a_aux_at_A2I_1: + lw $a0, -4($fp) + bne $a0, $zero, label_i2a_aux_at_A2I_2 + lw $t1, 8($fp) + li $a0, 10 + div $a0, $t1, $a0 + sw $a0, -16($fp) + lw $t1, -16($fp) + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, next + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -28($fp) + li $t1, next + li $a0, 10 + mul $a0 $t1 $a0 + sw $a0, -40($fp) + lw $t1, 8($fp) + lw $a0, -40($fp) + blt $t1, $a0, label_i2a_aux_at_A2I_4 + li $a0, 0 + j label_i2a_aux_at_A2I_5 +label_i2a_aux_at_A2I_4: + li $a0, 1 +label_i2a_aux_at_A2I_5: + sw $a0, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_concat_at_String + sw $a0, -24($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + sw $t1, -12($fp) + j label_i2a_aux_at_A2I_3 +label_i2a_aux_at_A2I_2: + la $t1, _empty + sw $t1, -44($fp) + lw $t1, -44($fp) + sw $t1, -12($fp) +label_i2a_aux_at_A2I_3: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, A2I_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, A2I_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__A2I + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_A2I + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_menu_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -212 + la $t1, data_1 + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -12($fp) + la $t1, data_2 + sw $t1, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -20($fp) + la $t1, data_3 + sw $t1, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -36($fp) + la $t1, data_2 + sw $t1, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -44($fp) + la $t1, data_3 + sw $t1, -56($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -52($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -64($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -60($fp) + la $t1, data_2 + sw $t1, -72($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -72($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -68($fp) + la $t1, data_3 + sw $t1, -80($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -76($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -88($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -88($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -84($fp) + la $t1, data_2 + sw $t1, -96($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -96($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -92($fp) + la $t1, data_3 + sw $t1, -104($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -104($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -100($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -112($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -112($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -108($fp) + la $t1, data_2 + sw $t1, -120($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -120($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -116($fp) + la $t1, data_3 + sw $t1, -128($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -128($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -124($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -136($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -136($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -132($fp) + la $t1, data_2 + sw $t1, -144($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -144($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -140($fp) + la $t1, data_3 + sw $t1, -152($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -152($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -148($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -160($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -160($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -156($fp) + la $t1, data_2 + sw $t1, -168($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -168($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -164($fp) + la $t1, data_3 + sw $t1, -176($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -176($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -172($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -184($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -184($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -180($fp) + la $t1, data_2 + sw $t1, -192($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -192($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -188($fp) + la $t1, data_4 + sw $t1, -200($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -200($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -196($fp) + la $t1, data_5 + sw $t1, -208($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -208($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -204($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -212($fp) + + #retornando el valor + + lw $a0, -212($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 224 + lw $fp, 0($sp) + jr $ra +function_prompt_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + la $t1, data_2 + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + la $t1, _empty + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -20($fp) + + #retornando el valor + + lw $a0, -20($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 32 + lw $fp, 0($sp) + jr $ra +function_get_int_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -24 + + #init allocate + + li $v0, 9 + lw $a0, A2I_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A2I + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -16($fp) + lw $t1, -16($fp) + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, s + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, z + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 20($a0) + jalr $a0 + sw $a0, -24($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -24($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 36 + lw $fp, 0($sp) + jr $ra +function_is_even_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + lw $t1, 8($fp) + sw $t1, -4($fp) + li $a0, [] + bne $a0, $zero, label_is_even_at_Main_0 + li $t1, 0 + li $a0, x + sub $a0, $t1, $a0 + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_is_even_at_Main_2 + li $t1, 1 + sw $t1, -12($fp) + j label_is_even_at_Main_3 +label_is_even_at_Main_2: + li $t1, 0 + sw $t1, -12($fp) +label_is_even_at_Main_3: + lw $a0, -12($fp) + bne $a0, $zero, label_is_even_at_Main_4 + li $t1, 1 + li $a0, x + sub $a0, $t1, $a0 + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_is_even_at_Main_6 + li $t1, 1 + sw $t1, -24($fp) + j label_is_even_at_Main_7 +label_is_even_at_Main_6: + li $t1, 0 + sw $t1, -24($fp) +label_is_even_at_Main_7: + lw $a0, -24($fp) + bne $a0, $zero, label_is_even_at_Main_8 + li $t1, x + li $a0, 2 + blt $t1, $a0, label_is_even_at_Main_10 + li $a0, 0 + j label_is_even_at_Main_11 +label_is_even_at_Main_10: + li $a0, 1 +label_is_even_at_Main_11: + sw $a0, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -32($fp) + j label_is_even_at_Main_9 +label_is_even_at_Main_8: + li $t1, 0 + sw $t1, -32($fp) +label_is_even_at_Main_9: + lw $t1, -32($fp) + sw $t1, -20($fp) + j label_is_even_at_Main_5 +label_is_even_at_Main_4: + li $t1, 1 + sw $t1, -20($fp) +label_is_even_at_Main_5: + lw $t1, -20($fp) + sw $t1, -8($fp) + j label_is_even_at_Main_1 +label_is_even_at_Main_0: + li $t1, x + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -44($fp) + lw $t1, -44($fp) + sw $t1, -8($fp) +label_is_even_at_Main_1: + + #retornando el valor + + lw $a0, -8($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 64 + lw $fp, 0($sp) + jr $ra +function_class_type_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -80 + lw $t1, 8($fp) + sw $t1, -8($fp) + la $a0, E_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_0 + la $a0, D_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_1 + la $a0, C_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_2 + la $a0, B_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_3 + la $a0, A_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_4 + la $a0, Bool_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_5 + la $a0, Int_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_5 + la $a0, String_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_5 + la $a0, Main_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_5 + la $a0, IO_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_5 + la $a0, A2I_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_5 + la $a0, Object_name + lw $t1, 8($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_class_type_at_Main_5 +label_class_type_at_Main_4: + lw $t1, 8($fp) + sw $t1, -12($fp) + la $t1, data_2 + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -16($fp) + lw $t1, -16($fp) + sw $t1, -4($fp) + j label_class_type_at_Main_6 +label_class_type_at_Main_3: + lw $t1, 8($fp) + sw $t1, -24($fp) + la $t1, data_2 + sw $t1, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + lw $t1, -28($fp) + sw $t1, -4($fp) + j label_class_type_at_Main_6 +label_class_type_at_Main_2: + lw $t1, 8($fp) + sw $t1, -36($fp) + la $t1, data_2 + sw $t1, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -40($fp) + lw $t1, -40($fp) + sw $t1, -4($fp) + j label_class_type_at_Main_6 +label_class_type_at_Main_1: + lw $t1, 8($fp) + sw $t1, -48($fp) + la $t1, data_2 + sw $t1, -56($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -52($fp) + lw $t1, -52($fp) + sw $t1, -4($fp) + j label_class_type_at_Main_6 +label_class_type_at_Main_0: + lw $t1, 8($fp) + sw $t1, -60($fp) + la $t1, data_2 + sw $t1, -68($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -64($fp) + lw $t1, -64($fp) + sw $t1, -4($fp) + j label_class_type_at_Main_6 +label_class_type_at_Main_5: + lw $t1, 8($fp) + sw $t1, -72($fp) + la $t1, data_2 + sw $t1, -80($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -76($fp) + lw $t1, -76($fp) + sw $t1, -4($fp) + j label_class_type_at_Main_6 +label_class_type_at_Main_6: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 96 + lw $fp, 0($sp) + jr $ra +function_print_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -32 + + #init allocate + + li $v0, 9 + lw $a0, A2I_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A2I + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, 8($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -24($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, z + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -20($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -16($fp) + la $t1, _empty + sw $t1, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + + #retornando el valor + + lw $a0, -28($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 48 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -652 + + #init allocate + + li $v0, 9 + lw $a0, A_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A + sw $a0, -8($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -4($fp) + sw $t1, 16($a0) + + #end set attribute + +label_main_at_Main_0: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 24($a0) + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_main_at_Main_1 + j label_main_at_Main_2 +label_main_at_Main_1: + la $t1, _empty + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -16($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -24($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -40($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -36($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -32($fp) + lw $a0, -32($fp) + bne $a0, $zero, label_main_at_Main_3 + la $t1, data_2 + sw $t1, -52($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -52($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -48($fp) + lw $t1, -48($fp) + sw $t1, -44($fp) + j label_main_at_Main_4 +label_main_at_Main_3: + la $t1, data_2 + sw $t1, -60($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -56($fp) + lw $t1, -56($fp) + sw $t1, -44($fp) +label_main_at_Main_4: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -68($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -64($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -72($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -72($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -80($fp) + la $t1, _empty + sw $t1, -84($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -84($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -76($fp) + lw $a0, -76($fp) + bne $a0, $zero, label_main_at_Main_5 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -96($fp) + la $t1, _empty + sw $t1, -100($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -96($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -100($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -92($fp) + lw $a0, -92($fp) + bne $a0, $zero, label_main_at_Main_7 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -112($fp) + la $t1, _empty + sw $t1, -116($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -112($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -116($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -108($fp) + lw $a0, -108($fp) + bne $a0, $zero, label_main_at_Main_9 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -128($fp) + la $t1, _empty + sw $t1, -132($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -128($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -132($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -124($fp) + lw $a0, -124($fp) + bne $a0, $zero, label_main_at_Main_11 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -144($fp) + la $t1, _empty + sw $t1, -148($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -144($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -148($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -140($fp) + lw $a0, -140($fp) + bne $a0, $zero, label_main_at_Main_13 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -160($fp) + la $t1, _empty + sw $t1, -164($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -160($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -164($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -156($fp) + lw $a0, -156($fp) + bne $a0, $zero, label_main_at_Main_15 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -176($fp) + la $t1, _empty + sw $t1, -180($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -176($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -180($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -172($fp) + lw $a0, -172($fp) + bne $a0, $zero, label_main_at_Main_17 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -192($fp) + la $t1, _empty + sw $t1, -196($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -192($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -196($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -188($fp) + lw $a0, -188($fp) + bne $a0, $zero, label_main_at_Main_19 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -208($fp) + la $t1, _empty + sw $t1, -212($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -208($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -212($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -204($fp) + lw $a0, -204($fp) + bne $a0, $zero, label_main_at_Main_21 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -224($fp) + la $t1, _empty + sw $t1, -228($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -224($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -228($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -220($fp) + lw $a0, -220($fp) + bne $a0, $zero, label_main_at_Main_23 + + #init allocate + + li $v0, 9 + lw $a0, A_size + syscall + sw $v0, -240($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -240($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A + sw $a0, -244($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -252($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -252($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -252($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -248($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -248($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -240($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -240($fp) + lw $a0, 8($a0) + lw $a0, 20($a0) + jalr $a0 + sw $a0, -236($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -236($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -236($fp) + sw $t1, -232($fp) + j label_main_at_Main_24 +label_main_at_Main_23: + + #init set attribute + + lw $a0, 4($fp) + li $t1, 0 + sw $t1, 24($a0) + + #end set attribute + + li $t1, 0 + sw $t1, -232($fp) +label_main_at_Main_24: + lw $t1, -232($fp) + sw $t1, -216($fp) + j label_main_at_Main_22 +label_main_at_Main_21: + + #init allocate + + li $v0, 9 + lw $a0, A_size + syscall + sw $v0, -256($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -256($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A + sw $a0, -260($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -256($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -256($fp) + sw $t1, -216($fp) +label_main_at_Main_22: + lw $t1, -216($fp) + sw $t1, -200($fp) + j label_main_at_Main_20 +label_main_at_Main_19: + la $t1, _void + sw $t1, -264($fp) + lw $t1, -264($fp) + sw $t1, -268($fp) + + #init allocate + + li $v0, 9 + lw $a0, E_size + syscall + sw $v0, -276($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -276($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_E + sw $a0, -280($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -288($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -288($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -288($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -284($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -284($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -276($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -276($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -272($fp) + + #fin llamada dinamica + + lw $t1, -272($fp) + sw $t1, -268($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -300($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -300($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -300($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -296($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -308($fp) + + #fin llamada dinamica + + lw $t1, -308($fp) + li $a0, 8 + mul $a0 $t1 $a0 + sw $a0, -304($fp) + lw $t1, -296($fp) + lw $a0, -304($fp) + blt $t1, $a0, label_main_at_Main_25 + li $a0, 0 + j label_main_at_Main_26 +label_main_at_Main_25: + li $a0, 1 +label_main_at_Main_26: + sw $a0, -292($fp) + lw $t1, -292($fp) + sw $t1, -312($fp) + la $t1, _empty + sw $t1, -320($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -320($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -316($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -328($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -328($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -324($fp) + la $t1, _empty + sw $t1, -336($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -336($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -332($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, x + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -340($fp) + la $t1, _empty + sw $t1, -348($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -348($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -344($fp) + + #init allocate + + li $v0, 9 + lw $a0, A2I_size + syscall + sw $v0, -352($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -352($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A2I + sw $a0, -356($fp) + + #fin llamada dinamica + + lw $t1, -352($fp) + sw $t1, -360($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, r + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, a + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -368($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -368($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -364($fp) + la $t1, data_2 + sw $t1, -376($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -376($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -372($fp) + + #init set attribute + + lw $a0, 4($fp) + li $t1, x + sw $t1, 16($a0) + + #end set attribute + + li $t1, x + sw $t1, -200($fp) +label_main_at_Main_20: + lw $t1, -200($fp) + sw $t1, -184($fp) + j label_main_at_Main_18 +label_main_at_Main_17: + + #init allocate + + li $v0, 9 + lw $a0, D_size + syscall + sw $v0, -384($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -384($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_D + sw $a0, -388($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -396($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -396($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -396($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -392($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -392($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -384($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -384($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -380($fp) + + #fin llamada dinamica + + lw $a0, -380($fp) + bne $a0, $zero, label_main_at_Main_27 + la $t1, _empty + sw $t1, -408($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -408($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -404($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -416($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -416($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -412($fp) + la $t1, data_2 + sw $t1, -424($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -424($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -420($fp) + lw $t1, -420($fp) + sw $t1, -400($fp) + j label_main_at_Main_28 +label_main_at_Main_27: + la $t1, _empty + sw $t1, -432($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -432($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -428($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -440($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -440($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -436($fp) + la $t1, data_2 + sw $t1, -448($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -448($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -444($fp) + lw $t1, -444($fp) + sw $t1, -400($fp) +label_main_at_Main_28: + lw $t1, -400($fp) + sw $t1, -184($fp) +label_main_at_Main_18: + lw $t1, -184($fp) + sw $t1, -168($fp) + j label_main_at_Main_16 +label_main_at_Main_15: + + #init allocate + + li $v0, 9 + lw $a0, C_size + syscall + sw $v0, -456($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -456($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_C + sw $a0, -460($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -468($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -468($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -468($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -464($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -464($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -456($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__C + lw $a0, 36($a0) + jalr $a0 + sw $a0, -452($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -452($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -452($fp) + sw $t1, -168($fp) +label_main_at_Main_16: + lw $t1, -168($fp) + sw $t1, -152($fp) + j label_main_at_Main_14 +label_main_at_Main_13: + + #init allocate + + li $v0, 9 + lw $a0, C_size + syscall + sw $v0, -476($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -476($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_C + sw $a0, -480($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -488($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -488($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -488($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -484($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -484($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -476($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__B + lw $a0, 36($a0) + jalr $a0 + sw $a0, -472($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -472($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -472($fp) + sw $t1, -152($fp) +label_main_at_Main_14: + lw $t1, -152($fp) + sw $t1, -136($fp) + j label_main_at_Main_12 +label_main_at_Main_11: + + #init allocate + + li $v0, 9 + lw $a0, C_size + syscall + sw $v0, -496($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -496($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_C + sw $a0, -500($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -508($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -508($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -508($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -504($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -504($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -496($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__A + lw $a0, 36($a0) + jalr $a0 + sw $a0, -492($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -492($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -492($fp) + sw $t1, -136($fp) +label_main_at_Main_12: + lw $t1, -136($fp) + sw $t1, -120($fp) + j label_main_at_Main_10 +label_main_at_Main_9: + + #init allocate + + li $v0, 9 + lw $a0, A_size + syscall + sw $v0, -516($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -516($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A + sw $a0, -520($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -524($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -524($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -516($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -516($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -512($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -512($fp) + sw $t1, 20($a0) + + #end set attribute + + + #init allocate + + li $v0, 9 + lw $a0, D_size + syscall + sw $v0, -532($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -532($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_D + sw $a0, -536($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -544($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -544($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -544($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -540($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 20($a0) + sw $a0, -552($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -552($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -552($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -548($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -548($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -540($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -532($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -532($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -528($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -528($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -528($fp) + sw $t1, -120($fp) +label_main_at_Main_10: + lw $t1, -120($fp) + sw $t1, -104($fp) + j label_main_at_Main_8 +label_main_at_Main_7: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -564($fp) + lw $t1, -564($fp) + sw $t1, -560($fp) + la $a0, C_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_29 + la $a0, E_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_30 + la $a0, D_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_30 + la $a0, B_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_30 + la $a0, A_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_30 + la $a0, Bool_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_31 + la $a0, Int_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_31 + la $a0, String_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_31 + la $a0, Main_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_31 + la $a0, IO_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_31 + la $a0, A2I_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_31 + la $a0, Object_name + lw $t1, -564($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_main_at_Main_31 +label_main_at_Main_29: + lw $t1, -564($fp) + sw $t1, -568($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, c + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -576($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -576($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, c + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -572($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -572($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -572($fp) + sw $t1, -556($fp) + j label_main_at_Main_32 +label_main_at_Main_30: + lw $t1, -564($fp) + sw $t1, -580($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, a + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -588($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -588($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, a + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -584($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -584($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -584($fp) + sw $t1, -556($fp) + j label_main_at_Main_32 +label_main_at_Main_31: + lw $t1, -564($fp) + sw $t1, -592($fp) + la $t1, data_2 + sw $t1, -600($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -600($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -596($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -604($fp) + li $t1, 0 + sw $t1, -556($fp) + j label_main_at_Main_32 +label_main_at_Main_32: + lw $t1, -556($fp) + sw $t1, -104($fp) +label_main_at_Main_8: + lw $t1, -104($fp) + sw $t1, -88($fp) + j label_main_at_Main_6 +label_main_at_Main_5: + + #init allocate + + li $v0, 9 + lw $a0, A_size + syscall + sw $v0, -612($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -612($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A + sw $a0, -616($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -620($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -620($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -612($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -612($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -608($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -608($fp) + sw $t1, 20($a0) + + #end set attribute + + + #init allocate + + li $v0, 9 + lw $a0, B_size + syscall + sw $v0, -628($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -628($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_B + sw $a0, -632($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -640($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -640($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -640($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -636($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 20($a0) + sw $a0, -648($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -648($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -648($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -644($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -644($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -636($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -628($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -628($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -624($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -624($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -624($fp) + sw $t1, -88($fp) +label_main_at_Main_6: + j label_main_at_Main_0 +label_main_at_Main_2: + la $t1, _void + sw $t1, -652($fp) + + #retornando el valor + + lw $a0, -652($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 664 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -8($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/atoi.mips b/tests/codegen/atoi.mips new file mode 100644 index 000000000..f8dd438a5 --- /dev/null +++ b/tests/codegen/atoi.mips @@ -0,0 +1,2204 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + A2I_name: .asciiz "A2I" + A2I_size: .word 12 +__virtual_table__A2I: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_c2i_at_A2I + .word function_i2c_at_A2I + .word function_a2i_at_A2I + .word function_a2i_aux_at_A2I + .word function_i2a_at_A2I + .word function_i2a_aux_at_A2I + Main_name: .asciiz "Main" + Main_size: .word 12 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 28($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_c2i_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -124 + la $t1, _empty + sw $t1, -8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -4($fp) + lw $a0, -4($fp) + bne $a0, $zero, label_c2i_at_A2I_0 + la $t1, _empty + sw $t1, -20($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_c2i_at_A2I_2 + la $t1, _empty + sw $t1, -32($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_c2i_at_A2I_4 + la $t1, _empty + sw $t1, -44($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_c2i_at_A2I_6 + la $t1, _empty + sw $t1, -56($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -52($fp) + lw $a0, -52($fp) + bne $a0, $zero, label_c2i_at_A2I_8 + la $t1, _empty + sw $t1, -68($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -64($fp) + lw $a0, -64($fp) + bne $a0, $zero, label_c2i_at_A2I_10 + la $t1, _empty + sw $t1, -80($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -76($fp) + lw $a0, -76($fp) + bne $a0, $zero, label_c2i_at_A2I_12 + la $t1, _empty + sw $t1, -92($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -92($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -88($fp) + lw $a0, -88($fp) + bne $a0, $zero, label_c2i_at_A2I_14 + la $t1, _empty + sw $t1, -104($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -104($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -100($fp) + lw $a0, -100($fp) + bne $a0, $zero, label_c2i_at_A2I_16 + la $t1, _empty + sw $t1, -116($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -116($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -112($fp) + lw $a0, -112($fp) + bne $a0, $zero, label_c2i_at_A2I_18 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -124($fp) + li $t1, 0 + sw $t1, -120($fp) + j label_c2i_at_A2I_19 +label_c2i_at_A2I_18: + li $t1, 9 + sw $t1, -120($fp) +label_c2i_at_A2I_19: + lw $t1, -120($fp) + sw $t1, -108($fp) + j label_c2i_at_A2I_17 +label_c2i_at_A2I_16: + li $t1, 8 + sw $t1, -108($fp) +label_c2i_at_A2I_17: + lw $t1, -108($fp) + sw $t1, -96($fp) + j label_c2i_at_A2I_15 +label_c2i_at_A2I_14: + li $t1, 7 + sw $t1, -96($fp) +label_c2i_at_A2I_15: + lw $t1, -96($fp) + sw $t1, -84($fp) + j label_c2i_at_A2I_13 +label_c2i_at_A2I_12: + li $t1, 6 + sw $t1, -84($fp) +label_c2i_at_A2I_13: + lw $t1, -84($fp) + sw $t1, -72($fp) + j label_c2i_at_A2I_11 +label_c2i_at_A2I_10: + li $t1, 5 + sw $t1, -72($fp) +label_c2i_at_A2I_11: + lw $t1, -72($fp) + sw $t1, -60($fp) + j label_c2i_at_A2I_9 +label_c2i_at_A2I_8: + li $t1, 4 + sw $t1, -60($fp) +label_c2i_at_A2I_9: + lw $t1, -60($fp) + sw $t1, -48($fp) + j label_c2i_at_A2I_7 +label_c2i_at_A2I_6: + li $t1, 3 + sw $t1, -48($fp) +label_c2i_at_A2I_7: + lw $t1, -48($fp) + sw $t1, -36($fp) + j label_c2i_at_A2I_5 +label_c2i_at_A2I_4: + li $t1, 2 + sw $t1, -36($fp) +label_c2i_at_A2I_5: + lw $t1, -36($fp) + sw $t1, -24($fp) + j label_c2i_at_A2I_3 +label_c2i_at_A2I_2: + li $t1, 1 + sw $t1, -24($fp) +label_c2i_at_A2I_3: + lw $t1, -24($fp) + sw $t1, -12($fp) + j label_c2i_at_A2I_1 +label_c2i_at_A2I_0: + li $t1, 0 + sw $t1, -12($fp) +label_c2i_at_A2I_1: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 140 + lw $fp, 0($sp) + jr $ra +function_i2c_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -168 + lw $t1, 8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -8($fp) + lw $a0, -8($fp) + bne $a0, $zero, label_i2c_at_A2I_0 + li $t1, 1 + sw $t1, -4($fp) + j label_i2c_at_A2I_1 +label_i2c_at_A2I_0: + li $t1, 0 + sw $t1, -4($fp) +label_i2c_at_A2I_1: + lw $a0, -4($fp) + bne $a0, $zero, label_i2c_at_A2I_2 + lw $t1, 8($fp) + li $a0, 1 + sub $a0, $t1, $a0 + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_i2c_at_A2I_4 + li $t1, 1 + sw $t1, -16($fp) + j label_i2c_at_A2I_5 +label_i2c_at_A2I_4: + li $t1, 0 + sw $t1, -16($fp) +label_i2c_at_A2I_5: + lw $a0, -16($fp) + bne $a0, $zero, label_i2c_at_A2I_6 + lw $t1, 8($fp) + li $a0, 2 + sub $a0, $t1, $a0 + sw $a0, -32($fp) + lw $a0, -32($fp) + bne $a0, $zero, label_i2c_at_A2I_8 + li $t1, 1 + sw $t1, -28($fp) + j label_i2c_at_A2I_9 +label_i2c_at_A2I_8: + li $t1, 0 + sw $t1, -28($fp) +label_i2c_at_A2I_9: + lw $a0, -28($fp) + bne $a0, $zero, label_i2c_at_A2I_10 + lw $t1, 8($fp) + li $a0, 3 + sub $a0, $t1, $a0 + sw $a0, -44($fp) + lw $a0, -44($fp) + bne $a0, $zero, label_i2c_at_A2I_12 + li $t1, 1 + sw $t1, -40($fp) + j label_i2c_at_A2I_13 +label_i2c_at_A2I_12: + li $t1, 0 + sw $t1, -40($fp) +label_i2c_at_A2I_13: + lw $a0, -40($fp) + bne $a0, $zero, label_i2c_at_A2I_14 + lw $t1, 8($fp) + li $a0, 4 + sub $a0, $t1, $a0 + sw $a0, -56($fp) + lw $a0, -56($fp) + bne $a0, $zero, label_i2c_at_A2I_16 + li $t1, 1 + sw $t1, -52($fp) + j label_i2c_at_A2I_17 +label_i2c_at_A2I_16: + li $t1, 0 + sw $t1, -52($fp) +label_i2c_at_A2I_17: + lw $a0, -52($fp) + bne $a0, $zero, label_i2c_at_A2I_18 + lw $t1, 8($fp) + li $a0, 5 + sub $a0, $t1, $a0 + sw $a0, -68($fp) + lw $a0, -68($fp) + bne $a0, $zero, label_i2c_at_A2I_20 + li $t1, 1 + sw $t1, -64($fp) + j label_i2c_at_A2I_21 +label_i2c_at_A2I_20: + li $t1, 0 + sw $t1, -64($fp) +label_i2c_at_A2I_21: + lw $a0, -64($fp) + bne $a0, $zero, label_i2c_at_A2I_22 + lw $t1, 8($fp) + li $a0, 6 + sub $a0, $t1, $a0 + sw $a0, -80($fp) + lw $a0, -80($fp) + bne $a0, $zero, label_i2c_at_A2I_24 + li $t1, 1 + sw $t1, -76($fp) + j label_i2c_at_A2I_25 +label_i2c_at_A2I_24: + li $t1, 0 + sw $t1, -76($fp) +label_i2c_at_A2I_25: + lw $a0, -76($fp) + bne $a0, $zero, label_i2c_at_A2I_26 + lw $t1, 8($fp) + li $a0, 7 + sub $a0, $t1, $a0 + sw $a0, -92($fp) + lw $a0, -92($fp) + bne $a0, $zero, label_i2c_at_A2I_28 + li $t1, 1 + sw $t1, -88($fp) + j label_i2c_at_A2I_29 +label_i2c_at_A2I_28: + li $t1, 0 + sw $t1, -88($fp) +label_i2c_at_A2I_29: + lw $a0, -88($fp) + bne $a0, $zero, label_i2c_at_A2I_30 + lw $t1, 8($fp) + li $a0, 8 + sub $a0, $t1, $a0 + sw $a0, -104($fp) + lw $a0, -104($fp) + bne $a0, $zero, label_i2c_at_A2I_32 + li $t1, 1 + sw $t1, -100($fp) + j label_i2c_at_A2I_33 +label_i2c_at_A2I_32: + li $t1, 0 + sw $t1, -100($fp) +label_i2c_at_A2I_33: + lw $a0, -100($fp) + bne $a0, $zero, label_i2c_at_A2I_34 + lw $t1, 8($fp) + li $a0, 9 + sub $a0, $t1, $a0 + sw $a0, -116($fp) + lw $a0, -116($fp) + bne $a0, $zero, label_i2c_at_A2I_36 + li $t1, 1 + sw $t1, -112($fp) + j label_i2c_at_A2I_37 +label_i2c_at_A2I_36: + li $t1, 0 + sw $t1, -112($fp) +label_i2c_at_A2I_37: + lw $a0, -112($fp) + bne $a0, $zero, label_i2c_at_A2I_38 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -124($fp) + la $t1, _empty + sw $t1, -128($fp) + lw $t1, -128($fp) + sw $t1, -120($fp) + j label_i2c_at_A2I_39 +label_i2c_at_A2I_38: + la $t1, _empty + sw $t1, -132($fp) + lw $t1, -132($fp) + sw $t1, -120($fp) +label_i2c_at_A2I_39: + lw $t1, -120($fp) + sw $t1, -108($fp) + j label_i2c_at_A2I_35 +label_i2c_at_A2I_34: + la $t1, _empty + sw $t1, -136($fp) + lw $t1, -136($fp) + sw $t1, -108($fp) +label_i2c_at_A2I_35: + lw $t1, -108($fp) + sw $t1, -96($fp) + j label_i2c_at_A2I_31 +label_i2c_at_A2I_30: + la $t1, _empty + sw $t1, -140($fp) + lw $t1, -140($fp) + sw $t1, -96($fp) +label_i2c_at_A2I_31: + lw $t1, -96($fp) + sw $t1, -84($fp) + j label_i2c_at_A2I_27 +label_i2c_at_A2I_26: + la $t1, _empty + sw $t1, -144($fp) + lw $t1, -144($fp) + sw $t1, -84($fp) +label_i2c_at_A2I_27: + lw $t1, -84($fp) + sw $t1, -72($fp) + j label_i2c_at_A2I_23 +label_i2c_at_A2I_22: + la $t1, _empty + sw $t1, -148($fp) + lw $t1, -148($fp) + sw $t1, -72($fp) +label_i2c_at_A2I_23: + lw $t1, -72($fp) + sw $t1, -60($fp) + j label_i2c_at_A2I_19 +label_i2c_at_A2I_18: + la $t1, _empty + sw $t1, -152($fp) + lw $t1, -152($fp) + sw $t1, -60($fp) +label_i2c_at_A2I_19: + lw $t1, -60($fp) + sw $t1, -48($fp) + j label_i2c_at_A2I_15 +label_i2c_at_A2I_14: + la $t1, _empty + sw $t1, -156($fp) + lw $t1, -156($fp) + sw $t1, -48($fp) +label_i2c_at_A2I_15: + lw $t1, -48($fp) + sw $t1, -36($fp) + j label_i2c_at_A2I_11 +label_i2c_at_A2I_10: + la $t1, _empty + sw $t1, -160($fp) + lw $t1, -160($fp) + sw $t1, -36($fp) +label_i2c_at_A2I_11: + lw $t1, -36($fp) + sw $t1, -24($fp) + j label_i2c_at_A2I_7 +label_i2c_at_A2I_6: + la $t1, _empty + sw $t1, -164($fp) + lw $t1, -164($fp) + sw $t1, -24($fp) +label_i2c_at_A2I_7: + lw $t1, -24($fp) + sw $t1, -12($fp) + j label_i2c_at_A2I_3 +label_i2c_at_A2I_2: + la $t1, _empty + sw $t1, -168($fp) + lw $t1, -168($fp) + sw $t1, -12($fp) +label_i2c_at_A2I_3: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 184 + lw $fp, 0($sp) + jr $ra +function_a2i_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -88 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_a2i_at_A2I_0 + li $t1, 1 + sw $t1, -4($fp) + j label_a2i_at_A2I_1 +label_a2i_at_A2I_0: + li $t1, 0 + sw $t1, -4($fp) +label_a2i_at_A2I_1: + lw $a0, -4($fp) + bne $a0, $zero, label_a2i_at_A2I_2 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 0 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -24($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -28($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_a2i_at_A2I_4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 0 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -40($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -44($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_a2i_at_A2I_6 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -52($fp) + lw $t1, -52($fp) + sw $t1, -48($fp) + j label_a2i_at_A2I_7 +label_a2i_at_A2I_6: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -68($fp) + + #fin llamada dinamica + + lw $t1, -68($fp) + li $a0, 1 + blt $t1, $a0, label_a2i_at_A2I_8 + li $a0, 0 + j label_a2i_at_A2I_9 +label_a2i_at_A2I_8: + li $a0, 1 +label_a2i_at_A2I_9: + sw $a0, -64($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -60($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -56($fp) + lw $t1, -56($fp) + sw $t1, -48($fp) +label_a2i_at_A2I_7: + lw $t1, -48($fp) + sw $t1, -32($fp) + j label_a2i_at_A2I_5 +label_a2i_at_A2I_4: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -88($fp) + + #fin llamada dinamica + + lw $t1, -88($fp) + li $a0, 1 + blt $t1, $a0, label_a2i_at_A2I_10 + li $a0, 0 + j label_a2i_at_A2I_11 +label_a2i_at_A2I_10: + li $a0, 1 +label_a2i_at_A2I_11: + sw $a0, -84($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -84($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -80($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -76($fp) + lw $t1, -76($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -72($fp) + lw $t1, -72($fp) + sw $t1, -32($fp) +label_a2i_at_A2I_5: + lw $t1, -32($fp) + sw $t1, -16($fp) + j label_a2i_at_A2I_3 +label_a2i_at_A2I_2: + li $t1, 0 + sw $t1, -16($fp) +label_a2i_at_A2I_3: + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 104 + lw $fp, 0($sp) + jr $ra +function_a2i_aux_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + li $t1, 0 + sw $t1, -4($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + sw $t1, -12($fp) + li $t1, 0 + sw $t1, -16($fp) +label_a2i_aux_at_A2I_0: + li $a0, [] + bne $a0, $zero, label_a2i_aux_at_A2I_1 + j label_a2i_aux_at_A2I_2 +label_a2i_aux_at_A2I_1: + li $t1, int + li $a0, 10 + mul $a0 $t1 $a0 + sw $a0, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, i + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -32($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + lw $t1, -24($fp) + lw $a0, -28($fp) + add $a0, $a0, $t1 + sw $a0, -20($fp) + lw $t1, -20($fp) + sw $t1, -4($fp) + li $t1, i + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -16($fp) + j label_a2i_aux_at_A2I_0 +label_a2i_aux_at_A2I_2: + la $t1, _void + sw $t1, -40($fp) + + #retornando el valor + + li $a0, int + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 56 + lw $fp, 0($sp) + jr $ra +function_i2a_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -44 + lw $t1, 8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -8($fp) + lw $a0, -8($fp) + bne $a0, $zero, label_i2a_at_A2I_0 + li $t1, 1 + sw $t1, -4($fp) + j label_i2a_at_A2I_1 +label_i2a_at_A2I_0: + li $t1, 0 + sw $t1, -4($fp) +label_i2a_at_A2I_1: + lw $a0, -4($fp) + bne $a0, $zero, label_i2a_at_A2I_2 + li $a0, [] + bne $a0, $zero, label_i2a_at_A2I_4 + la $t1, _empty + sw $t1, -24($fp) + li $t1, 1 + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -36($fp) + lw $t1, 8($fp) + lw $a0, -36($fp) + mul $a0 $t1 $a0 + sw $a0, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_concat_at_String + sw $a0, -20($fp) + + #fin llamada dinamica + + lw $t1, -20($fp) + sw $t1, -16($fp) + j label_i2a_at_A2I_5 +label_i2a_at_A2I_4: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -40($fp) + lw $t1, -40($fp) + sw $t1, -16($fp) +label_i2a_at_A2I_5: + lw $t1, -16($fp) + sw $t1, -12($fp) + j label_i2a_at_A2I_3 +label_i2a_at_A2I_2: + la $t1, _empty + sw $t1, -44($fp) + lw $t1, -44($fp) + sw $t1, -12($fp) +label_i2a_at_A2I_3: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_i2a_aux_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -44 + lw $t1, 8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -8($fp) + lw $a0, -8($fp) + bne $a0, $zero, label_i2a_aux_at_A2I_0 + li $t1, 1 + sw $t1, -4($fp) + j label_i2a_aux_at_A2I_1 +label_i2a_aux_at_A2I_0: + li $t1, 0 + sw $t1, -4($fp) +label_i2a_aux_at_A2I_1: + lw $a0, -4($fp) + bne $a0, $zero, label_i2a_aux_at_A2I_2 + lw $t1, 8($fp) + li $a0, 10 + div $a0, $t1, $a0 + sw $a0, -16($fp) + lw $t1, -16($fp) + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, next + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -28($fp) + li $t1, next + li $a0, 10 + mul $a0 $t1 $a0 + sw $a0, -40($fp) + lw $t1, 8($fp) + lw $a0, -40($fp) + blt $t1, $a0, label_i2a_aux_at_A2I_4 + li $a0, 0 + j label_i2a_aux_at_A2I_5 +label_i2a_aux_at_A2I_4: + li $a0, 1 +label_i2a_aux_at_A2I_5: + sw $a0, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_concat_at_String + sw $a0, -24($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + sw $t1, -12($fp) + j label_i2a_aux_at_A2I_3 +label_i2a_aux_at_A2I_2: + la $t1, _empty + sw $t1, -44($fp) + lw $t1, -44($fp) + sw $t1, -12($fp) +label_i2a_aux_at_A2I_3: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, A2I_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, A2I_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__A2I + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_A2I + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_A2I: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -60 + + #init allocate + + li $v0, 9 + lw $a0, A2I_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A2I + sw $a0, -12($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 20($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -20($fp) + + #init allocate + + li $v0, 9 + lw $a0, A2I_size + syscall + sw $v0, -28($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A2I + sw $a0, -32($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 678987 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -28($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -24($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + sw $t1, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, a + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -40($fp) + la $t1, _empty + sw $t1, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, b + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -52($fp) + la $t1, data_1 + sw $t1, -60($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -56($fp) + + #retornando el valor + + lw $a0, -56($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 72 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/book_list.mips b/tests/codegen/book_list.mips new file mode 100644 index 000000000..c509548d6 --- /dev/null +++ b/tests/codegen/book_list.mips @@ -0,0 +1,2487 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Book_name: .asciiz "Book" + Book_size: .word 20 +__virtual_table__Book: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_initBook_at_Book + .word function_print_at_Book + Article_name: .asciiz "Article" + Article_size: .word 24 +__virtual_table__Article: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_initBook_at_Book + .word function_print_at_Article + .word function_initArticle_at_Article + BookList_name: .asciiz "BookList" + BookList_size: .word 12 +__virtual_table__BookList: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_BookList + .word function_cons_at_BookList + .word function_car_at_BookList + .word function_cdr_at_BookList + .word function_print_list_at_BookList + Cons_name: .asciiz "Cons" + Cons_size: .word 20 +__virtual_table__Cons: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_Cons + .word function_cons_at_BookList + .word function_car_at_Cons + .word function_cdr_at_Cons + .word function_print_list_at_Cons + .word function_init_at_Cons + Nil_name: .asciiz "Nil" + Nil_size: .word 12 +__virtual_table__Nil: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_Nil + .word function_cons_at_BookList + .word function_car_at_BookList + .word function_cdr_at_BookList + .word function_print_list_at_Nil + Main_name: .asciiz "Main" + Main_size: .word 16 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 12($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_initBook_at_Book: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 12($fp) + sw $t1, 16($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_print_at_Book: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + la $t1, _empty + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -12($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -12($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -8($fp) + + #fin llamada dinamica + + la $t1, data_1 + sw $t1, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -36($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -36($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -32($fp) + + #fin llamada dinamica + + la $t1, data_1 + sw $t1, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -32($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Book: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Book_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Book_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Book + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Book + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Book: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_initArticle_at_Article: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -4($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 16($fp) + sw $t1, 20($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_print_at_Article: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -28 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Book + lw $a0, 32($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -16($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 20($a0) + sw $a0, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + la $t1, data_1 + sw $t1, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -12($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -8($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 40 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Article: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Article_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Article_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Article + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Article + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Article: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Book + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_BookList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + li $a0, 1 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_cons_at_BookList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init allocate + + li $v0, 9 + lw $a0, Cons_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Cons + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, new_cell + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 32 + lw $fp, 0($sp) + jr $ra +function_car_at_BookList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #init allocate + + li $v0, 9 + lw $a0, Book_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Book + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -8($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_cdr_at_BookList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #init allocate + + li $v0, 9 + lw $a0, BookList_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_BookList + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -8($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_print_list_at_BookList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_BookList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, BookList_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, BookList_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__BookList + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_BookList + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_BookList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_init_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 12($fp) + sw $t1, 16($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_car_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_cdr_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_print_list_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + lw $t1, -12($fp) + sw $t1, -8($fp) + la $a0, Article_name + lw $t1, -12($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_print_list_at_Cons_0 + la $a0, Book_name + lw $t1, -12($fp) + lw $t1, 0($t1) + beq $t1, $a0, label_print_list_at_Cons_1 +label_print_list_at_Cons_1: + lw $t1, -12($fp) + sw $t1, -20($fp) + la $t1, data_1 + sw $t1, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -24($fp) + lw $t1, -24($fp) + sw $t1, -4($fp) + j label_print_list_at_Cons_2 +label_print_list_at_Cons_0: + lw $t1, -12($fp) + sw $t1, -32($fp) + la $t1, data_1 + sw $t1, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -4($fp) + j label_print_list_at_Cons_2 +label_print_list_at_Cons_2: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -48($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -44($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -44($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Cons_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Cons_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Cons + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Cons + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_BookList + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 1 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_print_list_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 1 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Nil_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Nil_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Nil + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Nil + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_BookList + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -76 + + #init allocate + + li $v0, 9 + lw $a0, Book_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Book + sw $a0, -12($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -16($fp) + la $t1, _empty + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -24($fp) + + #init allocate + + li $v0, 9 + lw $a0, Article_size + syscall + sw $v0, -32($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Article + sw $a0, -36($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -40($fp) + la $t1, _empty + sw $t1, -44($fp) + la $t1, _empty + sw $t1, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -32($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -28($fp) + + #fin llamada dinamica + + lw $t1, -28($fp) + sw $t1, -52($fp) + + #init allocate + + li $v0, 9 + lw $a0, Nil_size + syscall + sw $v0, -64($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Nil + sw $a0, -68($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, a_book + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -64($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -60($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, an_article + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -60($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -56($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -56($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -76($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -76($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -76($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -72($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -72($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 88 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/cells.mips b/tests/codegen/cells.mips new file mode 100644 index 000000000..be1d9467c --- /dev/null +++ b/tests/codegen/cells.mips @@ -0,0 +1,1685 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + CellularAutomaton_name: .asciiz "CellularAutomaton" + CellularAutomaton_size: .word 16 +__virtual_table__CellularAutomaton: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_init_at_CellularAutomaton + .word function_print_at_CellularAutomaton + .word function_num_cells_at_CellularAutomaton + .word function_cell_at_CellularAutomaton + .word function_cell_left_neighbor_at_CellularAutomaton + .word function_cell_right_neighbor_at_CellularAutomaton + .word function_cell_at_next_evolution_at_CellularAutomaton + .word function_evolve_at_CellularAutomaton + Main_name: .asciiz "Main" + Main_size: .word 16 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 12($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_init_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_print_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -12($fp) + la $t1, data_1 + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_concat_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_num_cells_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_cell_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_cell_left_neighbor_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -32 + lw $t1, 8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -8($fp) + lw $a0, -8($fp) + bne $a0, $zero, label_cell_left_neighbor_at_CellularAutomaton_0 + li $t1, 1 + sw $t1, -4($fp) + j label_cell_left_neighbor_at_CellularAutomaton_1 +label_cell_left_neighbor_at_CellularAutomaton_0: + li $t1, 0 + sw $t1, -4($fp) +label_cell_left_neighbor_at_CellularAutomaton_1: + lw $a0, -4($fp) + bne $a0, $zero, label_cell_left_neighbor_at_CellularAutomaton_2 + lw $t1, 8($fp) + li $a0, 1 + blt $t1, $a0, label_cell_left_neighbor_at_CellularAutomaton_4 + li $a0, 0 + j label_cell_left_neighbor_at_CellularAutomaton_5 +label_cell_left_neighbor_at_CellularAutomaton_4: + li $a0, 1 +label_cell_left_neighbor_at_CellularAutomaton_5: + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -16($fp) + lw $t1, -16($fp) + sw $t1, -12($fp) + j label_cell_left_neighbor_at_CellularAutomaton_3 +label_cell_left_neighbor_at_CellularAutomaton_2: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -32($fp) + lw $t1, -32($fp) + li $a0, 1 + blt $t1, $a0, label_cell_left_neighbor_at_CellularAutomaton_6 + li $a0, 0 + j label_cell_left_neighbor_at_CellularAutomaton_7 +label_cell_left_neighbor_at_CellularAutomaton_6: + li $a0, 1 +label_cell_left_neighbor_at_CellularAutomaton_7: + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -24($fp) + lw $t1, -24($fp) + sw $t1, -12($fp) +label_cell_left_neighbor_at_CellularAutomaton_3: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 48 + lw $fp, 0($sp) + jr $ra +function_cell_right_neighbor_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -32 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -12($fp) + lw $t1, -12($fp) + li $a0, 1 + blt $t1, $a0, label_cell_right_neighbor_at_CellularAutomaton_0 + li $a0, 0 + j label_cell_right_neighbor_at_CellularAutomaton_1 +label_cell_right_neighbor_at_CellularAutomaton_0: + li $a0, 1 +label_cell_right_neighbor_at_CellularAutomaton_1: + sw $a0, -8($fp) + lw $t1, 8($fp) + lw $a0, -8($fp) + sub $a0, $t1, $a0 + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_cell_right_neighbor_at_CellularAutomaton_2 + li $t1, 1 + sw $t1, -4($fp) + j label_cell_right_neighbor_at_CellularAutomaton_3 +label_cell_right_neighbor_at_CellularAutomaton_2: + li $t1, 0 + sw $t1, -4($fp) +label_cell_right_neighbor_at_CellularAutomaton_3: + lw $a0, -4($fp) + bne $a0, $zero, label_cell_right_neighbor_at_CellularAutomaton_4 + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -24($fp) + lw $t1, -24($fp) + sw $t1, -20($fp) + j label_cell_right_neighbor_at_CellularAutomaton_5 +label_cell_right_neighbor_at_CellularAutomaton_4: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 0 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -32($fp) + lw $t1, -32($fp) + sw $t1, -20($fp) +label_cell_right_neighbor_at_CellularAutomaton_5: + + #retornando el valor + + lw $a0, -20($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 48 + lw $fp, 0($sp) + jr $ra +function_cell_at_next_evolution_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -76 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -20($fp) + la $t1, _empty + sw $t1, -24($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_0 + li $t1, 0 + sw $t1, -28($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_1 +label_cell_at_next_evolution_at_CellularAutomaton_0: + li $t1, 1 + sw $t1, -28($fp) +label_cell_at_next_evolution_at_CellularAutomaton_1: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -36($fp) + la $t1, _empty + sw $t1, -40($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -32($fp) + lw $a0, -32($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_2 + li $t1, 0 + sw $t1, -44($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_3 +label_cell_at_next_evolution_at_CellularAutomaton_2: + li $t1, 1 + sw $t1, -44($fp) +label_cell_at_next_evolution_at_CellularAutomaton_3: + lw $t1, -28($fp) + lw $a0, -44($fp) + add $a0, $a0, $t1 + sw $a0, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -52($fp) + la $t1, _empty + sw $t1, -56($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -52($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -48($fp) + lw $a0, -48($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_4 + li $t1, 0 + sw $t1, -60($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_5 +label_cell_at_next_evolution_at_CellularAutomaton_4: + li $t1, 1 + sw $t1, -60($fp) +label_cell_at_next_evolution_at_CellularAutomaton_5: + lw $t1, -12($fp) + lw $a0, -60($fp) + add $a0, $a0, $t1 + sw $a0, -8($fp) + lw $t1, -8($fp) + li $a0, 1 + sub $a0, $t1, $a0 + sw $a0, -64($fp) + lw $a0, -64($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_6 + li $t1, 1 + sw $t1, -4($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_7 +label_cell_at_next_evolution_at_CellularAutomaton_6: + li $t1, 0 + sw $t1, -4($fp) +label_cell_at_next_evolution_at_CellularAutomaton_7: + lw $a0, -4($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_8 + la $t1, _empty + sw $t1, -72($fp) + lw $t1, -72($fp) + sw $t1, -68($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_9 +label_cell_at_next_evolution_at_CellularAutomaton_8: + la $t1, _empty + sw $t1, -76($fp) + lw $t1, -76($fp) + sw $t1, -68($fp) +label_cell_at_next_evolution_at_CellularAutomaton_9: + + #retornando el valor + + lw $a0, -68($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 92 + lw $fp, 0($sp) + jr $ra +function_evolve_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -36 + li $t1, 0 + sw $t1, -4($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -8($fp) + lw $t1, -8($fp) + sw $t1, -12($fp) + la $t1, _empty + sw $t1, -16($fp) + lw $t1, -16($fp) + sw $t1, -20($fp) +label_evolve_at_CellularAutomaton_0: + li $a0, [] + bne $a0, $zero, label_evolve_at_CellularAutomaton_1 + j label_evolve_at_CellularAutomaton_2 +label_evolve_at_CellularAutomaton_1: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, position + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 52($a0) + jalr $a0 + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, temp + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_concat_at_String + sw $a0, -24($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + sw $t1, -20($fp) + li $t1, position + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -32($fp) + lw $t1, -32($fp) + sw $t1, -4($fp) + j label_evolve_at_CellularAutomaton_0 +label_evolve_at_CellularAutomaton_2: + la $t1, _void + sw $t1, -36($fp) + + #init set attribute + + lw $a0, 4($fp) + li $t1, temp + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 48 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, CellularAutomaton_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, CellularAutomaton_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__CellularAutomaton + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_CellularAutomaton + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -52 + + #init allocate + + li $v0, 9 + lw $a0, CellularAutomaton_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_CellularAutomaton + sw $a0, -12($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -4($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -24($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -20($fp) + + #fin llamada dinamica + + li $t1, 20 + sw $t1, -28($fp) +label_main_at_Main_0: + li $a0, [] + bne $a0, $zero, label_main_at_Main_1 + j label_main_at_Main_2 +label_main_at_Main_1: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -36($fp) + lw $a0, 8($a0) + lw $a0, 56($a0) + jalr $a0 + sw $a0, -32($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -44($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -40($fp) + + #fin llamada dinamica + + li $t1, countdown + li $a0, 1 + blt $t1, $a0, label_main_at_Main_3 + li $a0, 0 + j label_main_at_Main_4 +label_main_at_Main_3: + li $a0, 1 +label_main_at_Main_4: + sw $a0, -48($fp) + lw $t1, -48($fp) + sw $t1, -28($fp) + j label_main_at_Main_0 +label_main_at_Main_2: + la $t1, _void + sw $t1, -52($fp) + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 64 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/complex.mips b/tests/codegen/complex.mips new file mode 100644 index 000000000..a208e60e7 --- /dev/null +++ b/tests/codegen/complex.mips @@ -0,0 +1,1413 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Main_name: .asciiz "Main" + Main_size: .word 12 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_main_at_Main + Complex_name: .asciiz "Complex" + Complex_size: .word 20 +__virtual_table__Complex: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_init_at_Complex + .word function_print_at_Complex + .word function_reflect_0_at_Complex + .word function_reflect_X_at_Complex + .word function_reflect_Y_at_Complex + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 28($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -56 + + #init allocate + + li $v0, 9 + lw $a0, Complex_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Complex + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, c + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -28($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -28($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -24($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, c + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -32($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + lw $a0, -32($fp) + sub $a0, $t1, $a0 + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_main_at_Main_0 + li $t1, 1 + sw $t1, -20($fp) + j label_main_at_Main_1 +label_main_at_Main_0: + li $t1, 0 + sw $t1, -20($fp) +label_main_at_Main_1: + lw $a0, -20($fp) + bne $a0, $zero, label_main_at_Main_2 + la $t1, data_1 + sw $t1, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -44($fp) + lw $t1, -44($fp) + sw $t1, -40($fp) + j label_main_at_Main_3 +label_main_at_Main_2: + la $t1, data_1 + sw $t1, -56($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -52($fp) + lw $t1, -52($fp) + sw $t1, -40($fp) +label_main_at_Main_3: + + #retornando el valor + + lw $a0, -40($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 68 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_init_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -24 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + lw $t1, -8($fp) + lw $a0, 8($fp) + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_init_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_init_at_Complex_1 +label_init_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_init_at_Complex_1: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -20($fp) + lw $t1, -20($fp) + lw $a0, 12($fp) + sub $a0, $t1, $a0 + sw $a0, -24($fp) + lw $a0, -24($fp) + bne $a0, $zero, label_init_at_Complex_2 + li $t1, 1 + sw $t1, -16($fp) + j label_init_at_Complex_3 +label_init_at_Complex_2: + li $t1, 0 + sw $t1, -16($fp) +label_init_at_Complex_3: + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 44 + lw $fp, 0($sp) + jr $ra +function_print_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -56 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -8($fp) + lw $t1, -8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_print_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_print_at_Complex_1 +label_print_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_print_at_Complex_1: + lw $a0, -4($fp) + bne $a0, $zero, label_print_at_Complex_2 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -32($fp) + la $t1, _empty + sw $t1, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -32($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -28($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -24($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -24($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -20($fp) + + #fin llamada dinamica + + lw $t1, -20($fp) + sw $t1, -16($fp) + j label_print_at_Complex_3 +label_print_at_Complex_2: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -56($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -52($fp) + lw $t1, -52($fp) + sw $t1, -16($fp) +label_print_at_Complex_3: + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 68 + lw $fp, 0($sp) + jr $ra +function_reflect_0_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + lw $t1, -16($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -12($fp) + lw $t1, -8($fp) + lw $a0, -12($fp) + sub $a0, $t1, $a0 + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_reflect_0_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_reflect_0_at_Complex_1 +label_reflect_0_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_reflect_0_at_Complex_1: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -28($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -36($fp) + lw $t1, -36($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -32($fp) + lw $t1, -28($fp) + lw $a0, -32($fp) + sub $a0, $t1, $a0 + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_reflect_0_at_Complex_2 + li $t1, 1 + sw $t1, -24($fp) + j label_reflect_0_at_Complex_3 +label_reflect_0_at_Complex_2: + li $t1, 0 + sw $t1, -24($fp) +label_reflect_0_at_Complex_3: + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 52 + lw $fp, 0($sp) + jr $ra +function_reflect_X_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -8($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -16($fp) + lw $t1, -16($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -12($fp) + lw $t1, -8($fp) + lw $a0, -12($fp) + sub $a0, $t1, $a0 + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_reflect_X_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_reflect_X_at_Complex_1 +label_reflect_X_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_reflect_X_at_Complex_1: + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 32 + lw $fp, 0($sp) + jr $ra +function_reflect_Y_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + lw $t1, -16($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -12($fp) + lw $t1, -8($fp) + lw $a0, -12($fp) + sub $a0, $t1, $a0 + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_reflect_Y_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_reflect_Y_at_Complex_1 +label_reflect_Y_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_reflect_Y_at_Complex_1: + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 32 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Complex_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Complex_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Complex + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Complex + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/fib.mips b/tests/codegen/fib.mips new file mode 100644 index 000000000..0e2815e03 --- /dev/null +++ b/tests/codegen/fib.mips @@ -0,0 +1,859 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Main_name: .asciiz "Main" + Main_size: .word 12 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_main_at_Main + .word function_fib_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 28($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -28 + la $t1, data_1 + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 20($a0) + jalr $a0 + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -12($fp) + la $t1, data_1 + sw $t1, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -24($fp) + + #retornando el valor + + lw $a0, -24($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 40 + lw $fp, 0($sp) + jr $ra +function_fib_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -36 + li $t1, 1 + sw $t1, -4($fp) + li $t1, 0 + sw $t1, -8($fp) + li $t1, 0 + sw $t1, -12($fp) +label_fib_at_Main_0: + lw $t1, 8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -24($fp) + lw $a0, -24($fp) + bne $a0, $zero, label_fib_at_Main_3 + li $t1, 1 + sw $t1, -20($fp) + j label_fib_at_Main_4 +label_fib_at_Main_3: + li $t1, 0 + sw $t1, -20($fp) +label_fib_at_Main_4: + lw $a0, -20($fp) + bne $a0, $zero, label_fib_at_Main_5 + li $t1, 1 + sw $t1, -16($fp) + j label_fib_at_Main_6 +label_fib_at_Main_5: + li $t1, 0 + sw $t1, -16($fp) +label_fib_at_Main_6: + lw $a0, -16($fp) + bne $a0, $zero, label_fib_at_Main_1 + j label_fib_at_Main_2 +label_fib_at_Main_1: + li $t1, a + li $a0, b + add $a0, $a0, $t1 + sw $a0, -28($fp) + lw $t1, -28($fp) + sw $t1, -12($fp) + lw $t1, 8($fp) + li $a0, 1 + blt $t1, $a0, label_fib_at_Main_7 + li $a0, 0 + j label_fib_at_Main_8 +label_fib_at_Main_7: + li $a0, 1 +label_fib_at_Main_8: + sw $a0, -32($fp) + lw $t1, -32($fp) + sw $t1, 8($fp) + li $t1, a + sw $t1, -8($fp) + li $t1, c + sw $t1, -4($fp) + j label_fib_at_Main_0 +label_fib_at_Main_2: + la $t1, _void + sw $t1, -36($fp) + + #retornando el valor + + li $a0, c + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 52 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/graph.mips b/tests/codegen/graph.mips new file mode 100644 index 000000000..54a974dc2 --- /dev/null +++ b/tests/codegen/graph.mips @@ -0,0 +1,4993 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Graph_name: .asciiz "Graph" + Graph_size: .word 20 +__virtual_table__Graph: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_add_vertice_at_Graph + .word function_print_E_at_Graph + .word function_print_V_at_Graph + Vertice_name: .asciiz "Vertice" + Vertice_size: .word 20 +__virtual_table__Vertice: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_outgoing_at_Vertice + .word function_number_at_Vertice + .word function_init_at_Vertice + .word function_add_out_at_Vertice + .word function_print_at_Vertice + Edge_name: .asciiz "Edge" + Edge_size: .word 24 +__virtual_table__Edge: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_init_at_Edge + .word function_print_at_Edge + EList_name: .asciiz "EList" + EList_size: .word 16 +__virtual_table__EList: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_EList + .word function_head_at_EList + .word function_tail_at_EList + .word function_cons_at_EList + .word function_append_at_EList + .word function_print_at_EList + ECons_name: .asciiz "ECons" + ECons_size: .word 20 +__virtual_table__ECons: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_ECons + .word function_head_at_ECons + .word function_tail_at_ECons + .word function_cons_at_EList + .word function_append_at_EList + .word function_print_at_ECons + .word function_init_at_ECons + VList_name: .asciiz "VList" + VList_size: .word 16 +__virtual_table__VList: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_VList + .word function_head_at_VList + .word function_tail_at_VList + .word function_cons_at_VList + .word function_print_at_VList + VCons_name: .asciiz "VCons" + VCons_size: .word 20 +__virtual_table__VCons: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_VCons + .word function_head_at_VCons + .word function_tail_at_VCons + .word function_cons_at_VList + .word function_print_at_VCons + .word function_init_at_VCons + Parse_name: .asciiz "Parse" + Parse_size: .word 20 +__virtual_table__Parse: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_read_input_at_Parse + .word function_parse_line_at_Parse + .word function_c2i_at_Parse + .word function_a2i_at_Parse + .word function_a2i_aux_at_Parse + Main_name: .asciiz "Main" + Main_size: .word 24 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_read_input_at_Parse + .word function_parse_line_at_Parse + .word function_c2i_at_Parse + .word function_a2i_at_Parse + .word function_a2i_aux_at_Parse + .word function_main_at_Main + BoolOp_name: .asciiz "BoolOp" + BoolOp_size: .word 12 +__virtual_table__BoolOp: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_and_at_BoolOp + .word function_or_at_BoolOp + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 48($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_add_vertice_at_Graph: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, 8($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -8($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -4($fp) + sw $t1, 16($a0) + + #end set attribute + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -20($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -16($fp) + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 36 + lw $fp, 0($sp) + jr $ra +function_print_E_at_Graph: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_print_V_at_Graph: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Graph: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Graph_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Graph_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Graph + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Graph + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Graph: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + la $t1, _void + sw $t1, -8($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 12($a0) + + #end set attribute + + la $t1, _void + sw $t1, -12($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -12($fp) + sw $t1, 16($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_outgoing_at_Vertice: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_number_at_Vertice: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_init_at_Vertice: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_add_out_at_Vertice: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -4($fp) + sw $t1, 16($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_print_at_Vertice: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -4($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Vertice: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Vertice_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Vertice_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Vertice + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Vertice + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Vertice: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 0 + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_init_at_Edge: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 12($fp) + sw $t1, 16($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 16($fp) + sw $t1, 20($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_print_at_Edge: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + la $t1, _empty + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -12($fp) + la $t1, _empty + sw $t1, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -20($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -28($fp) + la $t1, _empty + sw $t1, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -36($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 20($a0) + sw $a0, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -44($fp) + + #retornando el valor + + lw $a0, -44($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Edge: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Edge_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Edge_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Edge + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Edge + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Edge: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_EList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 1 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_head_at_EList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #retornando el valor + + lw $a0, -8($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_tail_at_EList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_cons_at_EList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, ECons_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_ECons + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 52($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_append_at_EList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -24 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + lw $a0, -4($fp) + bne $a0, $zero, label_append_at_EList_0 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -20($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + lw $t1, -12($fp) + sw $t1, -8($fp) + j label_append_at_EList_1 +label_append_at_EList_0: + lw $t1, 8($fp) + sw $t1, -8($fp) +label_append_at_EList_1: + + #retornando el valor + + lw $a0, -8($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 40 + lw $fp, 0($sp) + jr $ra +function_print_at_EList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + la $t1, data_1 + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_EList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, EList_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, EList_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__EList + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_EList + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_EList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_ECons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_head_at_ECons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_tail_at_ECons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_init_at_ECons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 12($fp) + sw $t1, 16($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_print_at_ECons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_ECons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, ECons_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, ECons_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__ECons + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_ECons + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_ECons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_EList + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_VList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 1 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_head_at_VList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #retornando el valor + + lw $a0, -8($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_tail_at_VList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_cons_at_VList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, VCons_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_VCons + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_print_at_VList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + la $t1, data_1 + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_VList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, VList_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, VList_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__VList + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_VList + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_VList: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_VCons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_head_at_VCons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_tail_at_VCons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_init_at_VCons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 12($fp) + sw $t1, 16($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_print_at_VCons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_VCons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, VCons_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, VCons_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__VCons + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_VCons + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_VCons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_VList + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_read_input_at_Parse: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -68 + + #init allocate + + li $v0, 9 + lw $a0, Graph_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Graph + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -16($fp) + lw $t1, -16($fp) + sw $t1, -20($fp) +label_read_input_at_Parse_0: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -28($fp) + la $t1, data_1 + sw $t1, -40($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, None + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_read_input_at_Parse_3 + li $t1, 1 + sw $t1, -32($fp) + j label_read_input_at_Parse_4 +label_read_input_at_Parse_3: + li $t1, 0 + sw $t1, -32($fp) +label_read_input_at_Parse_4: + la $t1, _empty + sw $t1, -52($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, None + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -52($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -48($fp) + lw $a0, -48($fp) + bne $a0, $zero, label_read_input_at_Parse_5 + li $t1, 1 + sw $t1, -44($fp) + j label_read_input_at_Parse_6 +label_read_input_at_Parse_5: + li $t1, 0 + sw $t1, -44($fp) +label_read_input_at_Parse_6: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -28($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -24($fp) + + #fin llamada dinamica + + lw $a0, -24($fp) + bne $a0, $zero, label_read_input_at_Parse_1 + j label_read_input_at_Parse_2 +label_read_input_at_Parse_1: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, line + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -60($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, g + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -56($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -64($fp) + lw $t1, -64($fp) + sw $t1, -20($fp) + j label_read_input_at_Parse_0 +label_read_input_at_Parse_2: + la $t1, _void + sw $t1, -68($fp) + + #retornando el valor + + li $a0, g + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 80 + lw $fp, 0($sp) + jr $ra +function_parse_line_at_Parse: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -88 + + #init allocate + + li $v0, 9 + lw $a0, Vertice_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Vertice + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -20($fp) +label_parse_line_at_Parse_0: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -32($fp) + + #fin llamada dinamica + + lw $t1, -32($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_parse_line_at_Parse_3 + li $t1, 1 + sw $t1, -28($fp) + j label_parse_line_at_Parse_4 +label_parse_line_at_Parse_3: + li $t1, 0 + sw $t1, -28($fp) +label_parse_line_at_Parse_4: + lw $a0, -28($fp) + bne $a0, $zero, label_parse_line_at_Parse_5 + li $t1, 1 + sw $t1, -24($fp) + j label_parse_line_at_Parse_6 +label_parse_line_at_Parse_5: + li $t1, 0 + sw $t1, -24($fp) +label_parse_line_at_Parse_6: + lw $a0, -24($fp) + bne $a0, $zero, label_parse_line_at_Parse_1 + j label_parse_line_at_Parse_2 +label_parse_line_at_Parse_1: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -44($fp) + lw $t1, -44($fp) + sw $t1, -52($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -60($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -56($fp) + lw $t1, -56($fp) + sw $t1, -64($fp) + + #init allocate + + li $v0, 9 + lw $a0, Edge_size + syscall + sw $v0, -76($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -76($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Edge + sw $a0, -80($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, v + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -84($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, weight + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, succ + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -84($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -76($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -76($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -72($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -72($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, v + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -68($fp) + + #fin llamada dinamica + + j label_parse_line_at_Parse_0 +label_parse_line_at_Parse_2: + la $t1, _void + sw $t1, -88($fp) + + #retornando el valor + + li $a0, v + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 104 + lw $fp, 0($sp) + jr $ra +function_c2i_at_Parse: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -124 + la $t1, _empty + sw $t1, -8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -4($fp) + lw $a0, -4($fp) + bne $a0, $zero, label_c2i_at_Parse_0 + la $t1, _empty + sw $t1, -20($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_c2i_at_Parse_2 + la $t1, _empty + sw $t1, -32($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_c2i_at_Parse_4 + la $t1, _empty + sw $t1, -44($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_c2i_at_Parse_6 + la $t1, _empty + sw $t1, -56($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -52($fp) + lw $a0, -52($fp) + bne $a0, $zero, label_c2i_at_Parse_8 + la $t1, _empty + sw $t1, -68($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -64($fp) + lw $a0, -64($fp) + bne $a0, $zero, label_c2i_at_Parse_10 + la $t1, _empty + sw $t1, -80($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -76($fp) + lw $a0, -76($fp) + bne $a0, $zero, label_c2i_at_Parse_12 + la $t1, _empty + sw $t1, -92($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -92($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -88($fp) + lw $a0, -88($fp) + bne $a0, $zero, label_c2i_at_Parse_14 + la $t1, _empty + sw $t1, -104($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -104($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -100($fp) + lw $a0, -100($fp) + bne $a0, $zero, label_c2i_at_Parse_16 + la $t1, _empty + sw $t1, -116($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -116($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -112($fp) + lw $a0, -112($fp) + bne $a0, $zero, label_c2i_at_Parse_18 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -124($fp) + li $t1, 0 + sw $t1, -120($fp) + j label_c2i_at_Parse_19 +label_c2i_at_Parse_18: + li $t1, 9 + sw $t1, -120($fp) +label_c2i_at_Parse_19: + lw $t1, -120($fp) + sw $t1, -108($fp) + j label_c2i_at_Parse_17 +label_c2i_at_Parse_16: + li $t1, 8 + sw $t1, -108($fp) +label_c2i_at_Parse_17: + lw $t1, -108($fp) + sw $t1, -96($fp) + j label_c2i_at_Parse_15 +label_c2i_at_Parse_14: + li $t1, 7 + sw $t1, -96($fp) +label_c2i_at_Parse_15: + lw $t1, -96($fp) + sw $t1, -84($fp) + j label_c2i_at_Parse_13 +label_c2i_at_Parse_12: + li $t1, 6 + sw $t1, -84($fp) +label_c2i_at_Parse_13: + lw $t1, -84($fp) + sw $t1, -72($fp) + j label_c2i_at_Parse_11 +label_c2i_at_Parse_10: + li $t1, 5 + sw $t1, -72($fp) +label_c2i_at_Parse_11: + lw $t1, -72($fp) + sw $t1, -60($fp) + j label_c2i_at_Parse_9 +label_c2i_at_Parse_8: + li $t1, 4 + sw $t1, -60($fp) +label_c2i_at_Parse_9: + lw $t1, -60($fp) + sw $t1, -48($fp) + j label_c2i_at_Parse_7 +label_c2i_at_Parse_6: + li $t1, 3 + sw $t1, -48($fp) +label_c2i_at_Parse_7: + lw $t1, -48($fp) + sw $t1, -36($fp) + j label_c2i_at_Parse_5 +label_c2i_at_Parse_4: + li $t1, 2 + sw $t1, -36($fp) +label_c2i_at_Parse_5: + lw $t1, -36($fp) + sw $t1, -24($fp) + j label_c2i_at_Parse_3 +label_c2i_at_Parse_2: + li $t1, 1 + sw $t1, -24($fp) +label_c2i_at_Parse_3: + lw $t1, -24($fp) + sw $t1, -12($fp) + j label_c2i_at_Parse_1 +label_c2i_at_Parse_0: + li $t1, 0 + sw $t1, -12($fp) +label_c2i_at_Parse_1: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 140 + lw $fp, 0($sp) + jr $ra +function_a2i_at_Parse: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -88 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_a2i_at_Parse_0 + li $t1, 1 + sw $t1, -4($fp) + j label_a2i_at_Parse_1 +label_a2i_at_Parse_0: + li $t1, 0 + sw $t1, -4($fp) +label_a2i_at_Parse_1: + lw $a0, -4($fp) + bne $a0, $zero, label_a2i_at_Parse_2 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 0 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -24($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -28($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_a2i_at_Parse_4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 0 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -40($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -44($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_a2i_at_Parse_6 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -52($fp) + lw $t1, -52($fp) + sw $t1, -48($fp) + j label_a2i_at_Parse_7 +label_a2i_at_Parse_6: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -68($fp) + + #fin llamada dinamica + + lw $t1, -68($fp) + li $a0, 1 + blt $t1, $a0, label_a2i_at_Parse_8 + li $a0, 0 + j label_a2i_at_Parse_9 +label_a2i_at_Parse_8: + li $a0, 1 +label_a2i_at_Parse_9: + sw $a0, -64($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -60($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -56($fp) + lw $t1, -56($fp) + sw $t1, -48($fp) +label_a2i_at_Parse_7: + lw $t1, -48($fp) + sw $t1, -32($fp) + j label_a2i_at_Parse_5 +label_a2i_at_Parse_4: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -88($fp) + + #fin llamada dinamica + + lw $t1, -88($fp) + li $a0, 1 + blt $t1, $a0, label_a2i_at_Parse_10 + li $a0, 0 + j label_a2i_at_Parse_11 +label_a2i_at_Parse_10: + li $a0, 1 +label_a2i_at_Parse_11: + sw $a0, -84($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -84($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -80($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -76($fp) + lw $t1, -76($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -72($fp) + lw $t1, -72($fp) + sw $t1, -32($fp) +label_a2i_at_Parse_5: + lw $t1, -32($fp) + sw $t1, -16($fp) + j label_a2i_at_Parse_3 +label_a2i_at_Parse_2: + li $t1, 0 + sw $t1, -16($fp) +label_a2i_at_Parse_3: + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 104 + lw $fp, 0($sp) + jr $ra +function_a2i_aux_at_Parse: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -132 + li $t1, 0 + sw $t1, -4($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + sw $t1, -12($fp) + li $t1, 0 + sw $t1, -16($fp) +label_a2i_aux_at_Parse_0: + li $a0, [] + bne $a0, $zero, label_a2i_aux_at_Parse_1 + j label_a2i_aux_at_Parse_2 +label_a2i_aux_at_Parse_1: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, i + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -20($fp) + + #fin llamada dinamica + + lw $t1, -20($fp) + sw $t1, -24($fp) + la $t1, _empty + sw $t1, -32($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, None + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_a2i_aux_at_Parse_3 + la $t1, _empty + sw $t1, -44($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, None + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_a2i_aux_at_Parse_5 + li $t1, int + li $a0, 10 + mul $a0 $t1 $a0 + sw $a0, -56($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, i + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -64($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -60($fp) + lw $t1, -56($fp) + lw $a0, -60($fp) + add $a0, $a0, $t1 + sw $a0, -52($fp) + lw $t1, -52($fp) + sw $t1, -4($fp) + li $t1, i + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -68($fp) + lw $t1, -68($fp) + sw $t1, -16($fp) + li $t1, i + li $a0, j + sub $a0, $t1, $a0 + sw $a0, -76($fp) + lw $a0, -76($fp) + bne $a0, $zero, label_a2i_aux_at_Parse_7 + li $t1, 1 + sw $t1, -72($fp) + j label_a2i_aux_at_Parse_8 +label_a2i_aux_at_Parse_7: + li $t1, 0 + sw $t1, -72($fp) +label_a2i_aux_at_Parse_8: + lw $a0, -72($fp) + bne $a0, $zero, label_a2i_aux_at_Parse_9 + la $t1, _empty + sw $t1, -84($fp) + lw $t1, -84($fp) + sw $t1, -80($fp) + j label_a2i_aux_at_Parse_10 +label_a2i_aux_at_Parse_9: + la $t1, _empty + sw $t1, -88($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -88($fp) + sw $t1, 16($a0) + + #end set attribute + + lw $t1, -88($fp) + sw $t1, -80($fp) +label_a2i_aux_at_Parse_10: + lw $t1, -80($fp) + sw $t1, -48($fp) + j label_a2i_aux_at_Parse_6 +label_a2i_aux_at_Parse_5: + li $t1, i + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -96($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -108($fp) + + #fin llamada dinamica + + lw $t1, -108($fp) + li $a0, i + blt $t1, $a0, label_a2i_aux_at_Parse_11 + li $a0, 0 + j label_a2i_aux_at_Parse_12 +label_a2i_aux_at_Parse_11: + li $a0, 1 +label_a2i_aux_at_Parse_12: + sw $a0, -104($fp) + lw $t1, -104($fp) + li $a0, 1 + blt $t1, $a0, label_a2i_aux_at_Parse_13 + li $a0, 0 + j label_a2i_aux_at_Parse_14 +label_a2i_aux_at_Parse_13: + li $a0, 1 +label_a2i_aux_at_Parse_14: + sw $a0, -100($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -100($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -96($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -92($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -92($fp) + sw $t1, 16($a0) + + #end set attribute + + li $t1, j + sw $t1, -16($fp) + li $t1, j + sw $t1, -48($fp) +label_a2i_aux_at_Parse_6: + lw $t1, -48($fp) + sw $t1, -36($fp) + j label_a2i_aux_at_Parse_4 +label_a2i_aux_at_Parse_3: + li $t1, i + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -116($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -128($fp) + + #fin llamada dinamica + + lw $t1, -128($fp) + li $a0, i + blt $t1, $a0, label_a2i_aux_at_Parse_15 + li $a0, 0 + j label_a2i_aux_at_Parse_16 +label_a2i_aux_at_Parse_15: + li $a0, 1 +label_a2i_aux_at_Parse_16: + sw $a0, -124($fp) + lw $t1, -124($fp) + li $a0, 1 + blt $t1, $a0, label_a2i_aux_at_Parse_17 + li $a0, 0 + j label_a2i_aux_at_Parse_18 +label_a2i_aux_at_Parse_17: + li $a0, 1 +label_a2i_aux_at_Parse_18: + sw $a0, -120($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -120($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -116($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -112($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -112($fp) + sw $t1, 16($a0) + + #end set attribute + + li $t1, j + sw $t1, -16($fp) + li $t1, j + sw $t1, -36($fp) +label_a2i_aux_at_Parse_4: + j label_a2i_aux_at_Parse_0 +label_a2i_aux_at_Parse_2: + la $t1, _void + sw $t1, -132($fp) + + #retornando el valor + + li $a0, int + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 148 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Parse: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Parse_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Parse_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Parse + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Parse + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Parse: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + la $t1, _void + sw $t1, -8($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 20($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 20($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 20($a0) + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Parse + sw $a0, -4($fp) + + #fin llamada dinamica + + la $t1, _void + sw $t1, -8($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 20($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_and_at_BoolOp: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + lw $a0, 8($fp) + bne $a0, $zero, label_and_at_BoolOp_0 + li $t1, 0 + sw $t1, -4($fp) + j label_and_at_BoolOp_1 +label_and_at_BoolOp_0: + lw $t1, 12($fp) + sw $t1, -4($fp) +label_and_at_BoolOp_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_or_at_BoolOp: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + lw $a0, 8($fp) + bne $a0, $zero, label_or_at_BoolOp_0 + lw $t1, 12($fp) + sw $t1, -4($fp) + j label_or_at_BoolOp_1 +label_or_at_BoolOp_0: + li $t1, 1 + sw $t1, -4($fp) +label_or_at_BoolOp_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_BoolOp: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, BoolOp_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, BoolOp_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__BoolOp + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_BoolOp + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_BoolOp: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/hairyscary.mips b/tests/codegen/hairyscary.mips new file mode 100644 index 000000000..26c26daa5 --- /dev/null +++ b/tests/codegen/hairyscary.mips @@ -0,0 +1,1507 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Foo_name: .asciiz "Foo" + Foo_size: .word 32 +__virtual_table__Foo: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_printh_at_Bazz + .word function_doh_at_Foo + Bar_name: .asciiz "Bar" + Bar_size: .word 48 +__virtual_table__Bar: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_printh_at_Bazz + .word function_doh_at_Foo + Razz_name: .asciiz "Razz" + Razz_size: .word 40 +__virtual_table__Razz: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_printh_at_Bazz + .word function_doh_at_Foo + Bazz_name: .asciiz "Bazz" + Bazz_size: .word 24 +__virtual_table__Bazz: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_printh_at_Bazz + .word function_doh_at_Bazz + Main_name: .asciiz "Main" + Main_size: .word 28 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_main_at_Main + _empty: .asciiz "" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 12($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_doh_at_Foo: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + lw $t1, -4($fp) + sw $t1, -8($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + lw $t1, -16($fp) + li $a0, 2 + add $a0, $a0, $t1 + sw $a0, -12($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -12($fp) + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + li $a0, i + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Foo: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Foo_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Foo_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Foo + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Foo + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Foo: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -28 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Bazz + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 24($a0) + + #end set attribute + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -24($fp) + lw $t1, -20($fp) + lw $a0, -24($fp) + add $a0, $a0, $t1 + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -28($fp) + lw $t1, -16($fp) + lw $a0, -28($fp) + add $a0, $a0, $t1 + sw $a0, -12($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -12($fp) + sw $t1, 28($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 40 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Bar: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Bar_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Bar_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Bar + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Bar + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Bar: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Razz + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 0 + sw $t1, 40($a0) + + #end set attribute + + la $t1, _void + sw $t1, -8($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 44($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Razz: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Razz_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Razz_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Razz + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Razz + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Razz: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -36 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Foo + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 32($a0) + + #end set attribute + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, e + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -28($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + lw $a0, -28($fp) + add $a0, $a0, $t1 + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -32($fp) + lw $t1, -20($fp) + lw $a0, -32($fp) + add $a0, $a0, $t1 + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -16($fp) + lw $a0, -36($fp) + add $a0, $a0, $t1 + sw $a0, -12($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -12($fp) + sw $t1, 36($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 48 + lw $fp, 0($sp) + jr $ra +function_printh_at_Bazz: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_doh_at_Bazz: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + lw $t1, -4($fp) + sw $t1, -8($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + lw $t1, -16($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -12($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -12($fp) + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + li $a0, i + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Bazz: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Bazz_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Bazz_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Bazz + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Bazz + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Bazz: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 0 + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 16($a0) + + #end set attribute + + la $t1, _void + sw $t1, -12($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -12($fp) + sw $t1, 20($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + la $t1, _empty + sw $t1, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + la $t1, _void + sw $t1, -8($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 12($a0) + + #end set attribute + + la $t1, _void + sw $t1, -12($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -12($fp) + sw $t1, 16($a0) + + #end set attribute + + la $t1, _void + sw $t1, -16($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -16($fp) + sw $t1, 20($a0) + + #end set attribute + + la $t1, _void + sw $t1, -20($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -20($fp) + sw $t1, 24($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 32 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/hello_world.mips b/tests/codegen/hello_world.mips new file mode 100644 index 000000000..a205ae8c1 --- /dev/null +++ b/tests/codegen/hello_world.mips @@ -0,0 +1,703 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Main_name: .asciiz "Main" + Main_size: .word 12 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 28($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + la $t1, data_1 + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/io.mips b/tests/codegen/io.mips new file mode 100644 index 000000000..187646bcf --- /dev/null +++ b/tests/codegen/io.mips @@ -0,0 +1,1552 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + A_name: .asciiz "A" + A_size: .word 16 +__virtual_table__A: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_a_at_A + B_name: .asciiz "B" + B_size: .word 16 +__virtual_table__B: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_a_at_A + .word function_out_b_at_B + C_name: .asciiz "C" + C_size: .word 12 +__virtual_table__C: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_out_c_at_C + D_name: .asciiz "D" + D_size: .word 12 +__virtual_table__D: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_out_c_at_C + .word function_out_d_at_D + Main_name: .asciiz "Main" + Main_size: .word 12 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 28($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_out_a_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + la $t1, data_1 + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, A_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, A_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__A + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_A + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_A: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + la $t1, _void + sw $t1, -8($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_out_b_at_B: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + la $t1, data_1 + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_B: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, B_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, B_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__B + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_B + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_B: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_A + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_out_c_at_C: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + la $t1, data_1 + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_C: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, C_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, C_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__C + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_C + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_C: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_out_d_at_D: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + la $t1, data_1 + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_D: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, D_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, D_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__D + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_D + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_D: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_C + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -56 + + #init allocate + + li $v0, 9 + lw $a0, A_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_A + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init allocate + + li $v0, 9 + lw $a0, B_size + syscall + sw $v0, -20($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_B + sw $a0, -24($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -20($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #init allocate + + li $v0, 9 + lw $a0, C_size + syscall + sw $v0, -32($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_C + sw $a0, -36($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -32($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -28($fp) + + #fin llamada dinamica + + + #init allocate + + li $v0, 9 + lw $a0, D_size + syscall + sw $v0, -44($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_D + sw $a0, -48($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -44($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -40($fp) + + #fin llamada dinamica + + la $t1, data_1 + sw $t1, -56($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -52($fp) + + #retornando el valor + + lw $a0, -52($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 68 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/life.mips b/tests/codegen/life.mips new file mode 100644 index 000000000..f738f9597 --- /dev/null +++ b/tests/codegen/life.mips @@ -0,0 +1,4673 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Board_name: .asciiz "Board" + Board_size: .word 24 +__virtual_table__Board: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_size_of_board_at_Board + .word function_board_init_at_Board + CellularAutomaton_name: .asciiz "CellularAutomaton" + CellularAutomaton_size: .word 28 +__virtual_table__CellularAutomaton: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_size_of_board_at_Board + .word function_board_init_at_Board + .word function_init_at_CellularAutomaton + .word function_print_at_CellularAutomaton + .word function_num_cells_at_CellularAutomaton + .word function_cell_at_CellularAutomaton + .word function_north_at_CellularAutomaton + .word function_south_at_CellularAutomaton + .word function_east_at_CellularAutomaton + .word function_west_at_CellularAutomaton + .word function_northwest_at_CellularAutomaton + .word function_northeast_at_CellularAutomaton + .word function_southeast_at_CellularAutomaton + .word function_southwest_at_CellularAutomaton + .word function_neighbors_at_CellularAutomaton + .word function_cell_at_next_evolution_at_CellularAutomaton + .word function_evolve_at_CellularAutomaton + .word function_option_at_CellularAutomaton + .word function_prompt_at_CellularAutomaton + .word function_prompt2_at_CellularAutomaton + Main_name: .asciiz "Main" + Main_size: .word 32 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_size_of_board_at_Board + .word function_board_init_at_Board + .word function_init_at_CellularAutomaton + .word function_print_at_CellularAutomaton + .word function_num_cells_at_CellularAutomaton + .word function_cell_at_CellularAutomaton + .word function_north_at_CellularAutomaton + .word function_south_at_CellularAutomaton + .word function_east_at_CellularAutomaton + .word function_west_at_CellularAutomaton + .word function_northwest_at_CellularAutomaton + .word function_northeast_at_CellularAutomaton + .word function_southeast_at_CellularAutomaton + .word function_southwest_at_CellularAutomaton + .word function_neighbors_at_CellularAutomaton + .word function_cell_at_next_evolution_at_CellularAutomaton + .word function_evolve_at_CellularAutomaton + .word function_option_at_CellularAutomaton + .word function_prompt_at_CellularAutomaton + .word function_prompt2_at_CellularAutomaton + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + data_2: .asciiz "nn" + data_3: .asciiz " n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 108($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_size_of_board_at_Board: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_board_init_at_Board: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -80 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -4($fp) + lw $t1, -4($fp) + sw $t1, -8($fp) + li $t1, size + li $a0, 15 + sub $a0, $t1, $a0 + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_board_init_at_Board_0 + li $t1, 1 + sw $t1, -12($fp) + j label_board_init_at_Board_1 +label_board_init_at_Board_0: + li $t1, 0 + sw $t1, -12($fp) +label_board_init_at_Board_1: + lw $a0, -12($fp) + bne $a0, $zero, label_board_init_at_Board_2 + li $t1, size + li $a0, 16 + sub $a0, $t1, $a0 + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_board_init_at_Board_4 + li $t1, 1 + sw $t1, -24($fp) + j label_board_init_at_Board_5 +label_board_init_at_Board_4: + li $t1, 0 + sw $t1, -24($fp) +label_board_init_at_Board_5: + lw $a0, -24($fp) + bne $a0, $zero, label_board_init_at_Board_6 + li $t1, size + li $a0, 20 + sub $a0, $t1, $a0 + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_board_init_at_Board_8 + li $t1, 1 + sw $t1, -36($fp) + j label_board_init_at_Board_9 +label_board_init_at_Board_8: + li $t1, 0 + sw $t1, -36($fp) +label_board_init_at_Board_9: + lw $a0, -36($fp) + bne $a0, $zero, label_board_init_at_Board_10 + li $t1, size + li $a0, 21 + sub $a0, $t1, $a0 + sw $a0, -52($fp) + lw $a0, -52($fp) + bne $a0, $zero, label_board_init_at_Board_12 + li $t1, 1 + sw $t1, -48($fp) + j label_board_init_at_Board_13 +label_board_init_at_Board_12: + li $t1, 0 + sw $t1, -48($fp) +label_board_init_at_Board_13: + lw $a0, -48($fp) + bne $a0, $zero, label_board_init_at_Board_14 + li $t1, size + li $a0, 25 + sub $a0, $t1, $a0 + sw $a0, -64($fp) + lw $a0, -64($fp) + bne $a0, $zero, label_board_init_at_Board_16 + li $t1, 1 + sw $t1, -60($fp) + j label_board_init_at_Board_17 +label_board_init_at_Board_16: + li $t1, 0 + sw $t1, -60($fp) +label_board_init_at_Board_17: + lw $a0, -60($fp) + bne $a0, $zero, label_board_init_at_Board_18 + li $t1, size + li $a0, 28 + sub $a0, $t1, $a0 + sw $a0, -76($fp) + lw $a0, -76($fp) + bne $a0, $zero, label_board_init_at_Board_20 + li $t1, 1 + sw $t1, -72($fp) + j label_board_init_at_Board_21 +label_board_init_at_Board_20: + li $t1, 0 + sw $t1, -72($fp) +label_board_init_at_Board_21: + lw $a0, -72($fp) + bne $a0, $zero, label_board_init_at_Board_22 + + #init set attribute + + lw $a0, 4($fp) + li $t1, 5 + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 5 + sw $t1, 16($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, size + sw $t1, 20($a0) + + #end set attribute + + li $t1, size + sw $t1, -80($fp) + j label_board_init_at_Board_23 +label_board_init_at_Board_22: + + #init set attribute + + lw $a0, 4($fp) + li $t1, 7 + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 4 + sw $t1, 16($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, size + sw $t1, 20($a0) + + #end set attribute + + li $t1, size + sw $t1, -80($fp) +label_board_init_at_Board_23: + lw $t1, -80($fp) + sw $t1, -68($fp) + j label_board_init_at_Board_19 +label_board_init_at_Board_18: + + #init set attribute + + lw $a0, 4($fp) + li $t1, 5 + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 5 + sw $t1, 16($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, size + sw $t1, 20($a0) + + #end set attribute + + li $t1, size + sw $t1, -68($fp) +label_board_init_at_Board_19: + lw $t1, -68($fp) + sw $t1, -56($fp) + j label_board_init_at_Board_15 +label_board_init_at_Board_14: + + #init set attribute + + lw $a0, 4($fp) + li $t1, 3 + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 7 + sw $t1, 16($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, size + sw $t1, 20($a0) + + #end set attribute + + li $t1, size + sw $t1, -56($fp) +label_board_init_at_Board_15: + lw $t1, -56($fp) + sw $t1, -44($fp) + j label_board_init_at_Board_11 +label_board_init_at_Board_10: + + #init set attribute + + lw $a0, 4($fp) + li $t1, 4 + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 5 + sw $t1, 16($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, size + sw $t1, 20($a0) + + #end set attribute + + li $t1, size + sw $t1, -44($fp) +label_board_init_at_Board_11: + lw $t1, -44($fp) + sw $t1, -32($fp) + j label_board_init_at_Board_7 +label_board_init_at_Board_6: + + #init set attribute + + lw $a0, 4($fp) + li $t1, 4 + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 4 + sw $t1, 16($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, size + sw $t1, 20($a0) + + #end set attribute + + li $t1, size + sw $t1, -32($fp) +label_board_init_at_Board_7: + lw $t1, -32($fp) + sw $t1, -20($fp) + j label_board_init_at_Board_3 +label_board_init_at_Board_2: + + #init set attribute + + lw $a0, 4($fp) + li $t1, 3 + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 5 + sw $t1, 16($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, size + sw $t1, 20($a0) + + #end set attribute + + li $t1, size + sw $t1, -20($fp) +label_board_init_at_Board_3: + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 96 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Board: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Board_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Board_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Board + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Board + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Board: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_init_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 24($a0) + + #end set attribute + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 32($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_print_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -64 + li $t1, 0 + sw $t1, -4($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 20($a0) + sw $a0, -8($fp) + lw $t1, -8($fp) + sw $t1, -12($fp) + la $t1, data_1 + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -16($fp) +label_print_at_CellularAutomaton_0: + li $a0, [] + bne $a0, $zero, label_print_at_CellularAutomaton_1 + j label_print_at_CellularAutomaton_2 +label_print_at_CellularAutomaton_1: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 24($a0) + sw $a0, -32($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, i + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -28($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -24($fp) + la $t1, data_1 + sw $t1, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -40($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -52($fp) + li $t1, i + lw $a0, -52($fp) + add $a0, $a0, $t1 + sw $a0, -48($fp) + lw $t1, -48($fp) + sw $t1, -4($fp) + j label_print_at_CellularAutomaton_0 +label_print_at_CellularAutomaton_2: + la $t1, _void + sw $t1, -56($fp) + la $t1, data_1 + sw $t1, -64($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -60($fp) + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 76 + lw $fp, 0($sp) + jr $ra +function_num_cells_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 24($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_cell_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + li $a0, [] + bne $a0, $zero, label_cell_at_CellularAutomaton_0 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 24($a0) + sw $a0, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + sw $t1, -4($fp) + j label_cell_at_CellularAutomaton_1 +label_cell_at_CellularAutomaton_0: + la $t1, _empty + sw $t1, -16($fp) + lw $t1, -16($fp) + sw $t1, -4($fp) +label_cell_at_CellularAutomaton_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 32 + lw $fp, 0($sp) + jr $ra +function_north_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + li $a0, [] + bne $a0, $zero, label_north_at_CellularAutomaton_0 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -16($fp) + lw $t1, 8($fp) + lw $a0, -16($fp) + blt $t1, $a0, label_north_at_CellularAutomaton_2 + li $a0, 0 + j label_north_at_CellularAutomaton_3 +label_north_at_CellularAutomaton_2: + li $a0, 1 +label_north_at_CellularAutomaton_3: + sw $a0, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -8($fp) + lw $t1, -8($fp) + sw $t1, -4($fp) + j label_north_at_CellularAutomaton_1 +label_north_at_CellularAutomaton_0: + la $t1, _empty + sw $t1, -20($fp) + lw $t1, -20($fp) + sw $t1, -4($fp) +label_north_at_CellularAutomaton_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 36 + lw $fp, 0($sp) + jr $ra +function_south_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + li $a0, [] + bne $a0, $zero, label_south_at_CellularAutomaton_0 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -16($fp) + lw $t1, 8($fp) + lw $a0, -16($fp) + add $a0, $a0, $t1 + sw $a0, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -8($fp) + lw $t1, -8($fp) + sw $t1, -4($fp) + j label_south_at_CellularAutomaton_1 +label_south_at_CellularAutomaton_0: + la $t1, _empty + sw $t1, -20($fp) + lw $t1, -20($fp) + sw $t1, -4($fp) +label_south_at_CellularAutomaton_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 36 + lw $fp, 0($sp) + jr $ra +function_east_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -16($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -20($fp) + lw $t1, -16($fp) + lw $a0, -20($fp) + div $a0, $t1, $a0 + sw $a0, -12($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -24($fp) + lw $t1, -12($fp) + lw $a0, -24($fp) + mul $a0 $t1 $a0 + sw $a0, -8($fp) + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -28($fp) + lw $t1, -8($fp) + lw $a0, -28($fp) + sub $a0, $t1, $a0 + sw $a0, -32($fp) + lw $a0, -32($fp) + bne $a0, $zero, label_east_at_CellularAutomaton_0 + li $t1, 1 + sw $t1, -4($fp) + j label_east_at_CellularAutomaton_1 +label_east_at_CellularAutomaton_0: + li $t1, 0 + sw $t1, -4($fp) +label_east_at_CellularAutomaton_1: + lw $a0, -4($fp) + bne $a0, $zero, label_east_at_CellularAutomaton_2 + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -40($fp) + lw $t1, -40($fp) + sw $t1, -36($fp) + j label_east_at_CellularAutomaton_3 +label_east_at_CellularAutomaton_2: + la $t1, _empty + sw $t1, -48($fp) + lw $t1, -48($fp) + sw $t1, -36($fp) +label_east_at_CellularAutomaton_3: + + #retornando el valor + + lw $a0, -36($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 64 + lw $fp, 0($sp) + jr $ra +function_west_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -56 + lw $t1, 8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -8($fp) + lw $a0, -8($fp) + bne $a0, $zero, label_west_at_CellularAutomaton_0 + li $t1, 1 + sw $t1, -4($fp) + j label_west_at_CellularAutomaton_1 +label_west_at_CellularAutomaton_0: + li $t1, 0 + sw $t1, -4($fp) +label_west_at_CellularAutomaton_1: + lw $a0, -4($fp) + bne $a0, $zero, label_west_at_CellularAutomaton_2 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -28($fp) + lw $t1, 8($fp) + lw $a0, -28($fp) + div $a0, $t1, $a0 + sw $a0, -24($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -32($fp) + lw $t1, -24($fp) + lw $a0, -32($fp) + mul $a0 $t1 $a0 + sw $a0, -20($fp) + lw $t1, -20($fp) + lw $a0, 8($fp) + sub $a0, $t1, $a0 + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_west_at_CellularAutomaton_4 + li $t1, 1 + sw $t1, -16($fp) + j label_west_at_CellularAutomaton_5 +label_west_at_CellularAutomaton_4: + li $t1, 0 + sw $t1, -16($fp) +label_west_at_CellularAutomaton_5: + lw $a0, -16($fp) + bne $a0, $zero, label_west_at_CellularAutomaton_6 + lw $t1, 8($fp) + li $a0, 1 + blt $t1, $a0, label_west_at_CellularAutomaton_8 + li $a0, 0 + j label_west_at_CellularAutomaton_9 +label_west_at_CellularAutomaton_8: + li $a0, 1 +label_west_at_CellularAutomaton_9: + sw $a0, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -44($fp) + lw $t1, -44($fp) + sw $t1, -40($fp) + j label_west_at_CellularAutomaton_7 +label_west_at_CellularAutomaton_6: + la $t1, _empty + sw $t1, -52($fp) + lw $t1, -52($fp) + sw $t1, -40($fp) +label_west_at_CellularAutomaton_7: + lw $t1, -40($fp) + sw $t1, -12($fp) + j label_west_at_CellularAutomaton_3 +label_west_at_CellularAutomaton_2: + la $t1, _empty + sw $t1, -56($fp) + lw $t1, -56($fp) + sw $t1, -12($fp) +label_west_at_CellularAutomaton_3: + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 72 + lw $fp, 0($sp) + jr $ra +function_northwest_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + li $a0, [] + bne $a0, $zero, label_northwest_at_CellularAutomaton_0 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -20($fp) + lw $t1, 8($fp) + lw $a0, -20($fp) + div $a0, $t1, $a0 + sw $a0, -16($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -24($fp) + lw $t1, -16($fp) + lw $a0, -24($fp) + mul $a0 $t1 $a0 + sw $a0, -12($fp) + lw $t1, -12($fp) + lw $a0, 8($fp) + sub $a0, $t1, $a0 + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_northwest_at_CellularAutomaton_2 + li $t1, 1 + sw $t1, -8($fp) + j label_northwest_at_CellularAutomaton_3 +label_northwest_at_CellularAutomaton_2: + li $t1, 0 + sw $t1, -8($fp) +label_northwest_at_CellularAutomaton_3: + lw $a0, -8($fp) + bne $a0, $zero, label_northwest_at_CellularAutomaton_4 + lw $t1, 8($fp) + li $a0, 1 + blt $t1, $a0, label_northwest_at_CellularAutomaton_6 + li $a0, 0 + j label_northwest_at_CellularAutomaton_7 +label_northwest_at_CellularAutomaton_6: + li $a0, 1 +label_northwest_at_CellularAutomaton_7: + sw $a0, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 52($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -32($fp) + j label_northwest_at_CellularAutomaton_5 +label_northwest_at_CellularAutomaton_4: + la $t1, _empty + sw $t1, -44($fp) + lw $t1, -44($fp) + sw $t1, -32($fp) +label_northwest_at_CellularAutomaton_5: + lw $t1, -32($fp) + sw $t1, -4($fp) + j label_northwest_at_CellularAutomaton_1 +label_northwest_at_CellularAutomaton_0: + la $t1, _empty + sw $t1, -48($fp) + lw $t1, -48($fp) + sw $t1, -4($fp) +label_northwest_at_CellularAutomaton_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 64 + lw $fp, 0($sp) + jr $ra +function_northeast_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -56 + li $a0, [] + bne $a0, $zero, label_northeast_at_CellularAutomaton_0 + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -20($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -24($fp) + lw $t1, -20($fp) + lw $a0, -24($fp) + div $a0, $t1, $a0 + sw $a0, -16($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -28($fp) + lw $t1, -16($fp) + lw $a0, -28($fp) + mul $a0 $t1 $a0 + sw $a0, -12($fp) + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -32($fp) + lw $t1, -12($fp) + lw $a0, -32($fp) + sub $a0, $t1, $a0 + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_northeast_at_CellularAutomaton_2 + li $t1, 1 + sw $t1, -8($fp) + j label_northeast_at_CellularAutomaton_3 +label_northeast_at_CellularAutomaton_2: + li $t1, 0 + sw $t1, -8($fp) +label_northeast_at_CellularAutomaton_3: + lw $a0, -8($fp) + bne $a0, $zero, label_northeast_at_CellularAutomaton_4 + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 52($a0) + jalr $a0 + sw $a0, -44($fp) + lw $t1, -44($fp) + sw $t1, -40($fp) + j label_northeast_at_CellularAutomaton_5 +label_northeast_at_CellularAutomaton_4: + la $t1, _empty + sw $t1, -52($fp) + lw $t1, -52($fp) + sw $t1, -40($fp) +label_northeast_at_CellularAutomaton_5: + lw $t1, -40($fp) + sw $t1, -4($fp) + j label_northeast_at_CellularAutomaton_1 +label_northeast_at_CellularAutomaton_0: + la $t1, _empty + sw $t1, -56($fp) + lw $t1, -56($fp) + sw $t1, -4($fp) +label_northeast_at_CellularAutomaton_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 72 + lw $fp, 0($sp) + jr $ra +function_southeast_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -56 + li $a0, [] + bne $a0, $zero, label_southeast_at_CellularAutomaton_0 + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -20($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -24($fp) + lw $t1, -20($fp) + lw $a0, -24($fp) + div $a0, $t1, $a0 + sw $a0, -16($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -28($fp) + lw $t1, -16($fp) + lw $a0, -28($fp) + mul $a0 $t1 $a0 + sw $a0, -12($fp) + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -32($fp) + lw $t1, -12($fp) + lw $a0, -32($fp) + sub $a0, $t1, $a0 + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_southeast_at_CellularAutomaton_2 + li $t1, 1 + sw $t1, -8($fp) + j label_southeast_at_CellularAutomaton_3 +label_southeast_at_CellularAutomaton_2: + li $t1, 0 + sw $t1, -8($fp) +label_southeast_at_CellularAutomaton_3: + lw $a0, -8($fp) + bne $a0, $zero, label_southeast_at_CellularAutomaton_4 + lw $t1, 8($fp) + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 56($a0) + jalr $a0 + sw $a0, -44($fp) + lw $t1, -44($fp) + sw $t1, -40($fp) + j label_southeast_at_CellularAutomaton_5 +label_southeast_at_CellularAutomaton_4: + la $t1, _empty + sw $t1, -52($fp) + lw $t1, -52($fp) + sw $t1, -40($fp) +label_southeast_at_CellularAutomaton_5: + lw $t1, -40($fp) + sw $t1, -4($fp) + j label_southeast_at_CellularAutomaton_1 +label_southeast_at_CellularAutomaton_0: + la $t1, _empty + sw $t1, -56($fp) + lw $t1, -56($fp) + sw $t1, -4($fp) +label_southeast_at_CellularAutomaton_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 72 + lw $fp, 0($sp) + jr $ra +function_southwest_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + li $a0, [] + bne $a0, $zero, label_southwest_at_CellularAutomaton_0 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -20($fp) + lw $t1, 8($fp) + lw $a0, -20($fp) + div $a0, $t1, $a0 + sw $a0, -16($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -24($fp) + lw $t1, -16($fp) + lw $a0, -24($fp) + mul $a0 $t1 $a0 + sw $a0, -12($fp) + lw $t1, -12($fp) + lw $a0, 8($fp) + sub $a0, $t1, $a0 + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_southwest_at_CellularAutomaton_2 + li $t1, 1 + sw $t1, -8($fp) + j label_southwest_at_CellularAutomaton_3 +label_southwest_at_CellularAutomaton_2: + li $t1, 0 + sw $t1, -8($fp) +label_southwest_at_CellularAutomaton_3: + lw $a0, -8($fp) + bne $a0, $zero, label_southwest_at_CellularAutomaton_4 + lw $t1, 8($fp) + li $a0, 1 + blt $t1, $a0, label_southwest_at_CellularAutomaton_6 + li $a0, 0 + j label_southwest_at_CellularAutomaton_7 +label_southwest_at_CellularAutomaton_6: + li $a0, 1 +label_southwest_at_CellularAutomaton_7: + sw $a0, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 56($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -32($fp) + j label_southwest_at_CellularAutomaton_5 +label_southwest_at_CellularAutomaton_4: + la $t1, _empty + sw $t1, -44($fp) + lw $t1, -44($fp) + sw $t1, -32($fp) +label_southwest_at_CellularAutomaton_5: + lw $t1, -32($fp) + sw $t1, -4($fp) + j label_southwest_at_CellularAutomaton_1 +label_southwest_at_CellularAutomaton_0: + la $t1, _empty + sw $t1, -48($fp) + lw $t1, -48($fp) + sw $t1, -4($fp) +label_southwest_at_CellularAutomaton_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 64 + lw $fp, 0($sp) + jr $ra +function_neighbors_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -156 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 52($a0) + jalr $a0 + sw $a0, -36($fp) + la $t1, _empty + sw $t1, -40($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -32($fp) + lw $a0, -32($fp) + bne $a0, $zero, label_neighbors_at_CellularAutomaton_0 + li $t1, 0 + sw $t1, -44($fp) + j label_neighbors_at_CellularAutomaton_1 +label_neighbors_at_CellularAutomaton_0: + li $t1, 1 + sw $t1, -44($fp) +label_neighbors_at_CellularAutomaton_1: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 56($a0) + jalr $a0 + sw $a0, -52($fp) + la $t1, _empty + sw $t1, -56($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -52($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -48($fp) + lw $a0, -48($fp) + bne $a0, $zero, label_neighbors_at_CellularAutomaton_2 + li $t1, 0 + sw $t1, -60($fp) + j label_neighbors_at_CellularAutomaton_3 +label_neighbors_at_CellularAutomaton_2: + li $t1, 1 + sw $t1, -60($fp) +label_neighbors_at_CellularAutomaton_3: + lw $t1, -44($fp) + lw $a0, -60($fp) + add $a0, $a0, $t1 + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 60($a0) + jalr $a0 + sw $a0, -68($fp) + la $t1, _empty + sw $t1, -72($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -72($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -64($fp) + lw $a0, -64($fp) + bne $a0, $zero, label_neighbors_at_CellularAutomaton_4 + li $t1, 0 + sw $t1, -76($fp) + j label_neighbors_at_CellularAutomaton_5 +label_neighbors_at_CellularAutomaton_4: + li $t1, 1 + sw $t1, -76($fp) +label_neighbors_at_CellularAutomaton_5: + lw $t1, -28($fp) + lw $a0, -76($fp) + add $a0, $a0, $t1 + sw $a0, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 64($a0) + jalr $a0 + sw $a0, -84($fp) + la $t1, _empty + sw $t1, -88($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -84($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -88($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -80($fp) + lw $a0, -80($fp) + bne $a0, $zero, label_neighbors_at_CellularAutomaton_6 + li $t1, 0 + sw $t1, -92($fp) + j label_neighbors_at_CellularAutomaton_7 +label_neighbors_at_CellularAutomaton_6: + li $t1, 1 + sw $t1, -92($fp) +label_neighbors_at_CellularAutomaton_7: + lw $t1, -24($fp) + lw $a0, -92($fp) + add $a0, $a0, $t1 + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 72($a0) + jalr $a0 + sw $a0, -100($fp) + la $t1, _empty + sw $t1, -104($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -100($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -104($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -96($fp) + lw $a0, -96($fp) + bne $a0, $zero, label_neighbors_at_CellularAutomaton_8 + li $t1, 0 + sw $t1, -108($fp) + j label_neighbors_at_CellularAutomaton_9 +label_neighbors_at_CellularAutomaton_8: + li $t1, 1 + sw $t1, -108($fp) +label_neighbors_at_CellularAutomaton_9: + lw $t1, -20($fp) + lw $a0, -108($fp) + add $a0, $a0, $t1 + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 68($a0) + jalr $a0 + sw $a0, -116($fp) + la $t1, _empty + sw $t1, -120($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -116($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -120($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -112($fp) + lw $a0, -112($fp) + bne $a0, $zero, label_neighbors_at_CellularAutomaton_10 + li $t1, 0 + sw $t1, -124($fp) + j label_neighbors_at_CellularAutomaton_11 +label_neighbors_at_CellularAutomaton_10: + li $t1, 1 + sw $t1, -124($fp) +label_neighbors_at_CellularAutomaton_11: + lw $t1, -16($fp) + lw $a0, -124($fp) + add $a0, $a0, $t1 + sw $a0, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 76($a0) + jalr $a0 + sw $a0, -132($fp) + la $t1, _empty + sw $t1, -136($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -132($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -136($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -128($fp) + lw $a0, -128($fp) + bne $a0, $zero, label_neighbors_at_CellularAutomaton_12 + li $t1, 0 + sw $t1, -140($fp) + j label_neighbors_at_CellularAutomaton_13 +label_neighbors_at_CellularAutomaton_12: + li $t1, 1 + sw $t1, -140($fp) +label_neighbors_at_CellularAutomaton_13: + lw $t1, -12($fp) + lw $a0, -140($fp) + add $a0, $a0, $t1 + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 80($a0) + jalr $a0 + sw $a0, -148($fp) + la $t1, _empty + sw $t1, -152($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -148($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -152($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -144($fp) + lw $a0, -144($fp) + bne $a0, $zero, label_neighbors_at_CellularAutomaton_14 + li $t1, 0 + sw $t1, -156($fp) + j label_neighbors_at_CellularAutomaton_15 +label_neighbors_at_CellularAutomaton_14: + li $t1, 1 + sw $t1, -156($fp) +label_neighbors_at_CellularAutomaton_15: + lw $t1, -8($fp) + lw $a0, -156($fp) + add $a0, $a0, $t1 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 172 + lw $fp, 0($sp) + jr $ra +function_cell_at_next_evolution_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -64 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 84($a0) + jalr $a0 + sw $a0, -8($fp) + lw $t1, -8($fp) + li $a0, 3 + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_0 + li $t1, 1 + sw $t1, -4($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_1 +label_cell_at_next_evolution_at_CellularAutomaton_0: + li $t1, 0 + sw $t1, -4($fp) +label_cell_at_next_evolution_at_CellularAutomaton_1: + lw $a0, -4($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_2 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 84($a0) + jalr $a0 + sw $a0, -24($fp) + lw $t1, -24($fp) + li $a0, 2 + sub $a0, $t1, $a0 + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_4 + li $t1, 1 + sw $t1, -20($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_5 +label_cell_at_next_evolution_at_CellularAutomaton_4: + li $t1, 0 + sw $t1, -20($fp) +label_cell_at_next_evolution_at_CellularAutomaton_5: + lw $a0, -20($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_6 + la $t1, _empty + sw $t1, -36($fp) + lw $t1, -36($fp) + sw $t1, -32($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_7 +label_cell_at_next_evolution_at_CellularAutomaton_6: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -44($fp) + la $t1, _empty + sw $t1, -48($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_cell_at_next_evolution_at_CellularAutomaton_8 + la $t1, _empty + sw $t1, -56($fp) + lw $t1, -56($fp) + sw $t1, -52($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_9 +label_cell_at_next_evolution_at_CellularAutomaton_8: + la $t1, _empty + sw $t1, -60($fp) + lw $t1, -60($fp) + sw $t1, -52($fp) +label_cell_at_next_evolution_at_CellularAutomaton_9: + lw $t1, -52($fp) + sw $t1, -32($fp) +label_cell_at_next_evolution_at_CellularAutomaton_7: + lw $t1, -32($fp) + sw $t1, -16($fp) + j label_cell_at_next_evolution_at_CellularAutomaton_3 +label_cell_at_next_evolution_at_CellularAutomaton_2: + la $t1, _empty + sw $t1, -64($fp) + lw $t1, -64($fp) + sw $t1, -16($fp) +label_cell_at_next_evolution_at_CellularAutomaton_3: + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 80 + lw $fp, 0($sp) + jr $ra +function_evolve_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -36 + li $t1, 0 + sw $t1, -4($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -8($fp) + lw $t1, -8($fp) + sw $t1, -12($fp) + la $t1, _empty + sw $t1, -16($fp) + lw $t1, -16($fp) + sw $t1, -20($fp) +label_evolve_at_CellularAutomaton_0: + li $a0, [] + bne $a0, $zero, label_evolve_at_CellularAutomaton_1 + j label_evolve_at_CellularAutomaton_2 +label_evolve_at_CellularAutomaton_1: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, position + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 88($a0) + jalr $a0 + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, temp + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_concat_at_String + sw $a0, -24($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + sw $t1, -20($fp) + li $t1, position + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -32($fp) + lw $t1, -32($fp) + sw $t1, -4($fp) + j label_evolve_at_CellularAutomaton_0 +label_evolve_at_CellularAutomaton_2: + la $t1, _void + sw $t1, -36($fp) + + #init set attribute + + lw $a0, 4($fp) + li $t1, temp + sw $t1, 24($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 48 + lw $fp, 0($sp) + jr $ra +function_option_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -540 + li $t1, 0 + sw $t1, -4($fp) + la $t1, data_2 + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -8($fp) + la $t1, data_3 + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -16($fp) + la $t1, data_3 + sw $t1, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -24($fp) + la $t1, data_3 + sw $t1, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -32($fp) + la $t1, data_3 + sw $t1, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -40($fp) + la $t1, data_3 + sw $t1, -52($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -52($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -48($fp) + la $t1, data_3 + sw $t1, -60($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -56($fp) + la $t1, data_3 + sw $t1, -68($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -64($fp) + la $t1, data_3 + sw $t1, -76($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -76($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -72($fp) + la $t1, data_3 + sw $t1, -84($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -84($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -80($fp) + la $t1, data_3 + sw $t1, -92($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -92($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -88($fp) + la $t1, data_3 + sw $t1, -100($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -100($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -96($fp) + la $t1, data_3 + sw $t1, -108($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -108($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -104($fp) + la $t1, data_3 + sw $t1, -116($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -116($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -112($fp) + la $t1, data_3 + sw $t1, -124($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -124($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -120($fp) + la $t1, data_3 + sw $t1, -132($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -132($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -128($fp) + la $t1, data_3 + sw $t1, -140($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -140($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -136($fp) + la $t1, data_3 + sw $t1, -148($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -148($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -144($fp) + la $t1, data_3 + sw $t1, -156($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -156($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -152($fp) + la $t1, data_3 + sw $t1, -164($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -164($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -160($fp) + la $t1, data_3 + sw $t1, -172($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -172($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -168($fp) + la $t1, data_3 + sw $t1, -180($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -180($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -176($fp) + la $t1, _empty + sw $t1, -188($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -188($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -184($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 20($a0) + jalr $a0 + sw $a0, -192($fp) + lw $t1, -192($fp) + sw $t1, -4($fp) + la $t1, data_1 + sw $t1, -200($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -200($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -196($fp) + li $t1, num + li $a0, 1 + sub $a0, $t1, $a0 + sw $a0, -208($fp) + lw $a0, -208($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_0 + li $t1, 1 + sw $t1, -204($fp) + j label_option_at_CellularAutomaton_1 +label_option_at_CellularAutomaton_0: + li $t1, 0 + sw $t1, -204($fp) +label_option_at_CellularAutomaton_1: + lw $a0, -204($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_2 + li $t1, num + li $a0, 2 + sub $a0, $t1, $a0 + sw $a0, -220($fp) + lw $a0, -220($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_4 + li $t1, 1 + sw $t1, -216($fp) + j label_option_at_CellularAutomaton_5 +label_option_at_CellularAutomaton_4: + li $t1, 0 + sw $t1, -216($fp) +label_option_at_CellularAutomaton_5: + lw $a0, -216($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_6 + li $t1, num + li $a0, 3 + sub $a0, $t1, $a0 + sw $a0, -232($fp) + lw $a0, -232($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_8 + li $t1, 1 + sw $t1, -228($fp) + j label_option_at_CellularAutomaton_9 +label_option_at_CellularAutomaton_8: + li $t1, 0 + sw $t1, -228($fp) +label_option_at_CellularAutomaton_9: + lw $a0, -228($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_10 + li $t1, num + li $a0, 4 + sub $a0, $t1, $a0 + sw $a0, -244($fp) + lw $a0, -244($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_12 + li $t1, 1 + sw $t1, -240($fp) + j label_option_at_CellularAutomaton_13 +label_option_at_CellularAutomaton_12: + li $t1, 0 + sw $t1, -240($fp) +label_option_at_CellularAutomaton_13: + lw $a0, -240($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_14 + li $t1, num + li $a0, 5 + sub $a0, $t1, $a0 + sw $a0, -256($fp) + lw $a0, -256($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_16 + li $t1, 1 + sw $t1, -252($fp) + j label_option_at_CellularAutomaton_17 +label_option_at_CellularAutomaton_16: + li $t1, 0 + sw $t1, -252($fp) +label_option_at_CellularAutomaton_17: + lw $a0, -252($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_18 + li $t1, num + li $a0, 6 + sub $a0, $t1, $a0 + sw $a0, -268($fp) + lw $a0, -268($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_20 + li $t1, 1 + sw $t1, -264($fp) + j label_option_at_CellularAutomaton_21 +label_option_at_CellularAutomaton_20: + li $t1, 0 + sw $t1, -264($fp) +label_option_at_CellularAutomaton_21: + lw $a0, -264($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_22 + li $t1, num + li $a0, 7 + sub $a0, $t1, $a0 + sw $a0, -280($fp) + lw $a0, -280($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_24 + li $t1, 1 + sw $t1, -276($fp) + j label_option_at_CellularAutomaton_25 +label_option_at_CellularAutomaton_24: + li $t1, 0 + sw $t1, -276($fp) +label_option_at_CellularAutomaton_25: + lw $a0, -276($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_26 + li $t1, num + li $a0, 8 + sub $a0, $t1, $a0 + sw $a0, -292($fp) + lw $a0, -292($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_28 + li $t1, 1 + sw $t1, -288($fp) + j label_option_at_CellularAutomaton_29 +label_option_at_CellularAutomaton_28: + li $t1, 0 + sw $t1, -288($fp) +label_option_at_CellularAutomaton_29: + lw $a0, -288($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_30 + li $t1, num + li $a0, 9 + sub $a0, $t1, $a0 + sw $a0, -304($fp) + lw $a0, -304($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_32 + li $t1, 1 + sw $t1, -300($fp) + j label_option_at_CellularAutomaton_33 +label_option_at_CellularAutomaton_32: + li $t1, 0 + sw $t1, -300($fp) +label_option_at_CellularAutomaton_33: + lw $a0, -300($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_34 + li $t1, num + li $a0, 10 + sub $a0, $t1, $a0 + sw $a0, -316($fp) + lw $a0, -316($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_36 + li $t1, 1 + sw $t1, -312($fp) + j label_option_at_CellularAutomaton_37 +label_option_at_CellularAutomaton_36: + li $t1, 0 + sw $t1, -312($fp) +label_option_at_CellularAutomaton_37: + lw $a0, -312($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_38 + li $t1, num + li $a0, 11 + sub $a0, $t1, $a0 + sw $a0, -328($fp) + lw $a0, -328($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_40 + li $t1, 1 + sw $t1, -324($fp) + j label_option_at_CellularAutomaton_41 +label_option_at_CellularAutomaton_40: + li $t1, 0 + sw $t1, -324($fp) +label_option_at_CellularAutomaton_41: + lw $a0, -324($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_42 + li $t1, num + li $a0, 12 + sub $a0, $t1, $a0 + sw $a0, -340($fp) + lw $a0, -340($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_44 + li $t1, 1 + sw $t1, -336($fp) + j label_option_at_CellularAutomaton_45 +label_option_at_CellularAutomaton_44: + li $t1, 0 + sw $t1, -336($fp) +label_option_at_CellularAutomaton_45: + lw $a0, -336($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_46 + li $t1, num + li $a0, 13 + sub $a0, $t1, $a0 + sw $a0, -352($fp) + lw $a0, -352($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_48 + li $t1, 1 + sw $t1, -348($fp) + j label_option_at_CellularAutomaton_49 +label_option_at_CellularAutomaton_48: + li $t1, 0 + sw $t1, -348($fp) +label_option_at_CellularAutomaton_49: + lw $a0, -348($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_50 + li $t1, num + li $a0, 14 + sub $a0, $t1, $a0 + sw $a0, -364($fp) + lw $a0, -364($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_52 + li $t1, 1 + sw $t1, -360($fp) + j label_option_at_CellularAutomaton_53 +label_option_at_CellularAutomaton_52: + li $t1, 0 + sw $t1, -360($fp) +label_option_at_CellularAutomaton_53: + lw $a0, -360($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_54 + li $t1, num + li $a0, 15 + sub $a0, $t1, $a0 + sw $a0, -376($fp) + lw $a0, -376($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_56 + li $t1, 1 + sw $t1, -372($fp) + j label_option_at_CellularAutomaton_57 +label_option_at_CellularAutomaton_56: + li $t1, 0 + sw $t1, -372($fp) +label_option_at_CellularAutomaton_57: + lw $a0, -372($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_58 + li $t1, num + li $a0, 16 + sub $a0, $t1, $a0 + sw $a0, -388($fp) + lw $a0, -388($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_60 + li $t1, 1 + sw $t1, -384($fp) + j label_option_at_CellularAutomaton_61 +label_option_at_CellularAutomaton_60: + li $t1, 0 + sw $t1, -384($fp) +label_option_at_CellularAutomaton_61: + lw $a0, -384($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_62 + li $t1, num + li $a0, 17 + sub $a0, $t1, $a0 + sw $a0, -400($fp) + lw $a0, -400($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_64 + li $t1, 1 + sw $t1, -396($fp) + j label_option_at_CellularAutomaton_65 +label_option_at_CellularAutomaton_64: + li $t1, 0 + sw $t1, -396($fp) +label_option_at_CellularAutomaton_65: + lw $a0, -396($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_66 + li $t1, num + li $a0, 18 + sub $a0, $t1, $a0 + sw $a0, -412($fp) + lw $a0, -412($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_68 + li $t1, 1 + sw $t1, -408($fp) + j label_option_at_CellularAutomaton_69 +label_option_at_CellularAutomaton_68: + li $t1, 0 + sw $t1, -408($fp) +label_option_at_CellularAutomaton_69: + lw $a0, -408($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_70 + li $t1, num + li $a0, 19 + sub $a0, $t1, $a0 + sw $a0, -424($fp) + lw $a0, -424($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_72 + li $t1, 1 + sw $t1, -420($fp) + j label_option_at_CellularAutomaton_73 +label_option_at_CellularAutomaton_72: + li $t1, 0 + sw $t1, -420($fp) +label_option_at_CellularAutomaton_73: + lw $a0, -420($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_74 + li $t1, num + li $a0, 20 + sub $a0, $t1, $a0 + sw $a0, -436($fp) + lw $a0, -436($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_76 + li $t1, 1 + sw $t1, -432($fp) + j label_option_at_CellularAutomaton_77 +label_option_at_CellularAutomaton_76: + li $t1, 0 + sw $t1, -432($fp) +label_option_at_CellularAutomaton_77: + lw $a0, -432($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_78 + li $t1, num + li $a0, 21 + sub $a0, $t1, $a0 + sw $a0, -448($fp) + lw $a0, -448($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_80 + li $t1, 1 + sw $t1, -444($fp) + j label_option_at_CellularAutomaton_81 +label_option_at_CellularAutomaton_80: + li $t1, 0 + sw $t1, -444($fp) +label_option_at_CellularAutomaton_81: + lw $a0, -444($fp) + bne $a0, $zero, label_option_at_CellularAutomaton_82 + la $t1, _empty + sw $t1, -456($fp) + lw $t1, -456($fp) + sw $t1, -452($fp) + j label_option_at_CellularAutomaton_83 +label_option_at_CellularAutomaton_82: + la $t1, _empty + sw $t1, -460($fp) + lw $t1, -460($fp) + sw $t1, -452($fp) +label_option_at_CellularAutomaton_83: + lw $t1, -452($fp) + sw $t1, -440($fp) + j label_option_at_CellularAutomaton_79 +label_option_at_CellularAutomaton_78: + la $t1, _empty + sw $t1, -464($fp) + lw $t1, -464($fp) + sw $t1, -440($fp) +label_option_at_CellularAutomaton_79: + lw $t1, -440($fp) + sw $t1, -428($fp) + j label_option_at_CellularAutomaton_75 +label_option_at_CellularAutomaton_74: + la $t1, _empty + sw $t1, -468($fp) + lw $t1, -468($fp) + sw $t1, -428($fp) +label_option_at_CellularAutomaton_75: + lw $t1, -428($fp) + sw $t1, -416($fp) + j label_option_at_CellularAutomaton_71 +label_option_at_CellularAutomaton_70: + la $t1, _empty + sw $t1, -472($fp) + lw $t1, -472($fp) + sw $t1, -416($fp) +label_option_at_CellularAutomaton_71: + lw $t1, -416($fp) + sw $t1, -404($fp) + j label_option_at_CellularAutomaton_67 +label_option_at_CellularAutomaton_66: + la $t1, _empty + sw $t1, -476($fp) + lw $t1, -476($fp) + sw $t1, -404($fp) +label_option_at_CellularAutomaton_67: + lw $t1, -404($fp) + sw $t1, -392($fp) + j label_option_at_CellularAutomaton_63 +label_option_at_CellularAutomaton_62: + la $t1, _empty + sw $t1, -480($fp) + lw $t1, -480($fp) + sw $t1, -392($fp) +label_option_at_CellularAutomaton_63: + lw $t1, -392($fp) + sw $t1, -380($fp) + j label_option_at_CellularAutomaton_59 +label_option_at_CellularAutomaton_58: + la $t1, _empty + sw $t1, -484($fp) + lw $t1, -484($fp) + sw $t1, -380($fp) +label_option_at_CellularAutomaton_59: + lw $t1, -380($fp) + sw $t1, -368($fp) + j label_option_at_CellularAutomaton_55 +label_option_at_CellularAutomaton_54: + la $t1, _empty + sw $t1, -488($fp) + lw $t1, -488($fp) + sw $t1, -368($fp) +label_option_at_CellularAutomaton_55: + lw $t1, -368($fp) + sw $t1, -356($fp) + j label_option_at_CellularAutomaton_51 +label_option_at_CellularAutomaton_50: + la $t1, _empty + sw $t1, -492($fp) + lw $t1, -492($fp) + sw $t1, -356($fp) +label_option_at_CellularAutomaton_51: + lw $t1, -356($fp) + sw $t1, -344($fp) + j label_option_at_CellularAutomaton_47 +label_option_at_CellularAutomaton_46: + la $t1, _empty + sw $t1, -496($fp) + lw $t1, -496($fp) + sw $t1, -344($fp) +label_option_at_CellularAutomaton_47: + lw $t1, -344($fp) + sw $t1, -332($fp) + j label_option_at_CellularAutomaton_43 +label_option_at_CellularAutomaton_42: + la $t1, _empty + sw $t1, -500($fp) + lw $t1, -500($fp) + sw $t1, -332($fp) +label_option_at_CellularAutomaton_43: + lw $t1, -332($fp) + sw $t1, -320($fp) + j label_option_at_CellularAutomaton_39 +label_option_at_CellularAutomaton_38: + la $t1, _empty + sw $t1, -504($fp) + lw $t1, -504($fp) + sw $t1, -320($fp) +label_option_at_CellularAutomaton_39: + lw $t1, -320($fp) + sw $t1, -308($fp) + j label_option_at_CellularAutomaton_35 +label_option_at_CellularAutomaton_34: + la $t1, _empty + sw $t1, -508($fp) + lw $t1, -508($fp) + sw $t1, -308($fp) +label_option_at_CellularAutomaton_35: + lw $t1, -308($fp) + sw $t1, -296($fp) + j label_option_at_CellularAutomaton_31 +label_option_at_CellularAutomaton_30: + la $t1, _empty + sw $t1, -512($fp) + lw $t1, -512($fp) + sw $t1, -296($fp) +label_option_at_CellularAutomaton_31: + lw $t1, -296($fp) + sw $t1, -284($fp) + j label_option_at_CellularAutomaton_27 +label_option_at_CellularAutomaton_26: + la $t1, _empty + sw $t1, -516($fp) + lw $t1, -516($fp) + sw $t1, -284($fp) +label_option_at_CellularAutomaton_27: + lw $t1, -284($fp) + sw $t1, -272($fp) + j label_option_at_CellularAutomaton_23 +label_option_at_CellularAutomaton_22: + la $t1, _empty + sw $t1, -520($fp) + lw $t1, -520($fp) + sw $t1, -272($fp) +label_option_at_CellularAutomaton_23: + lw $t1, -272($fp) + sw $t1, -260($fp) + j label_option_at_CellularAutomaton_19 +label_option_at_CellularAutomaton_18: + la $t1, _empty + sw $t1, -524($fp) + lw $t1, -524($fp) + sw $t1, -260($fp) +label_option_at_CellularAutomaton_19: + lw $t1, -260($fp) + sw $t1, -248($fp) + j label_option_at_CellularAutomaton_15 +label_option_at_CellularAutomaton_14: + la $t1, _empty + sw $t1, -528($fp) + lw $t1, -528($fp) + sw $t1, -248($fp) +label_option_at_CellularAutomaton_15: + lw $t1, -248($fp) + sw $t1, -236($fp) + j label_option_at_CellularAutomaton_11 +label_option_at_CellularAutomaton_10: + la $t1, _empty + sw $t1, -532($fp) + lw $t1, -532($fp) + sw $t1, -236($fp) +label_option_at_CellularAutomaton_11: + lw $t1, -236($fp) + sw $t1, -224($fp) + j label_option_at_CellularAutomaton_7 +label_option_at_CellularAutomaton_6: + la $t1, _empty + sw $t1, -536($fp) + lw $t1, -536($fp) + sw $t1, -224($fp) +label_option_at_CellularAutomaton_7: + lw $t1, -224($fp) + sw $t1, -212($fp) + j label_option_at_CellularAutomaton_3 +label_option_at_CellularAutomaton_2: + la $t1, _empty + sw $t1, -540($fp) + lw $t1, -540($fp) + sw $t1, -212($fp) +label_option_at_CellularAutomaton_3: + + #retornando el valor + + lw $a0, -212($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 552 + lw $fp, 0($sp) + jr $ra +function_prompt_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + la $t1, _empty + sw $t1, -4($fp) + lw $t1, -4($fp) + sw $t1, -8($fp) + la $t1, data_1 + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -12($fp) + la $t1, _empty + sw $t1, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -28($fp) + lw $t1, -28($fp) + sw $t1, -8($fp) + la $t1, data_1 + sw $t1, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -32($fp) + la $t1, _empty + sw $t1, -44($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, None + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_prompt_at_CellularAutomaton_0 + li $t1, 1 + sw $t1, -48($fp) + j label_prompt_at_CellularAutomaton_1 +label_prompt_at_CellularAutomaton_0: + li $t1, 0 + sw $t1, -48($fp) +label_prompt_at_CellularAutomaton_1: + + #retornando el valor + + lw $a0, -48($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_prompt2_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + la $t1, _empty + sw $t1, -4($fp) + lw $t1, -4($fp) + sw $t1, -8($fp) + la $t1, data_2 + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -12($fp) + la $t1, data_1 + sw $t1, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -20($fp) + la $t1, _empty + sw $t1, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -8($fp) + la $t1, _empty + sw $t1, -44($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, None + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_prompt2_at_CellularAutomaton_0 + li $t1, 0 + sw $t1, -48($fp) + j label_prompt2_at_CellularAutomaton_1 +label_prompt2_at_CellularAutomaton_0: + li $t1, 1 + sw $t1, -48($fp) +label_prompt2_at_CellularAutomaton_1: + + #retornando el valor + + lw $a0, -48($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, CellularAutomaton_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, CellularAutomaton_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__CellularAutomaton + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_CellularAutomaton + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_CellularAutomaton: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Board + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -88 + li $t1, 0 + sw $t1, -4($fp) + la $t1, _empty + sw $t1, -8($fp) + lw $t1, -8($fp) + sw $t1, -12($fp) + la $t1, data_1 + sw $t1, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -16($fp) + la $t1, data_1 + sw $t1, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -24($fp) +label_main_at_Main_0: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 104($a0) + jalr $a0 + sw $a0, -32($fp) + lw $a0, -32($fp) + bne $a0, $zero, label_main_at_Main_1 + j label_main_at_Main_2 +label_main_at_Main_1: + li $t1, 1 + sw $t1, -4($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 96($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -12($fp) + + #init allocate + + li $v0, 9 + lw $a0, CellularAutomaton_size + syscall + sw $v0, -44($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_CellularAutomaton + sw $a0, -48($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, choice + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -44($fp) + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -40($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -40($fp) + sw $t1, 28($a0) + + #end set attribute + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 28($a0) + sw $a0, -56($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -56($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -52($fp) + + #fin llamada dinamica + +label_main_at_Main_3: + li $a0, continue + bne $a0, $zero, label_main_at_Main_4 + j label_main_at_Main_5 +label_main_at_Main_4: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 100($a0) + jalr $a0 + sw $a0, -60($fp) + lw $a0, -60($fp) + bne $a0, $zero, label_main_at_Main_6 + li $t1, 0 + sw $t1, -4($fp) + li $t1, 0 + sw $t1, -64($fp) + j label_main_at_Main_7 +label_main_at_Main_6: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 28($a0) + sw $a0, -72($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -72($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -72($fp) + lw $a0, 8($a0) + lw $a0, 92($a0) + jalr $a0 + sw $a0, -68($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 28($a0) + sw $a0, -80($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -80($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -76($fp) + + #fin llamada dinamica + + lw $t1, -76($fp) + sw $t1, -64($fp) +label_main_at_Main_7: + j label_main_at_Main_3 +label_main_at_Main_5: + la $t1, _void + sw $t1, -84($fp) + j label_main_at_Main_0 +label_main_at_Main_2: + la $t1, _void + sw $t1, -88($fp) + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 100 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_CellularAutomaton + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/list.mips b/tests/codegen/list.mips new file mode 100644 index 000000000..afb919b26 --- /dev/null +++ b/tests/codegen/list.mips @@ -0,0 +1,1647 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + List_name: .asciiz "List" + List_size: .word 12 +__virtual_table__List: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_isNil_at_List + .word function_head_at_List + .word function_tail_at_List + .word function_cons_at_List + Cons_name: .asciiz "Cons" + Cons_size: .word 20 +__virtual_table__Cons: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_isNil_at_Cons + .word function_head_at_Cons + .word function_tail_at_Cons + .word function_cons_at_List + .word function_init_at_Cons + Main_name: .asciiz "Main" + Main_size: .word 16 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_print_list_at_Main + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 32($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_isNil_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 1 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_head_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_tail_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_cons_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Cons_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Cons + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, List_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, List_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__List + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_List + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Object + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_head_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_tail_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_init_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 12($fp) + sw $t1, 16($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Cons_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Cons_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Cons + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Cons + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_List + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_print_list_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, 8($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + lw $a0, -4($fp) + bne $a0, $zero, label_print_list_at_Main_0 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, 8($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -12($fp) + la $t1, _empty + sw $t1, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, 8($fp) + lw $a0, 8($a0) + lw $a0, 20($a0) + jalr $a0 + sw $a0, -32($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -28($fp) + lw $t1, -28($fp) + sw $t1, -8($fp) + j label_print_list_at_Main_1 +label_print_list_at_Main_0: + la $t1, data_1 + sw $t1, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -8($fp) +label_print_list_at_Main_1: + + #retornando el valor + + lw $a0, -8($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 56 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -60 + + #init allocate + + li $v0, 9 + lw $a0, List_size + syscall + sw $v0, -24($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_List + sw $a0, -28($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -24($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -20($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 2 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -20($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 3 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -12($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 5 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -4($fp) + sw $t1, 12($a0) + + #end set attribute + +label_main_at_Main_0: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -40($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -36($fp) + + #fin llamada dinamica + + lw $a0, -36($fp) + bne $a0, $zero, label_main_at_Main_3 + li $t1, 1 + sw $t1, -32($fp) + j label_main_at_Main_4 +label_main_at_Main_3: + li $t1, 0 + sw $t1, -32($fp) +label_main_at_Main_4: + lw $a0, -32($fp) + bne $a0, $zero, label_main_at_Main_1 + j label_main_at_Main_2 +label_main_at_Main_1: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -44($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -56($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -56($fp) + lw $a0, 8($a0) + lw $a0, 20($a0) + jalr $a0 + sw $a0, -52($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -52($fp) + sw $t1, 12($a0) + + #end set attribute + + j label_main_at_Main_0 +label_main_at_Main_2: + la $t1, _void + sw $t1, -60($fp) + + #retornando el valor + + lw $a0, -60($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 72 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/new_complex.mips b/tests/codegen/new_complex.mips new file mode 100644 index 000000000..f25261c3f --- /dev/null +++ b/tests/codegen/new_complex.mips @@ -0,0 +1,1714 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Main_name: .asciiz "Main" + Main_size: .word 12 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_main_at_Main + Complex_name: .asciiz "Complex" + Complex_size: .word 20 +__virtual_table__Complex: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_init_at_Complex + .word function_print_at_Complex + .word function_reflect_0_at_Complex + .word function_reflect_X_at_Complex + .word function_reflect_Y_at_Complex + .word function_equal_at_Complex + .word function_x_value_at_Complex + .word function_y_value_at_Complex + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 28($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -88 + + #init allocate + + li $v0, 9 + lw $a0, Complex_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Complex + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, c + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -24($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, c + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -28($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + lw $a0, -28($fp) + sub $a0, $t1, $a0 + sw $a0, -32($fp) + lw $a0, -32($fp) + bne $a0, $zero, label_main_at_Main_0 + li $t1, 1 + sw $t1, -20($fp) + j label_main_at_Main_1 +label_main_at_Main_0: + li $t1, 0 + sw $t1, -20($fp) +label_main_at_Main_1: + lw $a0, -20($fp) + bne $a0, $zero, label_main_at_Main_2 + la $t1, data_1 + sw $t1, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -40($fp) + lw $t1, -40($fp) + sw $t1, -36($fp) + j label_main_at_Main_3 +label_main_at_Main_2: + la $t1, data_1 + sw $t1, -52($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -52($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -48($fp) + lw $t1, -48($fp) + sw $t1, -36($fp) +label_main_at_Main_3: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, c + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -64($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -64($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -60($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, c + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 36($a0) + jalr $a0 + sw $a0, -68($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -60($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -60($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -56($fp) + + #fin llamada dinamica + + lw $a0, -56($fp) + bne $a0, $zero, label_main_at_Main_4 + la $t1, data_1 + sw $t1, -80($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -80($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -76($fp) + lw $t1, -76($fp) + sw $t1, -72($fp) + j label_main_at_Main_5 +label_main_at_Main_4: + la $t1, data_1 + sw $t1, -88($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -88($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -84($fp) + lw $t1, -84($fp) + sw $t1, -72($fp) +label_main_at_Main_5: + + #retornando el valor + + lw $a0, -72($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 100 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_init_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -24 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + lw $t1, -8($fp) + lw $a0, 8($fp) + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_init_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_init_at_Complex_1 +label_init_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_init_at_Complex_1: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -20($fp) + lw $t1, -20($fp) + lw $a0, 12($fp) + sub $a0, $t1, $a0 + sw $a0, -24($fp) + lw $a0, -24($fp) + bne $a0, $zero, label_init_at_Complex_2 + li $t1, 1 + sw $t1, -16($fp) + j label_init_at_Complex_3 +label_init_at_Complex_2: + li $t1, 0 + sw $t1, -16($fp) +label_init_at_Complex_3: + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 44 + lw $fp, 0($sp) + jr $ra +function_print_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -56 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -8($fp) + lw $t1, -8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_print_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_print_at_Complex_1 +label_print_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_print_at_Complex_1: + lw $a0, -4($fp) + bne $a0, $zero, label_print_at_Complex_2 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -36($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -32($fp) + la $t1, _empty + sw $t1, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -32($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -44($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -28($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -24($fp) + + #fin llamada dinamica + + la $t1, _empty + sw $t1, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -24($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -20($fp) + + #fin llamada dinamica + + lw $t1, -20($fp) + sw $t1, -16($fp) + j label_print_at_Complex_3 +label_print_at_Complex_2: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -56($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -56($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -52($fp) + lw $t1, -52($fp) + sw $t1, -16($fp) +label_print_at_Complex_3: + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 68 + lw $fp, 0($sp) + jr $ra +function_reflect_0_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + lw $t1, -16($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -12($fp) + lw $t1, -8($fp) + lw $a0, -12($fp) + sub $a0, $t1, $a0 + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_reflect_0_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_reflect_0_at_Complex_1 +label_reflect_0_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_reflect_0_at_Complex_1: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -28($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -36($fp) + lw $t1, -36($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -32($fp) + lw $t1, -28($fp) + lw $a0, -32($fp) + sub $a0, $t1, $a0 + sw $a0, -40($fp) + lw $a0, -40($fp) + bne $a0, $zero, label_reflect_0_at_Complex_2 + li $t1, 1 + sw $t1, -24($fp) + j label_reflect_0_at_Complex_3 +label_reflect_0_at_Complex_2: + li $t1, 0 + sw $t1, -24($fp) +label_reflect_0_at_Complex_3: + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 52 + lw $fp, 0($sp) + jr $ra +function_reflect_X_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -8($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -16($fp) + lw $t1, -16($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -12($fp) + lw $t1, -8($fp) + lw $a0, -12($fp) + sub $a0, $t1, $a0 + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_reflect_X_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_reflect_X_at_Complex_1 +label_reflect_X_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_reflect_X_at_Complex_1: + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 32 + lw $fp, 0($sp) + jr $ra +function_reflect_Y_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -20 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + lw $t1, -16($fp) + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -12($fp) + lw $t1, -8($fp) + lw $a0, -12($fp) + sub $a0, $t1, $a0 + sw $a0, -20($fp) + lw $a0, -20($fp) + bne $a0, $zero, label_reflect_Y_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_reflect_Y_at_Complex_1 +label_reflect_Y_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_reflect_Y_at_Complex_1: + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 32 + lw $fp, 0($sp) + jr $ra +function_equal_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, 8($fp) + lw $a0, 8($a0) + lw $a0, 52($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + lw $a0, -12($fp) + sub $a0, $t1, $a0 + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_equal_at_Complex_0 + li $t1, 1 + sw $t1, -4($fp) + j label_equal_at_Complex_1 +label_equal_at_Complex_0: + li $t1, 0 + sw $t1, -4($fp) +label_equal_at_Complex_1: + lw $a0, -4($fp) + bne $a0, $zero, label_equal_at_Complex_2 + li $t1, 0 + sw $t1, -20($fp) + j label_equal_at_Complex_3 +label_equal_at_Complex_2: + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, 8($fp) + lw $a0, 8($a0) + lw $a0, 56($a0) + jalr $a0 + sw $a0, -32($fp) + + #fin llamada dinamica + + lw $t1, -28($fp) + lw $a0, -32($fp) + sub $a0, $t1, $a0 + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_equal_at_Complex_4 + li $t1, 1 + sw $t1, -24($fp) + j label_equal_at_Complex_5 +label_equal_at_Complex_4: + li $t1, 0 + sw $t1, -24($fp) +label_equal_at_Complex_5: + lw $a0, -24($fp) + bne $a0, $zero, label_equal_at_Complex_6 + li $t1, 0 + sw $t1, -40($fp) + j label_equal_at_Complex_7 +label_equal_at_Complex_6: + li $t1, 1 + sw $t1, -40($fp) +label_equal_at_Complex_7: + lw $t1, -40($fp) + sw $t1, -20($fp) +label_equal_at_Complex_3: + + #retornando el valor + + lw $a0, -20($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 56 + lw $fp, 0($sp) + jr $ra +function_x_value_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_y_value_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Complex_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Complex_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Complex + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Complex + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Complex: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/palindrome.mips b/tests/codegen/palindrome.mips new file mode 100644 index 000000000..955e13cc2 --- /dev/null +++ b/tests/codegen/palindrome.mips @@ -0,0 +1,1076 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Main_name: .asciiz "Main" + Main_size: .word 16 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_pal_at_Main + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 32($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_pal_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -72 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + li $a0, 0 + sub $a0, $t1, $a0 + sw $a0, -12($fp) + lw $a0, -12($fp) + bne $a0, $zero, label_pal_at_Main_0 + li $t1, 1 + sw $t1, -4($fp) + j label_pal_at_Main_1 +label_pal_at_Main_0: + li $t1, 0 + sw $t1, -4($fp) +label_pal_at_Main_1: + lw $a0, -4($fp) + bne $a0, $zero, label_pal_at_Main_2 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -24($fp) + + #fin llamada dinamica + + lw $t1, -24($fp) + li $a0, 1 + sub $a0, $t1, $a0 + sw $a0, -28($fp) + lw $a0, -28($fp) + bne $a0, $zero, label_pal_at_Main_4 + li $t1, 1 + sw $t1, -20($fp) + j label_pal_at_Main_5 +label_pal_at_Main_4: + li $t1, 0 + sw $t1, -20($fp) +label_pal_at_Main_5: + lw $a0, -20($fp) + bne $a0, $zero, label_pal_at_Main_6 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 0 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -40($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -52($fp) + + #fin llamada dinamica + + lw $t1, -52($fp) + li $a0, 1 + blt $t1, $a0, label_pal_at_Main_8 + li $a0, 0 + j label_pal_at_Main_9 +label_pal_at_Main_8: + li $a0, 1 +label_pal_at_Main_9: + sw $a0, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -44($fp) + + #fin llamada dinamica + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -44($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_comparer_string + sw $a0, -36($fp) + lw $a0, -36($fp) + bne $a0, $zero, label_pal_at_Main_10 + li $t1, 0 + sw $t1, -56($fp) + j label_pal_at_Main_11 +label_pal_at_Main_10: + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_length_at_String + sw $a0, -72($fp) + + #fin llamada dinamica + + lw $t1, -72($fp) + li $a0, 2 + blt $t1, $a0, label_pal_at_Main_12 + li $a0, 0 + j label_pal_at_Main_13 +label_pal_at_Main_12: + li $a0, 1 +label_pal_at_Main_13: + sw $a0, -68($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -68($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -64($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -64($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -60($fp) + lw $t1, -60($fp) + sw $t1, -56($fp) +label_pal_at_Main_11: + lw $t1, -56($fp) + sw $t1, -32($fp) + j label_pal_at_Main_7 +label_pal_at_Main_6: + li $t1, 1 + sw $t1, -32($fp) +label_pal_at_Main_7: + lw $t1, -32($fp) + sw $t1, -16($fp) + j label_pal_at_Main_3 +label_pal_at_Main_2: + li $t1, 1 + sw $t1, -16($fp) +label_pal_at_Main_3: + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 88 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + li $t1, 1 + li $t2, -1 + mul $t1 $t1 $t2 + sw $t1, -4($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -4($fp) + sw $t1, 12($a0) + + #end set attribute + + la $t1, data_1 + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 24($a0) + jalr $a0 + sw $a0, -20($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -16($fp) + lw $a0, -16($fp) + bne $a0, $zero, label_main_at_Main_0 + la $t1, data_1 + sw $t1, -32($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -28($fp) + lw $t1, -28($fp) + sw $t1, -24($fp) + j label_main_at_Main_1 +label_main_at_Main_0: + la $t1, data_1 + sw $t1, -40($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -36($fp) + lw $t1, -36($fp) + sw $t1, -24($fp) +label_main_at_Main_1: + + #retornando el valor + + lw $a0, -24($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 52 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/primes.mips b/tests/codegen/primes.mips new file mode 100644 index 000000000..7b989c7eb --- /dev/null +++ b/tests/codegen/primes.mips @@ -0,0 +1,733 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Main_name: .asciiz "Main" + Main_size: .word 32 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_main_at_Main + _empty: .asciiz "" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 28($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -8 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -8($fp) + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 0 + sw $t1, 16($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 0 + sw $t1, 20($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + li $t1, 500 + sw $t1, 24($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/print-cool.mips b/tests/codegen/print-cool.mips new file mode 100644 index 000000000..9c7626a73 --- /dev/null +++ b/tests/codegen/print-cool.mips @@ -0,0 +1,914 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + Main_name: .asciiz "Main" + Main_size: .word 12 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 28($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -48 + + #init allocate + + li $v0, 9 + lw $a0, Object_size + syscall + sw $v0, -20($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Object + sw $a0, -24($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -20($fp) + lw $a0, 8($a0) + lw $a0, 4($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -8($fp) + lw $t1, 4($fp) + li $a0, 1 + la $t2, _void + bne $t1, $t2, label_main_at_Main_0 + li $a0, 0 +label_main_at_Main_0: + sw $a0, -36($fp) + + #init allocate + + li $v0, 9 + lw $a0, Bool_size + syscall + sw $v0, -40($fp) + + #end allocate + + + #init set attribute + + lw $a0, -40($fp) + lw $t1, -36($fp) + sw $t1, 12($a0) + + #end set attribute + + + #LOAD inicia + + la $t1, Bool_name + lw $t2, -40($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Bool_size + lw $t2, -40($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Bool + lw $t2, -40($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -40($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -40($fp) + lw $a0, 8($a0) + lw $a0, 4($a0) + jalr $a0 + sw $a0, -32($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + li $a0, 3 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, 1 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -32($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_substr_at_String + sw $a0, -28($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + la $t1, data_1 + sw $t1, -48($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -48($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -44($fp) + + #retornando el valor + + lw $a0, -44($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 60 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file diff --git a/tests/codegen/sort-list.mips b/tests/codegen/sort-list.mips new file mode 100644 index 000000000..746de2712 --- /dev/null +++ b/tests/codegen/sort-list.mips @@ -0,0 +1,2614 @@ +.data + Int_name: .asciiz "Int" + Int_size: .word 16 +__virtual_table__Int: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + String_name: .asciiz "String" + String_size: .word 16 +__virtual_table__String: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_length_at_String + .word function_concat_at_String + .word function_substr_at_String + Bool_name: .asciiz "Bool" + Bool_size: .word 16 +__virtual_table__Bool: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + Object_name: .asciiz "Object" + Object_size: .word 12 +__virtual_table__Object: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + IO_name: .asciiz "IO" + IO_size: .word 12 +__virtual_table__IO: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + List_name: .asciiz "List" + List_size: .word 12 +__virtual_table__List: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_List + .word function_cons_at_List + .word function_car_at_List + .word function_cdr_at_List + .word function_rev_at_List + .word function_sort_at_List + .word function_insert_at_List + .word function_rcons_at_List + .word function_print_list_at_List + Cons_name: .asciiz "Cons" + Cons_size: .word 20 +__virtual_table__Cons: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_Cons + .word function_cons_at_List + .word function_car_at_Cons + .word function_cdr_at_Cons + .word function_rev_at_Cons + .word function_sort_at_Cons + .word function_insert_at_Cons + .word function_rcons_at_Cons + .word function_print_list_at_Cons + .word function_init_at_Cons + Nil_name: .asciiz "Nil" + Nil_size: .word 12 +__virtual_table__Nil: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_isNil_at_Nil + .word function_cons_at_List + .word function_car_at_List + .word function_cdr_at_List + .word function_rev_at_Nil + .word function_sort_at_Nil + .word function_insert_at_Nil + .word function_rcons_at_Nil + .word function_print_list_at_Nil + Main_name: .asciiz "Main" + Main_size: .word 16 +__virtual_table__Main: + .word function_abort_at_Object + .word function_type_name_at_Object + .word function_copy_at_Object + .word function_out_string_at_IO + .word function_out_int_at_IO + .word function_in_int_at_IO + .word function_in_string_at_IO + .word function_iota_at_Main + .word function_main_at_Main + _empty: .asciiz "" + data_1: .asciiz "n" + _error1: .asciiz "Abort called from class " + _salto_para_abort: .asciiz " +" + _buffer: .space 2048 + _void: .asciiz "" + + +.text +main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Main_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Main + sw $a0, -8($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + la $a0, __virtual_table__Main + lw $a0, 32($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_isNil_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + li $a0, 1 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_cons_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init allocate + + li $v0, 9 + lw $a0, Cons_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Cons + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -4($fp) + sw $t1, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, new_cell + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, None + lw $a0, 8($a0) + lw $a0, 64($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -16($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 32 + lw $fp, 0($sp) + jr $ra +function_car_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_cdr_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #init allocate + + li $v0, 9 + lw $a0, List_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_List + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -8($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 24 + lw $fp, 0($sp) + jr $ra +function_rev_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_sort_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_insert_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_rcons_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 40($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_print_list_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 0($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, List_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, List_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__List + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_List + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_List: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 0 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_init_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 8($fp) + sw $t1, 12($a0) + + #end set attribute + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, 12($fp) + sw $t1, 16($a0) + + #end set attribute + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_car_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_cdr_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_rev_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -12($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -8($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 56($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_sort_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -16 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -12($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -12($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -8($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 52($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_insert_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + li $a0, [] + bne $a0, $zero, label_insert_at_Cons_0 + + #init allocate + + li $v0, 9 + lw $a0, Cons_size + syscall + sw $v0, -12($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Cons + sw $a0, -16($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -20($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -28($fp) + lw $a0, 8($a0) + lw $a0, 52($a0) + jalr $a0 + sw $a0, -24($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -12($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -12($fp) + lw $a0, 8($a0) + lw $a0, 64($a0) + jalr $a0 + sw $a0, -8($fp) + + #fin llamada dinamica + + lw $t1, -8($fp) + sw $t1, -4($fp) + j label_insert_at_Cons_1 +label_insert_at_Cons_0: + + #init allocate + + li $v0, 9 + lw $a0, Cons_size + syscall + sw $v0, -36($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Cons + sw $a0, -40($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -36($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -36($fp) + lw $a0, 8($a0) + lw $a0, 64($a0) + jalr $a0 + sw $a0, -32($fp) + + #fin llamada dinamica + + lw $t1, -32($fp) + sw $t1, -4($fp) +label_insert_at_Cons_1: + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 56 + lw $fp, 0($sp) + jr $ra +function_rcons_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -24 + + #init allocate + + li $v0, 9 + lw $a0, Cons_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Cons + sw $a0, -12($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -16($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -24($fp) + lw $a0, 8($a0) + lw $a0, 56($a0) + jalr $a0 + sw $a0, -20($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 64($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 40 + lw $fp, 0($sp) + jr $ra +function_print_list_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -24 + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 16($a0) + jalr $a0 + sw $a0, -4($fp) + la $t1, data_1 + sw $t1, -16($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -12($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 16($a0) + sw $a0, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -24($fp) + lw $a0, 8($a0) + lw $a0, 60($a0) + jalr $a0 + sw $a0, -20($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -20($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 36 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Cons_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Cons_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Cons + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Cons + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Cons: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_List + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_isNil_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 1 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_rev_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_sort_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_insert_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 56($a0) + jalr $a0 + sw $a0, -4($fp) + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra +function_rcons_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -12 + + #init allocate + + li $v0, 9 + lw $a0, Cons_size + syscall + sw $v0, -8($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Cons + sw $a0, -12($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -8($fp) + lw $a0, 8($a0) + lw $a0, 64($a0) + jalr $a0 + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 28 + lw $fp, 0($sp) + jr $ra +function_print_list_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -0 + + #retornando el valor + + li $a0, 1 + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Nil_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Nil_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Nil + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Nil + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Nil: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_List + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_iota_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -40 + + #init allocate + + li $v0, 9 + lw $a0, Nil_size + syscall + sw $v0, -4($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Nil + sw $a0, -8($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -4($fp) + sw $t1, 12($a0) + + #end set attribute + + li $t1, 0 + sw $t1, -12($fp) +label_iota_at_Main_0: + li $a0, [] + bne $a0, $zero, label_iota_at_Main_1 + j label_iota_at_Main_2 +label_iota_at_Main_1: + + #init allocate + + li $v0, 9 + lw $a0, Cons_size + syscall + sw $v0, -20($fp) + + #end allocate + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Ctr_at_Cons + sw $a0, -24($fp) + + #fin llamada dinamica + + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + li $a0, j + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -20($fp) + lw $a0, 8($a0) + lw $a0, 64($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #init set attribute + + lw $a0, 4($fp) + lw $t1, -16($fp) + sw $t1, 12($a0) + + #end set attribute + + li $t1, j + li $a0, 1 + add $a0, $a0, $t1 + sw $a0, -32($fp) + lw $t1, -32($fp) + sw $t1, -12($fp) + j label_iota_at_Main_0 +label_iota_at_Main_2: + la $t1, _void + sw $t1, -36($fp) + + #init get attribute + + lw $a0, 4($fp) + lw $a0, 12($a0) + sw $a0, -40($fp) + + #retornando el valor + + lw $a0, -40($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 56 + lw $fp, 0($sp) + jr $ra +function_main_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -28 + la $t1, _empty + sw $t1, -8($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -8($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 12($a0) + jalr $a0 + sw $a0, -4($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 20($a0) + jalr $a0 + sw $a0, -28($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -28($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + lw $a0, 4($fp) + lw $a0, 8($a0) + lw $a0, 28($a0) + jalr $a0 + sw $a0, -24($fp) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -24($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -24($fp) + lw $a0, 8($a0) + lw $a0, 44($a0) + jalr $a0 + sw $a0, -20($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -20($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -20($fp) + lw $a0, 8($a0) + lw $a0, 48($a0) + jalr $a0 + sw $a0, -16($fp) + + #fin llamada dinamica + + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, -16($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada dinamica + + lw $a0, -16($fp) + lw $a0, 8($a0) + lw $a0, 60($a0) + jalr $a0 + sw $a0, -12($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, -12($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 40 + lw $fp, 0($sp) + jr $ra +function_Ctr_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #LOAD inicia + + la $t1, Main_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + #LOAD inicia + + lw $t1, Main_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + #LOAD inicia + + la $t1, __virtual_table__Main + lw $t2, 4($fp) + sw $t1, 8($t2) + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_Main + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra +function_Init_at_Main: + + #muevo el fp al sp, pongo en sp ra y avanzo la pila + + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + #muevo la pila x las variables locales + + addiu $sp, $sp, -4 + + #guardando los parametros + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + # fin guardando los parametros + + + #comienzo llamada al constructor + + jal function_Init_at_IO + sw $a0, -4($fp) + + #fin llamada dinamica + + + #retornando el valor + + lw $a0, 4($fp) + + #return sp, fp, ra + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_Ctr_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, Object_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, Object_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__Object + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Ctr_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $t1, IO_name + lw $t2, 4($fp) + sw $t1, 0($t2) + + lw $t1, IO_size + lw $t2, 4($fp) + sw $t1, 4($t2) + + la $t1, __virtual_table__IO + lw $t2, 4($fp) + sw $t1, 8($t2) + + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_Init_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_type_name_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + lw $a0, 4($fp) + lw $a0 0($a0) + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_abort_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + la $a0, _error1 + li $v0, 4 + syscall + lw $a0 4($fp) + lw $a0 ($a0) + li $v0, 4 + syscall + la $a0, _salto_para_abort + li $v0, 4 + syscall + li $v0, 10 + syscall + +function_copy_at_Object: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Int_name + + bne $a0, $t0, not_int + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_int: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, Bool_name + + bne $a0, $t0, not_bool + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_bool: + lw $a0, 4($fp) + lw $a0, 0($a0) + la $t0, String_name + + bne $a0, $t0, not_string + lw $a0, 4($fp) + lw $a0, 8($a0) + j end + + not_string: + lw $a0, 4($fp) + move $t2, $a0 + lw $a0, 4($a0) + move $t1, $a0 + + li $v0, 9 + syscall + + move $a0, $v0 + + copy: + lw $t0, 0($t2) + sw $t0, 0($a0) + addiu $a0, $a0, 4 + addiu $t2, $t2, 4 + addiu $t1, $t1, -4 + bne $t1, $zero, copy + + move $a0, $v0 + + end: + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_length_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s0, 4($fp) + li $a0, -1 + + length: + lb $t0, ($s0) + addiu $a0, $a0, 1 + addiu $s0, $s0, 1 + bne $t0, $zero, length + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_concat_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + move $t6, $a0 + add $a0, $t7, $t6 + addiu $a0, $a0, 1 + + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + copy_self: + lb $t5, ($s1) + beq $t5, $zero, end_copy_self + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + j copy_self + + end_copy_self: + lw $s1, 8($fp) + + copy_given: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + bne $t5, $zero, copy_given + + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + +function_substr_at_String: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 12($fp) + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + + lw $s1, 4($fp) + lw $t1, 8($fp) + add $s1, $s1, $t1 + + lw $t1, 12($fp) + + substr: + lb $t5, ($s1) + sb $t5, ($t0) + addiu $s1, $s1, 1 + addiu $t0, $t0, 1 + addiu $t1, $t1, -1 + bne $t1, $zero, substr + + sb $zero, ($t0) + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 20 + lw $fp, 0($sp) + jr $ra + + +function_comparer_string: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 4($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + sw $a0, 0($sp) + addiu $sp, $sp, -4 + + lw $s1, 8($fp) + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $s1, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + lw $t7, 4($sp) + addiu $sp, $sp, 4 + + bne $t7, $a0, not_equals_strings + + lw $t7, 4($fp) + lw $a0, 8($fp) + + equal_chart: + lb $t1, ($t7) + lb $t2, ($a0) + addiu $t7, $t7, 1 + addiu $a0, $a0, 1 + bne $t1, $t2, not_equals_strings + beq $t1, $zero, equals_strings + j equal_chart + + not_equals_strings: + li $a0, 0 + j end_equal_string + + equals_strings: + li $a0, 1 + + end_equal_string: + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + + + +function_out_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 4 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_out_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 8($fp) + li $v0, 1 + syscall + + lw $a0, 4($fp) + + lw $ra, 0($fp) + addiu $sp, $sp, 16 + lw $fp, 0($sp) + jr $ra + +function_in_int_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + lw $a0, 4($fp) + li $v0, 5 + syscall + + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + +function_in_string_at_IO: + move $fp, $sp + sw $ra, 0($sp) + addiu $sp, $sp, -4 + + la $a0, _buffer + li $a1, 1024 + + li $v0, 8 + syscall + + sw $fp, 0($sp) + addiu $sp, $sp, -4 + sw $a0, 0($sp) + addiu $sp, $sp, -4 + jal function_length_at_String + + addiu $a0, $a0, 1 + li $v0, 9 + syscall + + move $t0, $v0 + la $a0, _buffer + + IO_copy: + lb $t1, ($a0) + sb $t1, ($t0) + addiu $a0, $a0, 1 + addiu $t0, $t0, 1 + bne $t1, $zero, IO_copy + + addiu $t0, $t0, -2 + li $t1 10 + lb $t2, ($t0) + bne $t1 , $t2 not_slash + sb $zero, ($t0) + + not_slash: + move $a0, $v0 + + lw $ra, 0($fp) + addiu $sp, $sp, 12 + lw $fp, 0($sp) + jr $ra + + \ No newline at end of file