% ===============================================================
% MAIN.TEX: Orb Language Reference Manual
% ===============================================================
% Copyright (C) 2007 Adrián Fraga Fernandez
% Permission is granted to copy, distribute and/or modify this 
% document under the terms of the GNU Free Documentation License, 
% Version 1.2 or any later version published by the Free Software 
% Foundation; with no Invariant Sections, no Front-Cover Texts, 
% and no Back-Cover Texts.  A copy of the license is included in 
% the section entitled "GNU Free Documentation License".
% ===============================================================

\documentclass[a4paper,12pt]{book}
\usepackage[utf8]{inputenc}
\usepackage[spanish]{babel}
\usepackage[print]{estilo}
\input{macros}

\begin{document}
\newcommand  {\titulomanual}  {Manual de Referencia del Lenguaje}
\newcommand  {\orbversion}    {0.1-beta}

	% Portada

\include{portada}

	% Indice

\setcounter{tocdepth}{3}
\setcounter{page}{1}
\pagenumbering{roman}
\tableofcontents

	% Memoria

\startdocument

%-------------------------------------------------------------------------------------------
\chapter{Convenciones\label{convenciones}}
%-------------------------------------------------------------------------------------------
	
	Durante la presente especificación se utilizarán las siguientes convenciones:
	
	\begin{enumerate}
		\item \emph{Convenciones Gramaticales}:
			\begin{itemize}
			\item \uno{$\omega$} indica \emph{una} ocurrencia de $\omega$
			\item \cerouno{$\omega$} indica \emph{cero o una} ocurrencias de $\omega$
			\item \ceromas{$\omega$} indica \emph{cero o más} ocurrencias de $\omega$
			\item \unomas{$\omega$} indica \emph{una o más} ocurrencias de $\omega$
			\item $\omega_1$\obien$\omega_2$ indica $\omega_1$ \emph{o bien} $\omega_2$
			\item $\epsilon$ representa al símbolo vacío
			\end{itemize}
		\item \emph{Convenciones Semánticas}:
			\begin{itemize}
			\item $\omega_1$ $\equiv$ $\omega_2$ indica que $\omega_1$ \emph{equivale a} $\omega_2$
			\item \ident{} representa un \emph{identificador} (\ref{identificadores}) válido.
			\item \expresion{} representa una \emph{expresion} (\ref{expresiones}) válida. 
			\end{itemize}
	\end{enumerate}

%-------------------------------------------------------------------------------------------
\chapter{Análisis léxico\label{analisislexico}}
%-------------------------------------------------------------------------------------------

	Los ficheros de entrada se considerarán a efectos prácticos como una sucesión de componentes léxicos o \emph{tokens}. 
	
	Son componentes léxicos válidos las marcas de sangrado (\ref{sangrado}), simbolos y palabras reservadas del lenguaje (\ref{palabrasreservadas}), identificadores (\ref{identificadores}), números enteros (\ref{numerosenteros}), números reales (\ref{numerosreales}) y cadenas de caracteres (\ref{cadenasdecaracteres}).
	
	Los \emph{comentarios} (\ref{comentarios}) no juegan ningun papel en la generación de código y son ignorados a todos efectos. Las directivas (\ref{directivas}) tienen un significado especial (que puede afectar a la generación de código) pero tampoco son consideradas \emph{tokens}\footnote{A pesar de poder repercutir en el análisis sintáctico posterior, las directivas se procesan completamente durante la fase de análisis léxico y no se envían como entrada a fases posteriores de compilación.}.

	\parrafo{Política de emparejamiento}
	
	En caso de existir más de un emparejamiento posible entre la secuencia de caracteres de entrada y varios \emph{tokens}, sólo se considerará el emparejamiento más largo, cuyo resultado sea una cadena de caracteres de longitud máxima respecto al resto de posibles emparejamientos. Los espacios en blanco y finalizadores de linea pueden y deben ser utilizados para la separaración efectiva de componentes léxicos.
	
%-------------------------------------------------------------------------------------------
\section{Juego de caracteres\label{seccioncodificacion}\label{codificacion}\label{juegodecaracteres}}
%-------------------------------------------------------------------------------------------

	El juego de caracteres para los ficheros de entrada será ASCII de 8 bits. Por consiguiente, se entenderá como \emph{letras} al conjunto definido por dicha codificación, en concreto los caracteres ASCII \code{a}, \code{b}, \code{c}, \code{d}, \code{e}, \code{f}, \code{g}, \code{h}, \code{i}, \code{j}, \code{k}, \code{l}, \code{m}, \code{n}, \code{o}, \code{p}, \code{q}, \code{r}, \code{s}, \code{t}, \code{u}, \code{v}, \code{w}, \code{x}, \code{y}, \code{z}, \code{A}, \code{B}, \code{C}, \code{D}, \code{E}, \code{F}, \code{G}, \code{H}, \code{I}, \code{J}, \code{K}, \code{L}, \code{M}, \code{N}, \code{O}, \code{P}, \code{Q}, \code{R}, \code{S}, \code{T}, \code{U}, \code{V}, \code{W}, \code{X}, \code{Y} y \code{Z}.
	
	Se considerarán \emph{dígitos decimales} a los caracteres ASCII \code{0}, \code{1}, \code{2}, \code{3}, \code{4}, \code{5}, \code{6}, \code{7}, \code{8} y \code{9}, \emph{dígitos hexadecimales} a \code{0}, \code{1}, \code{2}, \code{3}, \code{4}, \code{5}, \code{6}, \code{7}, \code{8}, \code{9}, \code{A}, \code{B}, \code{C}, \code{D}, \code{E} y \code{F}, \emph{dígitos octales} a \code{0}, \code{1}, \code{2}, \code{3}, \code{4}, \code{5}, \code{6} y \code{7}, y \emph{dígitos binarios} a \code{0} y \code{1}. Cuando se hable sólamente de \emph{dígitos}, se entenderá que se trata del conjunto de los dígitos decimales.
	
	Finalmente, se considerarán como \emph{fin de linea (EOL)} a los caracteres \emph{newline} (ASCII \code{LF}), \emph{return} (ASCII \code{CR}) y a la combinación \emph{newline+return} (ASCII \code{CR+LF}), y como \emph{espacios en blanco} a \emph{space} (ASCII \code{SP}), \emph{horizontal tab} (ASCII \code{HT}) y \emph{form feed} (ASCII \code{FF}).
	
	En ningún caso se distinguirá entre mayúsculas y minúsculas. Así por ejemplo los símbolos ASCII \code{f} y \code{F} representan la misma letra o dígito hexadecimal a todos los efectos.

%-------------------------------------------------------------------------------------------
\section{División en íneas y sangrado\label{sangrado}}
%------------------------------------------------------------------------------------------
		
	La división de un programa en líneas y las diferencias de sangrado entre cada línea son propiedades léxicas relevantes

\parrafo{División en líneas}

	Un programa se divide en líneas de acuerdo a la presencia de caracteres de fin de línea (\ref{juegodecaracteres}). Un caracter de fín de línea representa el fin de una línea y el comienzo de la siguiente. Asimismo, el comienzo de un programa es un comienzo de línea y el fin de un programa un fin de línea.
	
\parrafo{Líneas en blanco}
	
	Se consideran líneas en blanco aquellas que, además de espacios en blanco, no contengan ningún \emph{token} válido (\ref{analisislexico}). Las líneas en blanco serán ignoradas a todos los efectos.

\parrafo{Unión explícita de líneas}
	
	Se puede evitar explícitamente una división de línea utilizando el carácter barra invertida (\code{\codebackslash}) inmediatamente antes de un fin de línea. En tal caso, tanto la barra como el fin de línea serán ignorados a todos los efectos.
	
\parrafo{Sangrado}
	
	Una línea presenta sangrado si el primer o primeros caracteres de la misma son espacios en blanco (\ref{juegodecaracteres}). El nivel o magnitud del sangrado depende del tipo de espacios en blanco. Así, el caracter ASCII \code{SP} (\textit{space}) representa un incremento en una unidad del nivel de sangrado y el caracter ASCII \code{HT} (\textit{horizontal tab}) representa un ajuste del nivel de sangrado al próximo múltiplo de 8. El carácter ASCII \code{FF} (\textit{form feed}) no tiene efecto sobre el nivel de sangrado.	
	
%-------------------------------------------------------------------------------------------
\section{Simbolos y palabras reservadas\label{palabrasreservadas}}
%-------------------------------------------------------------------------------------------
		
	Los siguientes símbolos y palabras reservadas forman parte integrante del lenguaje y se considerarán \emph{tokens} diferenciados:

	\begin{enumerate}
		\item Simbolos:
			\fboxcentrado{
				\code{
				( ) [ ] \codeabrellave\ \codecierrallave\ , . ; = \codemayor\ \codemenor\ + - * / \codemod\ : @ :: == != \codemayor = \codemenor = === !===
				}
			}		
			
		\item Palabras reservadas:
			\fboxcentrado{
				\code{abstract} \code{and} \code{break} \code{continue} \code{do} \code{else} \code{extern} \code{false} \code{for} \code{if} \code{has} \code{hidden} \code{in} \code{is} \code{let} \code{native} \code{not} \code{or} \code{resend} \code{return} \code{shared} \code{static} \code{then} \code{true} \code{var} \code{while}
			}	
	\end{enumerate}
	
%-------------------------------------------------------------------------------------------
\section{Identificadores\label{identificadores}}
%-------------------------------------------------------------------------------------------

	Un \emph{identificador} es un nombre ligado a una entidad. Debe estar formado por una sucesion de cero o más letras y/o dígitos precedida a su vez por una letra o una sucesión de uno o más guiones bajos (caracter ASCII \code{\codeguionbajo}).
	
	Ejemplos de identificadores válidos:
	
	\begin{center}
	\code{unIdent}\quad\code{UNIDENT}\quad\code{\codeguionbajo Unident1299}\quad\code{\codeguionbajo\codeguionbajo 32}
	\end{center}
	
	No son identificadores válidos, en ningún caso, las palabras reservadas del lenguaje (\ref{palabrasreservadas}).
	
\parrafo{Convenciones para identificadores\label{convencionesidentificadores}}

	Durante la presente especificación, se utilizará la misma convención lexicográfica para todos los identificadores. Estos se escribirán completamente en minúsculas, excepto en el caso de nombres compuestos por varias palabras, donde la inicial de la segunda palabra y posteriores se escribirán en mayúscula. Por ejemplo:

 	\begin{center}
 		\code{estado}\quad\code{toString}\quad\code{unValorConstante}
 	\end{center}	
	
	Aquellos nombres que tengan un significado especial podrán serán precedidos de guiones bajos.
	
%-------------------------------------------------------------------------------------------
\section{Literales numéricos enteros\label{numerosenteros}\label{literalesenteros}}
%-------------------------------------------------------------------------------------------

	Un literal entero tiene varias posibles representaciones léxicas, atendiendo a su base:
	
	\begin{enumerate}
		\item \emph{Representación decimal}: Se representa por una cadena --no vacía-- de dígitos decimales (\ref{codificacion}).
		\item \emph{Representación octal}: Se representa por la subcadena \code{0o} seguida por una cadena --no vacia-- de digitos octales (\ref{codificacion}).
		\item \emph{Representacion hexadecimal}: Se representa por la subcadena \code{0x}, seguida por una cadena --no vacía-- de dígitos hexadecimales (\ref{codificacion}).
		\item \emph{Representación binaria}: Se representa por la subcadena \code{0b} seguida por una cadena --no vacia-- de digitos binarios (\ref{codificacion}).
	\end{enumerate}

	Ejemplos de literales numéricos enteros:
	\begin{center}
	\code{0} (decimal)\quad \code{15} (decimal)\quad \code{0o23} (octal)\quad \code{0x6A} (hexadecimal)\quad \code{0b110} (binario)
	\end{center}
	
%-------------------------------------------------------------------------------------------
\section{Literales numéricos reales\label{numerosreales}\label{literalesreales}}
%-------------------------------------------------------------------------------------------
	
	Un número real (en base decimal) se expresa de la misma forma que un entero decimal agregando una coma decimal y/o exponente. La coma decimal se representa por el caracter ASCII punto (\code{.}) y puede aparecer en cualquier lugar de la cadena entera. El exponente puede aparecer a continuación de la misma, indicandose mediante la letra latina \code{e} (o \code{E}) seguida de un número entero que indica la magnitud del exponente. Entre la letra \code{e} (o E) y el exponente puede aparecer, también opcionalmente, un signo positivo o negativo (\code{+}, \code{-}) indicando el signo de este último.
	
	Ejemplos de literales numéricos reales:
	\begin{center}
	\code{0.0}\qquad\code{1.25}\qquad\code{19.}\qquad\code{.19}\qquad\code{1.2e28}\qquad\code{.18E+2}\qquad\code{0.E-24}
	\end{center}

%-------------------------------------------------------------------------------------------
\section{Literales de cadena\label{cadenasdecaracteres}\label{cadenadecaracteres}\label{literaldecadena}\label{literalescadena}}
%-------------------------------------------------------------------------------------------

	Un literal de cadena se representa mediante una secuencia encerrada entre comillas dobles (\code{\codecomillas}) de cero o más caracteres ASCII y/o alguna de las siguientes secuencias de escape:
	
 	\begin{center}
 	\begin{tabular}{|cp{7cm}|}
	\hline
	Secuencia de escape & \multicolumn{1}{c|}{Significado}\\ \hline
	&\\
 	\code{\codebackslash n} 		   	& Reemplazo por salto de linea (\emph{EOL}).\\
 	\code{\codebackslash\codecomillas} 	& Reemplazo por comillas dobles (\code{\codecomillas})\\
 	\code{\codebackslash\codebackslash} 	& Reemplazo por barra invertida (\code{\codebackslash})\\
	&\\
	\hline
 	\end{tabular}
 	\end{center}
	
	Ejemplos de literales de cadena:
	
	\begin{center}
	\code{\codecomillas\codecomillas}\qquad \code{\codecomillas cadena \codecomillas}\qquad \code{"x@equis.es"}\qquad \code{\codecomillas\codebackslash\codecomillas\codecomillas}
	\end{center}

	\parrafo{Literales de cadena de más de una linea}
	
	Los literales de cadena pueden extenderse más de una linea. En caso de un salto de linea durante la definicion de una cadena literal (esto es, entre la apertura de comillas y su cierre) se reemplazará dicho salto, asi como los espacios desde la última palabra hasta la primera palabra de la siguiente linea, por un espacio. Por ejemplo el literal:

\begin{cminipage}{\code{''Es un enorme sillón, el sitio perfectooo}}
\begin{verbatim}
"Es un enorme sillón, el sitio perfecto 
para que un gatito se acomode y duerma"
\end{verbatim}
\end{cminipage}
		
	Equivale a: 
	
\small
\begin{verbatim}	
"Es un enorme sillón, el sitio perfecto para que un gatito se acomode y duerma"
\end{verbatim} 
\normalsize

%-------------------------------------------------------------------------------------------
\section{Comentarios\label{comentarios}}
%-------------------------------------------------------------------------------------------

	Se considerarán dos tipos de comentarios:
	
	\begin{enumerate}
	\item \emph{Comentarios de una linea}: En caso de aparicion de la subcadena \code{//} se ignorarán todos los caracteres desde dicha marca hasta fin de linea
	\item \emph{Comentarios de varias lineas}: En caso de aparición de la subcadena \code{/*} se ignorarán todos los caracteres desde dicha marca hasta la aparición de la subcadena \code{*/}. Los comentarios de varias líneas pueden estar anidados.
	\end{enumerate}	

	A efectos de sangrado, los caracteres y marcas de comentario se consideran como espacios en blanco simples (ASCII \code{SP}), excepto tabuladores y fines de línea, que tendrán su significado habitual.
	
%-------------------------------------------------------------------------------------------
\section{Directiva de inclusión\label{directivas}\label{directivainclusion}}
%------------------------------------------------------------------------------------------

	Se define una directiva de inclusión, con la sintaxis:
	
	\begin{center}
	\code{\codecarcel include \codecomillas}\emph{fichero}\code{\codecomillas}
	\end{center}
	
	En caso de aparición de dicha directiva, ésta se reemplazará por el contenido íntegro del fichero \emph{fichero}, expresado en forma de literal de cadena (\ref{cadenadecaracteres}). En caso de no proporcionarse un camino completo (\emph{path}) hasta el fichero, se utilizará como directorio de trabajo el del fichero que contiene la directiva de inclusión.
	 
	Todo fichero incluido puede contener a su vez nuevas directivas de inclusión, hasta un cierto límite determinado por la implementación. 
	
	A efectos de sangrado, se añadirá el nivel de sangrado de la directiva al nivel de sangrado de las líneas del fichero incluido.
	
%-------------------------------------------------------------------------------------------
\section{Pragmas}
%------------------------------------------------------------------------------------------
	
	De manera complementario a la directiva de inclusión, se especifica una directiva especial \code{pragma} para enviar información dependiente de la implementación al compilador, con la sintaxis:

\begin{center}
	\code{\codecarcel pragma} \emph{tokens}	
\end{center}
	
	El conjunto de pragmas válidos y su significado dependerá de la implementación.
	
%-------------------------------------------------------------------------------------------
\chapter{Objetos\label{objetos}}
%-------------------------------------------------------------------------------------------

	El objeto es la entidad fundamental del lenguaje propuesto. Toda la información de un programa se representa mediante objetos y/o relaciones entre objetos.
	
	Todo objeto tiene un \emph{tipo}, determinado por el conjunto de miembros que soporta, un \emph{valor}, determinado por el contenido de los mismos, y una \emph{identidad}, que identifica al objeto de manera inequívoca\footnote{Normalmente la identidad de un objeto se corresponde con su posición en memoria, aunque esto dependerá en última instancia de la implementación.}. La identidad y el tipo de un objeto permanecen constantes desde la creación del objeto hasta su destrucción (o durante toda la ejecución del programa en caso de objetos es\-táticos) mientras que el valor puede variar en tiempo de ejecución.
	
%-------------------------------------------------------------------------------------------
\section{Miembros\label{miembros}}
%-------------------------------------------------------------------------------------------	
	
	Todo objeto se compone de un conjunto de \emph{miembros}. El \emph{contenido} de un miembro es una expresión (\ref{expresiones}) cuyo valor se determina por \emph{evaluación}.
	
	%------------------------------------------------------------------------------------	
	\parrafo{Miembros variables}
	%------------------------------------------------------------------------------------	
	
	Por defecto, el \emph{contenido} de un miembro es inmutable: una vez inicializada, la expresión contenida en dicho miembro permanecerá constante durante toda la ejecución del programa\footnote{Debe diferenciarse entre la \emph{expresión} contenida por un miembro y su \emph{valor}. La expresión puede permanecer constante y su valor variar dinámicamente en el tiempo.}. Para poder modificar dinámicamente el contenido de un miembro, es necesario declarar dicho miembro como \emph{variable} de manera explícita (\ref{declaraciondeobjetos}).
	
	%------------------------------------------------------------------------------------	
	\parrafo{Miembros con argumentos\label{argumentos}}
	%------------------------------------------------------------------------------------	
	
	Un miembro puede tomar, opcionalmente, un número arbitrario de argumentos. Dichos argumentos serán considerados variables locales de la expresión asociada en su ámbito más externo, y sus valores se inicializarán de manera previa a la evaluación de dicho miembro.
	
	El número de argumentos de un miembro se considerará parte implícita del nombre, de manera que dos miembros asociados al mismo identificador, pero con un número distinto de argumentos serán independientes a todos los efectos\footnote{Es decir, se permite en todo caso la sobrecarga de miembros}. 
	
%-------------------------------------------------------------------------------------------
\section{Herencia\label{herencia}}
%-------------------------------------------------------------------------------------------
	
	Todo objeto puede y debe expresarse enumerando sus diferencias respecto a uno o más\footnote{Es necesario especificar \emph{al menos un padre} para cada objeto. El único objeto sin padre es la abstracción nativa \code{object}, de la que se derivan (explícita o implícitamente) el resto de objetos.} objetos prototipo, que serán considerados \emph{padres} del primero. 
	
	Todos y cada uno de los miembros declarados en los objetos padres serán \emph{copiados} en el hijo: cada miembro paterno recibirá espacio para alojar una copia de sí mismo en el hijo, de igual manera que si en este último se declarase una copia de dicho miembro. 
	
	Un objeto puede redefinir el comportamiento heredado del padre simplemente declarando un miembro con el mismo identificador, que sobreescribirá al heredado. También es posible extender el comportamiento del padre, realizando adicionalmente una llamada explícita al comportamiento paterno (\ref{resend}).

	No se permitirá en ningún caso la creación de dependencias cíclicas de paternidad.
	
	%-------------------------------------------------------------------------
	\parrafo{Miembros com\-par\-ti\-dos}
	%-------------------------------------------------------------------------

	Por defecto, cada miembro heredado recibe su propio espacio para alojar una copia del contenido del miembro del padre.
	
	De manera alternativa, es posible declarar un miembro como \emph{com\-par\-ti\-do} (\ref{declaraciondeobjetos}), indicando que no se realizará una copia del miembro del padre en el hijo, sino que sólo existirá una copia de dicho miembro (la almacenada en el padre). De esta manera, los miembros heredados compartirán una única referencia, posibilitando la modificación dinámica de familias de objetos.
		
	Al ser único, un miembro compartido no puede ser redefinido ni extendido en ningún caso.
	
	%-------------------------------------------------------------------------
	\parrafo{Herencia múltiple\label{herenciamultiple}}
	%-------------------------------------------------------------------------
	
	En los casos en los que un objeto se derive de más de un padre a la vez, la llamada (implícita o explícita) al miembro paterno puede ser ambigua si el mismo miembro es declarado en más de un padre.
	
	En vez de proporcionar una regla implícita que decida cual de los miembros paternos es el correcto, dicha ambigüedad será considerada un error. Debe ser el propio programador el que resuelva explícitamente dicha ambigüedad, redefiniendo los miembros ambiguos y realizando (si procede) llamadas dirigidas (\ref{resend}) al comportamiento paterno.
	
	%-------------------------------------------------------------------------
	\parrafo{Miembros variables\label{miembrosvariables}}
	%-------------------------------------------------------------------------

	En caso de redefinir un miembro declarado como variable durante la extensión de un objeto, el nuevo miembro debe ser también declarado variable. Esto se aplicará también en herencia múltiple en caso de que uno o más padres declaren un miembro como variable (independientemente de que el resto de padres del objeto declare o no como variable dicho miembro).
	
	%-------------------------------------------------------------------------
	\parrafo{Miembros compartidos\label{miembroscompartidos}}
	%-------------------------------------------------------------------------

	El solapamiento de miembros compartidos (es decir, en caso de que más de un padre declare un miembro declarado compartido en alguno de los padres) se considerará un error.
	
%-------------------------------------------------------------------------------------------
\section{Objetos abstractos\label{objetosabstractos}\label{miembrosabstractos}}
%-------------------------------------------------------------------------------------------

	Por conveniencia, se proporciona un mecanismo para manejar abstracciones o definiciones incompletas de objetos en general.
	
	Un objeto declarado como \emph{abstracto} (\ref{declaraciondeobjetos}) no es usable directamente: no puede instanciarse ni pueden evaluarse sus miembros. Sin embargo, dicho objeto puede ser utilizado en una relación de herencia y ser extendido por objetos no abstractos, los cuales serán directamente accesibles.
	
%-------------------------------------------------------------------------------------------
\parrafo{Miembros abstractos}
%-------------------------------------------------------------------------------------------
	
	Un objeto declarado abstracto puede declarar a su vez \emph{miembros abstractos} (\ref{declaraciondeobjetos}), para los que no se proporciona una expresión de inicialización. En este caso, dichos miembros deben ser explícitamente inicializados en aquellos objetos no abstractos que los hereden. En caso contrario se producirá un mensaje de error en tiempo de compilación. 
	
	Un miembro abstracto puede ser sólamente referenciado como parte de una expresión por aquellos objetos declarados abstractos que declaren dicho miembro.
	
%------------------------------------------------------------------------------------
\section{Objetos anidados\label{objetosanidados}}
%------------------------------------------------------------------------------------

	Un objeto puede contener a su vez otras declaraciones de objetos\footnote{De hecho, exceptuando el objeto raíz (programa), todo objeto se declara dentro de otro objeto.}. Los objetos anidados se consideran parte del objeto que los engloba y se tratan como miembros no variables del mismo\footnote{Si el objeto es abstracto, el miembro se comportará como si fuera abstracto, vedándose la evaluación directa del mismo.}, que devuelven el propio objeto anidado como resultado de su evaluación. 

%-------------------------------------------------------------------------------------------
\parrafo{Objetos ocultos\label{objetosocultos}}
%-------------------------------------------------------------------------------------------
	
	Puede haber objetos concretos (generalmente prototipos para la creación de instancias dinámicas de objetos) que aún estando declarados de manera anidada dentro de otros objetos, no interese que aparezcan listados como tales, al no participar en una relación \emph{dentro de} (\ref{objetosanidados}).
	
	Para hacer efectiva esta distinción, dichos objetos podrán ser declarados \emph{ocultos} (\ref{declaraciondeobjetos}). Todo objeto abstracto es implícitamente oculto.
	
%-------------------------------------------------------------------------------------------
\parrafo{Objetos anónimos\label{objetosanonimos}}
%-------------------------------------------------------------------------------------------

	Normalmente será deseable asociar un identificador a cada objeto para posterior referencia. Sin embargo, es también posible declarar objetos anónimos (no asociados a ningún identificador) si no se prevee ninguna referencia al objeto excepto como continente o contenido de otro objeto (\ref{objetosanidados}).

	Se considerará un error la declaración de objetos anónimos ocultos, ya que no pueden en ningún caso utilizarse como parte de una expresión ni como base para la construcción de otros objetos.

%------------------------------------------------------------------------------------
\parrafo{Herencia de objetos anidados}
%------------------------------------------------------------------------------------
	
	No hay restricciones a la extensión (herencia) de un objeto anidado. Puede ser extendido por cualquier otro objeto que se encuentre dentro de su alcance (\ref{ambito}). 
	
	Tampoco hay restricciones a la extensión de objetos que contengan objetos anidados. En este caso, al igual que sucede con los miembros, se alojará una copia de los objetos anidados en el hijo. Todo objeto anidado es susceptible de ser redefinido (mediante una declaración de objeto o miembro con el mismo nombre) o extendido (mediante una declaración de objeto anidado que extienda al anterior objeto anidado)
	\footnote{
		Para aclarar este punto, considerese el siguiente ejemplo, donde el miembro \code{objetoAnidado1} de \code{objeto2} redefine al miembro \code{objetoAnidado1} de \code{objeto1} y el objeto \code{objetoAnidado2} de \code{objeto2} extiende a \code{objetoAnidado1} de \code{objeto1}:
		\begin{center}
		\code{
		\begin{tabular}{l}
		objeto1::object\codeabrellave\\
		\tab objetoAnidado1::object\codeabrellave\ldots\codecierrallave\\
		\codecierrallave \\
		objeto2::objeto1\codeabrellave \\
		\tab objetoAnidado1: null \\
		\tab objetoAnidado2::objetoAnidado1\codeabrellave\ldots\codecierrallave\\
		\codecierrallave 
		\end{tabular}
		}
		\end{center}
	}.

%-------------------------------------------------------------------------------------------
\section{Objetos nativos\label{objetosnativos}}
%-------------------------------------------------------------------------------------------
	
	Un objeto puede ser declarado \emph{nativo} (\ref{declaraciondeobjetos}). En un princio, la única diferencia entre un objeto nativo y otro no nativo es que el primero puede declarar miembros nativos; pueden surgir, sin embargo, otras diferencias durante la traducción a lenguaje objeto.
	
	%------------------------------------------------------------------------------------	
	\parrafo{Miembros nativos\label{miembrosnativos}}
	%------------------------------------------------------------------------------------	
	
	Es posible declarar un miembro como nativo (\ref{declaracionmiembrosexternos}) de manera que su expresión asociada la proporcione de manera implícita el compilador. La lista de miembros nativos soportados y su comportamiento se especifica en las secciónes \ref{tiposdedatosnativos} y \ref{libreriaestandar}.

	%------------------------------------------------------------------------------------	
	\parrafo{Miembros externos\label{miembrosexternos}}
	%------------------------------------------------------------------------------------	
	
	Es también posible declarar un miembro como externo (\ref{declaracionmiembrosexternos}) de manera que su expresión asociada la proporcione directamente el usuario en lenguaje objeto, en un fichero a enlazar en una fase posterior de compilación. El interfaz con los miembros externos dependerá del lenguaje objeto.

%-------------------------------------------------------------------------------------------
\section{Instanciación de objetos}
%-------------------------------------------------------------------------------------------
	
	La creación de instancias dinámicas de objetos se lleva a cabo mediante la utilización de los miembros \code{copy} y \code{deepCopy}, declarados en la abstracción \code{object} y heredados (explícita o implícitamente) por todos los objetos del programa (\ref{tipodedatoobjeto}). También se crean instancias dinámicas de objetos durante la evaluación de expresiones literales (\ref{literales}).

	La liberación de memoria asociada a objetos dinámicos se realizará de forma automática mediante un mecanismo de recogida de basura, dependiente en última instancia del lenguaje objeto. La instancia dinámica será destruida automáticamente cuando ya no sea referenciada por ningúna expresión pendiente de evaluación.


%-------------------------------------------------------------------------------------------
\section{Programa\label{programa}}
%-------------------------------------------------------------------------------------------

	Un programa es a su vez un objeto anónimo de declaración implícita, que no hereda comportamiento de ningún objeto. Todo programa debe declarar un miembro \code{main}, que será evaluado al ejecutar el programa.

%-------------------------------------------------------------------------------------------
\section{Declaración de objetos\label{declaraciondeobjetos}\label{declaracionobjetos}}
%------------------------------------------------------------------------------------------

	La sintaxis para la declaración de un objeto es:
	
	\operador{
	\ceromas{$Modificador_{Objeto}$} \cerouno{\ident{Objeto} \code{::}} \ident{Padre} \ceromas{\code{,} \ident{Padre}} \code{\codeabrellave} $Cuerpo_{Objeto}$ \code{\codecierrallave}
	}
	
	Por simplicidad, se describirán cada uno de los componentes de la anterior sintaxis por separado:
	
	\begin{enumerate}
	\item \shadowbox{\textit{\ceromas{$Modificador_{Objeto}$}}}
	
		Como prefijo a la declaración de un objeto pueden utilizarse, de manera opcional, uno o más de los siguientes modificadores:
		
		\begin{enumerate}
			\item \code{abstract}: Indica que el objeto representa una abstracción (\ref{objetosabstractos}).	
			\item \code{hidden}: Indica que el objeto será considerado oculto (\ref{objetosocultos}).
			\item \code{native}: Indica que el objeto es definido de manera nativa por el lenguaje (\ref{objetosnativos})	
		\end{enumerate}
	
	\item \shadowbox{\textit{\cerouno{\ident{Objeto} \code{::}}}}
	
		De manera también opcional puede proporcionarse un identificador para asociar al objeto, seguido del separador \code{::}. En otro caso, el objeto será anónimo (\ref{objetosanonimos}).

	\item \shadowbox{\textit{\ident{Padre} \ceromas{\code{,} \ident{Padre}}}}
	
		Todo objeto debe declarar al menos un padre del que hereda comportamiento (\ref{herencia}), indicando el identificador asociado al mismo. Dicho identificador debe haber sido debidamente declarado y poder resolverse satisfactoriamente en un objeto en el ámbito en el que se produce la referencia (\ref{ambito}). 
		
		En caso de herencia múltiple, los distintos padres del objeto deben separarse utilizando comas simples.
	
	\item \shadowbox{\textit{\code{\codeabrellave} $Cuerpo_{Objeto}$ \code{\codecierrallave}}}
	
		Finalmente, el cuerpo de la declaración de un objeto se compone de un conjunto de cero o más declaraciones de miembros y/o objetos encerradas entre llaves, con las siguientes características de sangrado:
		
			\begin{enumerate}
			\item En caso de que el cuerpo de la declaración de un objeto contenga una o ninguna declaración, tanto el cuerpo como las llaves de apertura y cierre pueden estar contenidas en la misma línea en la que se declara el objeto:
						
			\begin{center}
			\code{
			\begin{tabular}{l@{\qquad}l}
			object\codeabrellave\codecierrallave & object\codeabrellave x:true\codecierrallave 
			\end{tabular}
			}
			\end{center}
			
			\item En otro caso, debe finalizarse la línea en curso tras la llave de apertura y considerar una nueva línea para cada una de las declaraciones así como para la llave de cierre. El sangrado de las declaraciones debe ser uniforme y mayor que el de la propia declaración del objeto y el sangrado de la llave de cierre igual al de la declaración del objeto:

			\begin{center}
			\code{
			\begin{tabular}{l@{\qquad}l@{\qquad}l}
			object\codeabrellave & object\codeabrellave & object\codeabrellave\\
			\codecierrallave       & \qquad x:true   & \qquad x:true\\
			& \codecierrallave       & \qquad y:false\\
			&         & \codecierrallave\\
			\end{tabular}
			}
			\end{center}

			\end{enumerate}
		
	\end{enumerate}

%-------------------------------------------------------------------------------------------
\section{Declaración de miembros\label{declaraciondemiembros}\label{declaraciondemiembrosexternos}\label{declaracionmiembrosexternos}}
%------------------------------------------------------------------------------------------
		
		La sintaxis para la declaración de un miembro es:
		
		\operador{
			\ceromas{$Modificador_{Miembro}$} \ident{Miembro} \cerouno{\code{(} \ident{Arg} \ceromas{\code{,} \ident{Arg}}\code{)}} \code{:} $Cuerpo_{Miembro}$
		}
		
		Como en el caso anterior, se desglosará la sintaxis para una mejor comprensión:
		
		\begin{enumerate}
		\item \shadowbox{\textit{\ceromas{$Modificador_{Miembro}$}}}
		
			De manera prefija a la declaración de un miembro pueden utilizarse, de manera opcional, uno o más de los siguientes modificadores:
			
			\begin{enumerate}
				\item \code{shared}: Indica que el miembro es com\-par\-ti\-do (\ref{miembros}).
				\item \code{var}: Indica que el miembro es variable (\ref{miembros}).
			\end{enumerate}
		
		\item \shadowbox{\textit{\ident{Miembro} \cerouno{\code{(} \ident{Arg} \ceromas{\code{,} \ident{Arg}}\code{)}}}}
		
			Todo miembro debe asociarse a un identificador \ident{Miembro} válido. Opcionalmente, un miembro puede tomar un número arbitrario argumentos, en cuyo caso deben ser declarados entre paréntesis y separados por comas.

		\item \shadowbox{\code{:}}
		
			Se utilizará el separador \code{:} para distinguir claramente la declaración del miembro del cuerpo del mismo.
			
		\item \shadowbox{$Cuerpo_{Miembro}$}
		
			El cuerpo de un miembro puede:
			
			\begin{enumerate}
			\item Ser una expresión válida (\ref{expresiones}):
			
			\operador{\expresion{}}
			
			Por ejemplo:
			
			\begin{center}
			\code{var descripcion: \codecomillas Un camello gordo y feo\codecomillas}
			\end{center}
			
			\item Declararse abstracto (\ref{miembrosabstractos}):
			
			\operador{\code{abstract}}
			
			Por ejemplo:
			
			\begin{center}
			\code{sort(list): abstract}
			\end{center}
			
			\item Declararse nativo (\ref{miembrosnativos}):
			
			\operador{\code{native}}
			
			Por ejemplo:
			
			\begin{center}
			\code{sort(list): native}
			\end{center}
						\item Declararse externo:
			
			\operador{
				\code{extern} $Literal_{Paquete}$ $Literal_{Objeto}$ $Literal_{Miembro}$
			}
			
			Donde $Literal_{Paquete}$, $Literal_{Objeto}$ y $Literal_{Miembro}$ son literales de cadena válidos (\ref{literalescadena}) que indican, respectivamente, el nombre del paquete en el que es\-tá contenido el miembro externo, el nombre del objeto en el que es\-tá contenido el miembro externo, y finalmente el nombre del miembro externo, por ejemplo:
			
			\begin{center}
			\code{
				\codeguionbajo aux(x): extern \codecomillas util\codecomillas\ \codecomillas Calendario\codecomillas\ \codecomillas getTime\codecomillas 
			}
			\end{center}
			
			En el caso de lenguajes funcionales, se utilizarán solamente los campos $Literal_{Paquete}$ y $Literal_{Miembro}$ para refererise, respectivamente, al módulo y al nombre de la función o procedimiento que contiene el comportamiento externo.
			\end{enumerate}
			
		\end{enumerate}			

%-------------------------------------------------------------------------------------------
\chapter{Expresiones\label{expresiones}}
%-------------------------------------------------------------------------------------------

	Una expresión puede ser \emph{atómica} (concretamente un literal, un identificador o la palabra reservada \code{resend}) o el resultado de una combinación de expresiones (atómicas o no) utilizando algún operador válido.
	
	Toda expresión producirá un error o devolverá un objeto válido como resultado de su evaluación.
	
%-------------------------------------------------------------------------------------------
\section{Literales\label{literaldeobjeto}\label{literales}}
%-------------------------------------------------------------------------------------------
	
	Un literal representa un valor constante de un tipo de dato nativo. En el lenguaje propuesto, ya que todos los tipos de datos son objetos, un literal representará una instancia de objeto asociada a un tipo de datos nativo. 
	
	Se consideran los siguientes tipos de literales:

	\begin{enumerate}
%-------------------------------------------------------------------------------------------
		
		\item \emph{Literal booleano}: Representa una instancia del tipo de dato nativo \code{boolean} (\ref{tipoboolean}). Los únicos literales booleanos permitidos están representados por las palabras reservadas \code{true} y \code{false} que representan, respectivamente, los valores booleanos \emph{verdadero} y \emph{falso}.

%-------------------------------------------------------------------------------------------
		
		\item \emph{Literal numérico entero}: Representa una instancia del tipo de dato nativo \code{integer} (\ref{tipointeger}). La sintaxis para literales numéricos enteros ya ha sido previamente especificada en \ref{numerosenteros}.

%-------------------------------------------------------------------------------------------		
		\item \emph{Literal numérico real}: Representa una instancia del tipo de dato nativo  \code{float} (\ref{tipofloat}). La sintaxis para literales numéricos reales ya ha sido previamente especificada en \ref{numerosreales}.

%-------------------------------------------------------------------------------------------
				
		\item \emph{Literal de cadena de caracteres}: Representa una instancia del tipo de dato nativo \code{string} (\ref{tipostring}). La sintaxis para literales de cadea de caracteres ya ha sido previamente especificada en \ref{cadenasdecaracteres}.
		
%-------------------------------------------------------------------------------------------	
		
		\item \emph{Literal de secuencia}: 
		
		\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			\code{[} \cerouno{\expresion{1} \ceromas{\code{,} \expresion{i}}} \code{]}
		}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		
		Representa una instancia de \code{array} (\ref{tipoarray}). Se compone de cero o más subexpresiones separadas por comas y encerradas entre corchetes. El contenido del array será una secuencia ordenada de valores resultado de evaluar ordenadamente cada una de las subexpresiones \expresion{i}.
		
		Ejemplos de literal de secuencia:
		
		\begin{center}
		\code{[1,2,3,4]}\qquad\code{[[a+3,2],[5,obtenerEntero()]]}\qquad\code{[]} {\small (secuencia vacía)}
		\end{center} 
		
%-------------------------------------------------------------------------------------------
	\end{enumerate}

%-------------------------------------------------------------------------------------------
\section{Identificadores\label{operadoridentificadores}\label{idatomico}}
%-------------------------------------------------------------------------------------------

	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\ident{}
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	Un identificador es por si mismo una expresión atómica que hace referencia a un objeto, miembro o variable declarado previamente, por ejemplo:
	
		\begin{center}
			\code{null}\qquad\code{contador} 
		\end{center}
	
	El valor devuelto por dicha expresión depende de la entidad asociada al identificador, obtenida mediante el proceso de resolución de nombres descrito en \ref{resoluciondenombres}. En concreto:
	
	\begin{enumerate}
		\item \emph{Objetos}: 
		
		El resultado de la expresión será el propio objeto, excepto en el caso de que el objeto sea abstracto (\ref{objetosabstractos}), en cuyo caso se producirá un error en tiempo de compilación\footnote{Por definición, un objeto abstracto no puede ser accedido directamente.}.
		
		\item \emph{Miembros}: 
		
		El resultado de la expresión será el valor obtenido al evaluar el miembro. En este caso, se permite proporcionar un número arbitrario de expresiones de inicialización en caso de que el miembro tome argumentos, encerrados entre paréntesis y separados por comas:
		
		\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\ident{} \cerouno{\code{(} \expresion{param} \ceromas{\code{,} \expresion{param}} \code{)}}
		}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		
		En caso de proporcionarse, el número de expresiones de inicialización debe coincidir con el número de argumentos declarados para el miembro en curso. 
		
		En cualquier caso, las expresiones \expresion{param} se evaluarán en primer lugar y se utilizarán como valores de inicialización para los argumentos del miembro, considerados variables locales de la expresión asociada.
		
		Dos ejemplos:
		
		\begin{center}
			\code{print(\codecomillas The quick...\codecomillas )}\qquad\code{sort([1,4,5,2],"quicksort")}
		\end{center}
		
		\item \emph{Variables locales}: 
		
		El resultado de la expresión será el contenido de la variable local. 
		
		\item \emph{Desconocido}:
		
		Si el identificador no ha sido debidamente declarado o no es alcanzable desde el ámbito en curso (\ref{ambito}) se producirá un error en tiempo de compilación.
		
	\end{enumerate}	
	
%-------------------------------------------------------------------------------------------
\section{Operador de acceso a miembros\label{operadordeacceso}\label{operadordeaccesoamiembros}}
%-------------------------------------------------------------------------------------------

	El operador de acceso a miembros o \emph{operador punto} se utiliza para acceder a un miembro concreto de un objeto obtenido como resultado de la evaluación de una expresión:
	 
	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\expresion{} \code{.} \ident{Miembro}
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	En primera instancia se evaluará \expresion{}, cuyo resultado debe ser un objeto para el que haya sido declarado el miembro \ident{Miembro}: intentar acceder a un miembro que no ha sido debidamente declarado producirá un error, que será en tiempo de ejecución si la implementación es capaz de inferir el tipo del resultado de la expresión, o en tiempo de compilación en caso contrario.	
	
	El resultado de la expresión en su conjunto será el resultado de evaluar el miembro \ident{Miembro} en el objeto resultante la evaluación de \expresion{}. 
	
	En el caso de que el miembro tome argumentos, se permite un número arbitrario de expresiones de inicialización, encerrada entre paréntesis y separada por comas:

	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\expresion{} \code{.} \ident{Miembro} \cerouno{\code{(} \expresion{param} \ceromas{\code{,} \expresion{param}} \code{)}}
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	
	En caso de proporcionarse, el número de expresiones de inicialización debe coincidir con el número de argumentos declarados para el miembro en curso. Las expresiones \expresion{param} se evaluarán en segundo lugar (de manera posterior a la evaluación de \expresion{} y previamente a la evaluación de \ident{Miembro}) y se utilizarán como valores de inicialización para los argumentos del miembro, considerados variables locales de la expresión asociada. 
			
	Ejemplos:
				
		\begin{center}
			\code{x.contador\qquad(x+5).toString\qquad list.insert(x,10)}
		\end{center}
	
%-------------------------------------------------------------------------------------------	
\section{Operador de asignación\label{operadorasignacion}}
%-------------------------------------------------------------------------------------------

	El operador de asignación permite modificar el contenido de variables locales (\ref{variableslocales}) o miembros explícitamente declarados como variables (\ref{miembros}). Se trata de una extensión de la sintaxis de los identificadores atómicos (\ref{operadoridentificadores}) y del operador de acceso a miembros (\ref{operadordeacceso}):
	
	\begin{enumerate}
	\item \emph{Variables locales}:
		
		\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\ident{} \code{=} \expresion{asignacion}
		}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		
		Si \ident{} es un identificador asociado a una variable local, se asignará a ésta el resultado de evaluar \expresion{asignacion} y se devolverá dicho valor como resultado de la expresión. Por ejemplo:
		
		\begin{center}
			\code{contador=0\qquad x=5}
		\end{center}
		
	
	\item \emph{Miembros variables (referenciados a través de su identificador)}:		
	
		\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\ident{} \cerouno{\code{(} \ident{param} \ceromas{\code{,} \ident{param}} \code{)}} \code{=} \expresion{asignacion}
		}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		
		En el caso más simple, una asignación de nuevo contenido a un miembro tiene el mismo comportamiento que el caso de una variable local:

		\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\ident{} \code{=} \expresion{asignacion}
		}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~		
		
		Si \ident{} es un identificador asociado a un miembro declarado variable, se asignará a éste el resultado de evaluar \expresion{asignacion} y se devolverá dicho valor como resultado de la expresión.

		En caso de que el miembro tome argumentos, deben indicarse los nombres de los mismos durante la asignacion; los nombres proporcionados deben coincidir con los declarados para el objeto, aunque sólo se utilizan a título informativo\footnote{Como el nombre de los argumentos sólamente se proporciona a titulo informativo la expresión \expresion{asignacion} no puede hacer en ningún caso referencia al contenido de los argumentos \ident{param}.}:
		
		\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\ident{} \cerouno{\code{(} \ident{param} \ceromas{\code{,} \ident{param}} \code{)}} \code{=} \expresion{asignacion}
		}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
				
	\item \emph{Miembros variables (utilizando el operador de acceso a miembros)}:		
	
		\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\expresion{} \code{.} \ident{} \cerouno{\code{(} \ident{param} \ceromas{\code{,} \ident{param}} \code{)}} \code{=} \expresion{asignacion}
		}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		
		El comportamiento en el caso de que la referencia al miembro se realize indirectamente mediante el operador de acceso a miembros es exactamente el mismo que si ésta se realizase directamente a través de su identificador, realizándose las mismas consideraciones. 
		
		Un ejemplo de este tipo de asignación:
		
		\begin{center}
		\code{
			habitacion.descripcion=\codecomillas ...\codecomillas
		}
		\end{center}
	
	\end{enumerate}
	

%-------------------------------------------------------------------------------------------
\section{Operador identidad\label{operadoridentidad}}
%-------------------------------------------------------------------------------------------
		
	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	\code{(} \expresion{} \code{)}
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~			
	
	El operador identidad devuelve en todo caso el valor del operando \expresion{} como resultado de su evaluación. Se contempla con el fin de permitir explicitar la precedencia de evaluación de una expresión, ya sea para obtener código más legible o para alterar el orden de evaluación de las subexpresiones.

%--------------------------------------------------------------------------------------	
\section{Operador secuencia\label{operadorsecuencia}}
%--------------------------------------------------------------------------------------

	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\expresion{1} \code{;} \expresion{2}
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	El operador secuencia evalúa ordenadamente \expresion{1} y \expresion{2}, y devuelve el valor resultado de evaluar \expresion{2}. Puede utilizarse de manera encadenada para evaluar secuencias de expresiones de longitud arbitraria y devolver el resultado de la última de ellas. 
	
	Por ejemplo: 
	\begin{center}
	\code{x=5;x=x*2;x=x+1} {\footnotesize (El resultado de evaluar esta expresión sería el número entero \code{11})}
	\end{center}

% %--------------------------------------------------------------------------------------	
% \section{Operador bloque\label{operadorbloque}}
% %--------------------------------------------------------------------------------------
% 	
	Otra forma alternativa de expresar secuencias es a través del propio sangrado del programa. En vez de separadas por el caracter punto y coma, las expresiones de una secuencia pueden ubicarse en líneas dedicadas y sucesivas, con un nivel de sangrado uniforme y mayor al de la línea inmediatamente anterior al de la primera expresión.
	
	Asi, son equivalentes las siguientes expresiones:

	\begin{center}
	\code{
	\begin{tabular}{l@{\qquad}l@{\qquad}l}
	e1+(e2) & e1+(e2;e3) & e1+(e2;(e3;e4);e5)\\
	\multicolumn{1}{c}{$\equiv$}    & \multicolumn{1}{c}{$\equiv$}    & \multicolumn{1}{c}{$\equiv$} \\
	e1+       & e1+       & e1+\\
	\qquad e2 & \qquad e2 & \qquad e2\\
	            & \qquad e3 & \qquad \qquad e3\\
	            &		  & \qquad \qquad e4\\
		    &             & \qquad e5\\
	\end{tabular}
	}
	\end{center}		

%-------------------------------------------------------------------------------------------
\section{Operador \code{resend}\label{operadorresend}\label{resend}}
%-------------------------------------------------------------------------------------------
	
	El operador \code{resend} se utiliza para realizar llamadas explícitas al comportamiento paterno:
	
	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\code{resend} 
		\cerouno{\code{@} \ident{Miembro} \cerouno{\code{@} \ident{Padre}}} \cerouno{\code{(} \expresion{p(1)} \ceromas{\code{,} \expresion{p(i)}} \code{)}}
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	
	En ausencia de parámetros, el operador evalúa el comportamiento del padre para el miembro actual\footnote{Se entiende por miembro actual aquel miembro cuya expresión asociada contiene la llamada.}. La llamada puede tomar parámetros:
	
	\begin{center}
		\code{resend}\qquad\code{resend(x,10)}
	\end{center}
	
	Adicionalmente, puede proporcionarse el nombre del miembro a evaluar si se quiere realizar una llamada al comportamiento del padre para otro miembro distinto del actual:
	
	\begin{center}
		\code{resend @toString}\qquad\code{resend @insert(x,10)}
	\end{center}
	
	Finalmente, puede dirigirse la llamada a uno sólo de los padres indicando el nombre del padre a continuación del nombre del miembro, utilizando una arroba como separador:
	\begin{center}
		\code{resend @toString@integer}\qquad\code{resend @insert@list(x,10)}
	\end{center}
	
	En cualquiera de los casos el valor devuelto por la expresión será el resultado de la evaluación del miembro paterno. Se considerarán errores en tiempo de compilación los intentos de evaluar un miembro que no haya sido declarado en ninguno de los padres, evaluar un miembro declarado en más de un padre sin explicitar el padre o indicar un padre que no ha sido debidamente declarado para el objeto en curso.
				
%-------------------------------------------------------------------------------------------
\section{Operadores de reflexión\label{operadoresdereflexion}\label{operadorhas}}
%-------------------------------------------------------------------------------------------

	El término \emph{reflexión} se refiere a una serie de mecanismos de un lenguaje de programación que permiten a un programa inspeccionar su propia estructura de manera dinámica.
	
	Además de los métodos proporcionados por la abstracción \emph{object} a tal efecto (heredados por todos los objetos del sistema) se proporcionan una serie de operadores básicos para las operaciones de reflexión más comunes:
	
		\begin{enumerate}
		\item \emph{Operador de comprobación de paternidad\label{operadoris}}
				
			\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			\expresion{1}\ \code{is}\ \ident{Padre} & Operador \emph{es}\\
			\expresion{1}\ \code{is not}\ \ident{Padre} & Operador \emph{no es}
			}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			
			Los operadores de comprobación de paternidad \code{is} e \code{is not} indican si el objeto resultante de evaluar \expresion{1} se deriva (o no se deriva) del objeto \ident{Padre} (Es decir, si el objeto o alguno de sus ascendentes \emph{es} un objeto derivado de \ident{Padre}). El resultado de la operación será un valor de tipo booleano indicador de la veracidad de la afirmación expresada. 
			
			El objeto \ident{Padre} debe ser un objeto conocido en el ámbito en curso, cuyo nombre pueda ser resuelto satisfactoriamente (\ref{resoluciondenombres}). 
						
		\item \emph{Operador de comprobación de pertenencia}

			\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			\expresion{1}\ \code{has}\ \ident{Miembro} & Operador \emph{tiene}\\
			\expresion{1}\ \code{has not}\ \ident{Miembro} & Operador \emph{no tiene}
			}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			
			Los operadores de comprobación de pertenencia indican si el miembro con identificador \ident{Miembro} ha sido (o no ha sido) declarado para el objeto resultante de evaluar \expresion{1}.  El resultado de la operación será un valor de tipo booleano representando la veracidad de la relación expresada. 
				
		\item \emph{Operadores de comparación de identidad}
		
			\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			\expresion{1}\ \code{===}\ \expresion{2} & Operador \emph{idéntico a}\\
			\expresion{1}\ \code{!==}\ \expresion{2} & Operador \emph{no idéntico a}
			}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			
			Los operadores de comparación de identidad comparan la \emph{identidad} (\ref{objetos}) de dos objetos\footnote{Dos objetos serán idénticos si su identidad es la misma, es decir, se trata inequívocamente del mismo objeto.}. 
			
			El resultado de la operación será un valor de tipo booleano representando la veracidad de la relación expresada. 
		\end{enumerate}
	
%--------------------------------------------------------------------------------------		
\section{Operador \code{let}\label{variableslocales}\label{variablelocal}}
%--------------------------------------------------------------------------------------

	Es posible, durante la evaluación de una expresión, declarar variables locales a dicha expresión para utilizarlas como almacenamiento intermedio\footnote{Una variable será considerada una abstracción de celda de almacenamiento, cuyo valor puede variar dinámicamente.}.

	Además de los argumentos de un miembro, considerados variables implícitas de la expresión asociada a dicho miembro (\ref{miembros}), es posible declarar explícitamente nuevas variables utilizando el operador \code{let}:

	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\code{let} \ident{Variable} \cerouno{\code{=} \expresion{inicializacion}} \ceromas{\code{,} \ident{Variable} \cerouno{\code{=} \expresion{inicializacion}}} \code{in} \expresion{}
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	El operador declara una o más variables locales \ident{variable}, separadas por comas, que pueden ser opcionalmente inicializadas con un valor \expresion{inicializacion} en el momento de su declaración. En otro caso se inicializarán por defecto con el valor nulo (\code{null}). 
	
	La inicialización se producirá por orden de declaración; en ningún caso la expresión de inicialización de una variable puede hacer referencia a variables previamente declaradas en la misma expresión. Las variables declaradas sólamente serán visibles en la subexpresión \expresion{}.
	
	El valor devuelto por una expresión \code{let} será en cualquier caso el resultado de evaluar la subexpresión \expresion{}.
	
	El operador \code{let} puede extenderse a más de una línea, siempre que la finalización de línea se produzca inmediatamente antes del token \code{in} y el sangrado de la nueva linea sea el mismo de la línea que contiene el token \code{let}.	
	
%--------------------------------------------------------------------------------------		
\section{Operador \code{static}\label{operadorstatic}}
%--------------------------------------------------------------------------------------

	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\code{static} \expresion{}
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	El operador \code{static} permite la evaluación es\-tática de una expresión: la expresión asociada será evaluada una sóla vez durante la ejecución del programa, concretamente, la primera vez que la subexpresión \code{static} sea alcanzada durante una evaluación\footnote{Por razones de eficiencia, se permite a la implementación inicializar la expresión es\-tática en otro momento, siempre que el resultado sea el mismo.}. Posteriores evaluaciones de la misma expresión obtendrán como resultado el valor de la evaluación original.
	
%--------------------------------------------------------------------------------------		
\section{Operadores aritméticos\label{operadoresaritmeticos}}
%--------------------------------------------------------------------------------------

	El lenguaje proporciona una serie de operadores aritméticos destinados a objetos que representen números (por ejemplo instancias de los tipos nativos \code{integer} y \code{float}):
	
		\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\code{+}\ \expresion{1} & Operador \emph{signo \code{+}}\\
		\code{-}\ \expresion{1} & Operador \emph{signo \code{-}}\\
		\expresion{1}\ \code{+}\ \expresion{2} & Operador \emph{suma}\\
		\expresion{1}\ \code{-}\ \expresion{2} & Operador \emph{resta}\\
		\expresion{1}\ \code{*}\ \expresion{2} & Operador \emph{multiplicación}\\
		\expresion{1}\ \code{/}\ \expresion{2} & Operador \emph{división}\\
		\expresion{1}\ \code{\codemod}\ \expresion{2} & Operador \emph{módulo}\\
		}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		
	Para los tipos de datos nativos del lenguaje (\ref{tiposdedatosnativos}) el resultado de la aplicación de un operador aritmético será un nuevo objeto que represente el resultado de la operación aritmética expresada. 

	Este comportamiento puede ser distinto para tipos de datos definidos por el usuario, ya que cada operador equivale a efectos de evaluación a, respectivamente:
		
		\begin{center}
		\code{
		\begin{tabular}{ccl}
\code{+}\ \expresion{1}                & $\equiv$ & (\expresion{1}.operatorPlus)\\
\code{-}\ \expresion{1}                & $\equiv$ & (\expresion{1}.operatorMinus)\\
\expresion{1}\ \code{+}\ \expresion{2} & $\equiv$ & (\expresion{1}.operatorPlus(\expresion{2}))\\
\expresion{1}\ \code{-}\ \expresion{2} & $\equiv$ & (\expresion{1}.operatorMinus(\expresion{2}))\\
\expresion{1}\ \code{*}\ \expresion{2} & $\equiv$ & (\expresion{1}.operatorMultiplication(\expresion{2}))\\
\expresion{1}\ \code{/}\ \expresion{2} & $\equiv$ & (\expresion{1}.operatorDivision(\expresion{2}))\\
\expresion{1}\ \code{\codemod}\ \expresion{2} & $\equiv$ & (\expresion{1}.operatorModulus(\expresion{2}))\\
		\end{tabular}
		}
		\end{center}

	En caso de definirse dichos miembros (\code{OperatorPlus}, \code{OperatorMinus}, etc) en tipos de datos definidos por el usuario, se encarece la adhesión de los mismos al comportamiento por defecto del lenguaje.
			
%--------------------------------------------------------------------------------------		
\section{Operadores relacionales\label{operadoresdecomparacion}\label{operadoresrelacionales}}
%--------------------------------------------------------------------------------------
	
	Los operadores relacionales se utilizan para comparar el \emph{valor} de dos expresiones:
	
		\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\expresion{1}\ \code{==}\ \expresion{2} & Operador \emph{igual a}\\
		\expresion{1}\ \code{!=}\ \expresion{2} & Operador \emph{no igual a}\\
		\expresion{1}\ \code{\codemayor}\ \expresion{2} & Operador \emph{mayor que}\\
		\expresion{1}\ \code{\codemenor}\ \expresion{2} & Operador \emph{menor que}\\
		\expresion{1}\ \code{\codemayor=}\ \expresion{2} & Operador \emph{mayor o igual que}\\
		\expresion{1}\ \code{\codemenor=}\ \expresion{2} & Operador \emph{menor o igual que}\\
		}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	
	Para los tipos de datos nativos del lenguaje (\ref{tiposdedatosnativos}), el resultado de evaluar una expresión relacional será un valor booleano indicador de la veracidad de la relación expresada. 		
	
	Este comportamiento puede ser distinto para tipos de datos definidos por el usuario, ya que cada operador equivale a efectos de evaluación a, respectivamente:
			
		\begin{center}
		\code{
		\begin{tabular}{ccl}
			\expresion{1} == \expresion{2} & $\equiv$ & (\expresion{1}.operatorEqual(\expresion{2}))\\
			\expresion{1} != \expresion{2} & $\equiv$ & (\expresion{1}.operatorNotEqual(\expresion{2}))\\
			\expresion{1} \codemayor\ \expresion{2} & $\equiv$ & (\expresion{1}.operatorGreater(\expresion{2}))\\
			\expresion{1} \codemenor\ \expresion{2} & $\equiv$ & (\expresion{1}.operatorLess(\expresion{2}))\\
			\expresion{1} \codemayor= \expresion{2} & $\equiv$ & (\expresion{1}.operatorGreaterOrEqual(\expresion{2}))\\
			\expresion{1} \codemenor= \expresion{2} & $\equiv$ & (\expresion{1}.operatorLessOrEqual(\expresion{2}))\\
		\end{tabular}
		}
		\end{center}

	En caso de definirse dichos miembros en tipos de datos definidos por el usuario, se encarece la adhesión de los mismos al comportamiento por defecto del lenguaje.
		
%--------------------------------------------------------------------------------------		
\section{Operador de concatenación\label{operadordeconcatenacion}\label{operadorconcatenacion}}
%--------------------------------------------------------------------------------------

	El operador de concatenación se utiliza para concatenar las representaciones en forma de cadena de caracteres de dos objetos:

			\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			\expresion{1}\ : \expresion{2}
			}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	La representación en forma de cadena de un objeto se obtiene, por definición, a través de la evaluación del miembro \code{toString}, declarado por la abstracción base \code{object} y heredado (implícita o explícitamente) por todos los objetos. El operador de concatenación equivale a efectos de evaluación a:
		
		\begin{center}
		\begin{tabular}{ccl}
			\expresion{1}\ : \expresion{2} & $\equiv$ & \code{(\expresion{1}.toString.operatorConcat(\expresion{2}.toString))}
		\end{tabular}
		\end{center}
	
	Este comportamiento puede ser distinto para tipos de datos definidos por el usuario en caso de que el miembro \code{toString} no devuelva una representación adecuada en forma de cadenas de caracteres. En cualquier caso, se encarece la adhesión al comportamiento por defecto del lenguaje.
		
%--------------------------------------------------------------------------------------		
\section{Operadores para colecciones de datos\label{operadoresdesecuencias}\label{operadoresparacoleccionesdedatos}}
%--------------------------------------------------------------------------------------

	Se proporcionan una serie de operadores para facilitar el mantenimiento de colecciones de datos:

	\begin{enumerate}
		\item \emph{Operador de acceso a colecciones de datos}:
		
			\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			\expresion{objeto}\ \code{[}\ \expresion{indice}\ \code{]} \cerouno{\code{=} \expresion{valor}}
			}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			
			El comportamiento del operador de acceso es dependiente del tipo de dato sobre el que se aplique, y puede combinarse con el operador de asignación (\ref{operadorasignacion}). En concreto, el operador equivale a efectos de evaluación a (una de dos):
			
			\begin{center}
			\begin{tabular}{ccl}
			\expresion{objeto}\ \code{[}\ \expresion{indice}\ \code{]} & $\equiv$ & \code{(\expresion{objeto}.operatorGet(\expresion{indice}))}\\
			\expresion{objeto}\ \code{[}\ \expresion{indice}\ \code{]} \code{=} \expresion{valor} & $\equiv$ & \code{(\expresion{objeto}.operatorSet(\expresion{indice},\expresion{valor}))}
			\end{tabular}
			\end{center}
			
			Para los tipos de datos nativos del lenguaje (\ref{tiposdedatosnativos}) el comportamiento del operador de acceso a colecciones de datos será obtener (\code{operatorGet}) o establecer (\code{operatorSet}) el valor del elemento cuyo índice dentro de la colección coincide con la expresión \expresion{indice}. En ambos casos se devuelve dicho valor\footnote{En el caso de \code{operatorSet} se devolverá el nuevo valor asignado.} como resultado de la expresión. Nótese que la utilización de un índice o una expresión de asignación incorrectos puede provocar un error.
			
			Al igual que otros operadores cuyo comportamiento depende de sus operandos, éste puede diferir para tipos de datos definidos por el usuario. En caso de proporcionarse nuevos tipos de datos para los que exista una aplicación de estos operadores, se encarece la adhesión de la implementación de los mismos al comportamiento por defecto del lenguaje.
			
		\item \emph{Operador de unión de colecciones de datos}:
	
			El operador de unión se puede utilizar para obtener la unión de dos colecciones de datos o para añadir elementos a una colección de datos:
		
			\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			\expresion{1}\ :: \expresion{2}
			}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			
			Para los tipos de datos nativos (\ref{tiposdedatosnativos}) el operador devolverá una nueva colección resultado de la unión de las colecciones \expresion{1} y \expresion{2}\footnote{Si se pretende añadir un elemento a la colección, será necesario crear una nueva colección que contenga al elemento, convirtiendo la anterior expresión en \emph{\code{[}exp1\code{]::}exp2} o \emph{exp1\code{::[}exp2\code{]}}, por ejemplo.}. Este comportamiento puede ser distinto para tipos de datos definidos por el usuario, ya que el operador de unión equivale a efectos de evaluación a:
			
		\begin{center}
		\begin{tabular}{ccl}
			\expresion{1}\ :: \expresion{2} & $\equiv$ & \code{\expresion{1}.operatorUnion(\expresion{2})}
		\end{tabular}
		\end{center}
			
			En caso de definirse dicho miembro en tipos de datos definidos por el usuario, se encarece la adhesión al comportamiento por defecto del lenguaje.

	\end{enumerate}
	
%--------------------------------------------------------------------------------------	
\section{Operadores lógicos\label{operadoreslogicos}}
%--------------------------------------------------------------------------------------

	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\code{not} \expresion{1} & Operador \emph{not lógico}\\
		\expresion{1} \code{or} \expresion{2} & Operador \emph{or condicional}\\
		\expresion{1} \code{and} \expresion{2} & Operador \emph{and condicional}\\
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	
	Los operadores lógicos sólo pueden ser aplicados a operandos de tipo booleano. El resultado será también de tipo booleano:
	
	\begin{enumerate}
		\item Un \emph{not lógico} será cierto si el operando \expresion{1} es falso, y viceversa
		\item Un \emph{and condicional} será cierto si y solo si ambos operandos (\expresion{1} y \expresion{2}) son ciertos. El segundo operando sólo será evaluado si con la evaluación del primero no es posible determinar el resultado; en concreto, sólo se evaluará el segundo operando en caso de que el primero sea cierto.
		\item Un \emph{or condicional} será cierto si y solo si uno de sus operandos (\expresion{1} o \expresion{2}) es cierto\footnote{La operación es inclusiva (\emph{or inclusivo}).}. El segundo operando sólo será evaluado si con la evaluación del primero no es posible determinar el resultado; en concreto, sólo se evaluará el segundo operando en caso de que el primero sea falso.
	\end{enumerate}
	
	En caso de que alguno de los operandos no sea de tipo booleano se producirá un error, que será en tiempo de compilación si la implementación es capaz de inferir el tipo de las expresiones, o en tiempo de ejecución en otro caso.

%--------------------------------------------------------------------------------------	
\section{Operador \code{if-else}\label{operadorif}\label{operadorifelse}\label{ifelse}}
%--------------------------------------------------------------------------------------

	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	\code{if} \expresion{condicion} \code{then} \expresion{1} \cerouno{\code{else} \expresion{2}}
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	
	El operador \code{if} permite la evaluación condicional de una entre dos expresiones en base a la veracidad de una tercera expresión booleana.
	
	En concreto, si \expresion{condicion} se evalúa verdadera, se devolverá \expresion{1} como resultado de la operación; en otro caso, se devolverá \expresion{2} (o \code{null} si no se utiliza la construccion opcional \code{else}). En cualquier caso se evaluará en primera instancia \expresion{condicion}, y dependiendo de su resultado sólamente una de las otras dos expresiones será evaluada.
		
	En caso de que el operando \expresion{condicion} no sea de tipo booleano se producirá un error, que será en tiempo de compilación si la implementación es capaz de inferir el tipo de las expresiones, o en tiempo de ejecución en otro caso.
	
	\parrafo{Sangrado}
	
	Por conveniencia, se permite que la expresión \code{if-else} se extienda a más de una línea. En tal caso, la finalización de línea debe producirse inmediatamente antes de los \textit{tokens} \code{then} o \code{else} y el sangrado de la nueva línea debe ser el mismo de la línea que contiene el token \textit{token} \code{if}. Así, las siguientes expresiones son equivalentes:
	
	\begin{center}
	\code{
	\begin{tabular}{l@{\qquad}l@{\qquad}l@{\qquad}l}
	if A then B else C & if A then B & if A          & if A\\
			   & else C      & then B else C & then B\\
			   &             &               & else C
	\end{tabular}
	}
	\end{center}

	\parrafo{Emparejamiento \code{if-else}}
	
	Una construcción \code{else} no inmediatamente precedida por una construcción \code{if} se considerará siempre como continuación de la última construcción \code{if} sin \code{else} dentro del mismo miembro. 
	
	La aparición de una construcción \code{else} no emparejable con ninguna construcción \code{if} previa se considerará un error.
	
%--------------------------------------------------------------------------------------	
\section{Operadores de iteración\label{operadoresdeiteracion}}
%--------------------------------------------------------------------------------------

	Se consideran varios operadores de iteración, que devolverán en todo caso el valor nulo (\code{null}) como resultado de su evaluación:
		
		\begin{enumerate}
			\item \emph{Operador \code{while}}:
			
			\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
				\code{while} \expresion{condicion} \code{do} \expresion{}
			}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
					
			El operador \code{while} evalúa repetidamente \expresion{condicion} y \expresion{} (en este orden\footnote{Si \expresion{condicion} se evalúa falsa, se considerá terminada la iteración y no se evaluará \expresion{} a continuación.}) mientras se mantenga la veracidad de \expresion{condicion}.
			
			Por conveniencia, se permite que el operador \code{while} se extienda a más de una línea, siempre que la finalización de línea se produzca inmediatamente antes del token \code{do} y que el sangrado de la nueva línea sea el mismo de la lína que contiene el \textit{token} \code{while}
			
			\item \emph{Operador \code{do-while}}
			
			\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
				\code{do} \expresion{} \code{while} \expresion{condicion}
			}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~			
			
			El operador \code{do-while} evalúa repetidamente \expresion{} y \expresion{condicion} (en este orden) mientras se mantenga la veracidad de \expresion{condicion}.
				
			Por conveniencia, se permite que el operador \code{do-while} se extienda a más de una línea, siempre que la finalización de línea se produzca inmediatamente antes del token \code{while} y que el sangrado de la nueva línea sea el mismo de la lína que contiene el \textit{token} \code{do}
			
			\item \emph{Operador \code{for}\label{for}} 
			
			\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
				\code{for} \expresion{init} \code{,} \expresion{condicion} \code{,} \expresion{update} \code{do} \expresion{}
			}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			
			La evaluación de una expresión \code{for} se compone de dos fases:

			\begin{enumerate}
				\item \emph{Inicialización}: Se evalúa la expresión de inicialización \expresion{init}.
				
				\item \emph{Iteración y actualización}: Repetidamente, se evalúan las expresiónes \expresion{condicion}, \expresion{} y  \expresion{update}\footnote{Si \expresion{condicion} se evalúa falsa en cualquiera de las iteraciones, se considerá terminada la iteración y ya no se evaluará \expresion{} ni \expresion{update} a continuación.} (en este orden) mientras se mantenga la veracidad de la expresión \expresion{condicion}. 
			\end{enumerate}			
			
			Por conveniencia, se permite que el operador \code{for} se extienda a más de una línea, siempre que la finalización de línea se produzca inmediatamente antes del token \code{do} y que el sangrado de la nueva línea sea el mismo de la lína que contiene el \textit{token} \code{for}
						
			\item \emph{Operador \code{break}:\label{operadorbreak}}
			
				\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
					\code{break}
				}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			
				El operador \code{break} sólo puede aparecer contenido dentro del cuerpo de un bucle (\code{while}, \code{do-while} o \code{for}), terminando abruptamente la evaluación de dicho bucle y devolviendo \code{null} como resultado de la evaluación. En caso de bucles anidados, el efecto del operador sólo se aplicará al bucle más interno. 
			
			\item \emph{Operador \code{continue}:\label{operadorcontinue}}
			
				\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
					\code{continue}
				}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			
				El operador \code{continue} sólo puede aparecer contenido dentro del cuerpo (\expresion{}) de un bucle (\code{while}, \code{do-while} o \code{for}). El efecto del operador es terminar abruptamente la iteración en curso, abortando la evaluación de la expresión \expresion{} declarada como cuerpo del bucle y forzando una nueva iteración\footnote{En bucles \code{for}, la expresión \expresion{update} no se considera parte del cuerpo del bucle por lo que será evaluada normalmente.}. En caso de bucles anidados, el efecto del operador sólo se aplicará al bucle más interno.
				
	\end{enumerate}		
	
	En caso de que el operando \expresion{condicion} no sea de tipo booleano en cualquiera de las iteraciones de un bucle se producirá un error, que podrá ser en tiempo de compilación o en tiempo de ejecución, dependiendo de si la implementación es capaz de inferir el tipo del operando.
	
				
%--------------------------------------------------------------------------------------	
\section{Operador \code{return}\label{operadorreturn}}
%--------------------------------------------------------------------------------------
		
	\operador{%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		\code{return} \expresion{}						
	}%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	El operador de retorno finaliza abruptamente la evaluación de la expresión asociada a un miembro, devolviendo \expresion{} como resultado de dicha evaluación.

%-------------------------------------------------------------------------------------------
\section{Precedencia y asociatividad de operadores\label{precedenciaoperadores}}
%-------------------------------------------------------------------------------------------

\calcularancho{Operadores de desplazamiento}
	
	La precedencia y asociatividad de los operadores de la gramática se muestran en la figura \ref{figuraprecedenciaoperadores}. Los grupos de operadores de mayor precedencia se muestran en primer lugar.
	
% 	Por ejemplo la siguiente expresión es una tautología\footnote{Una tautología es una sentencia o proposición que siempre es verdadera.}:
% 	
% 	\begin{center}
% 		(1+5*2).toString():"X"::"Y":"Z"==["11X","YZ"]
% 	\end{center}
	
 	\begin{figure}
	\begin{center}
	\espaciadominimo
	%\small
	
	\newcommand{\aiz}{\emph{Izquierda a derecha}}
	\newcommand{\ader}{\emph{Derecha a izquierda}}	
	\newcommand{\ano}{\emph{No asociativo}}
	\newcommand{\mihlinefinal}{\hline}
	\newcommand{\mihline}{\hline}
	\newcommand{\mihlinetitulo}{\hline\hline}
	%\newcommand{\mihline}{\hline\hline}
	\setlength{\doublerulesep}{0.5cm}
 	
	\begin{tabular}{|ccc|}
 	\mihlinefinal%-------------------------------------------------
	{\fuentetitulostabla \bfseries Operador} 	& {\fuentetitulostabla \bfseries Operación} 		& {\fuentetitulostabla \bfseries Asociatividad} \\
	\mihlinetitulo%-------------------------------------------------
	\code{( )}	& Identidad		& \ano		\\
	%\textit{\small sangrado}	& Secuencia & \ano		\\
	\mihline%-------------------------------------------------
	\code{[ ]} 	& Acceso a secuencia	 & \aiz		\\
	\code{.}	& Acceso a miembros	& \aiz		\\
	\mihline%-------------------------------------------------
	\code{is}	& Es			& \ano		\\
	\code{is not}	& No es			& \ano		\\
	\code{has}	& Tiene			& \ano		\\
	\code{has not}	& No tiene		& \ano		\\
	\mihline%-------------------------------------------------
	\code{+} \footnotesize unario 	& Signo + & \ader 	\\
	\code{-} \footnotesize unario 	& Signo - & \ader 	\\
	\code{not}	& Not Lógico		& \ader		\\
	\mihline%-------------------------------------------------
	\code{\codemod} 	& Modulo   		& \aiz		\\
	\code{/} 	& Division		& \aiz		\\
	\code{*}	& Multiplicación	& \aiz		\\
	\mihline%-------------------------------------------------
	\code{+} \footnotesize binario & Suma	& \aiz	 	\\
	\code{-} \footnotesize binario & Resta	& \aiz	 	\\
	\mihline%-------------------------------------------------
	\code{:} 	& Concatenación		& \aiz		\\		
	\mihline%-------------------------------------------------
	\code{::}	& Unión			& \aiz		\\	
	\mihline%-------------------------------------------------
	\code{\codemayor}	& Mayor que		& \ano		\\
	\code{\codemayor =}	& Mayor o igual que 	& \ano		\\
	\code{\codemenor}	& Menor que 		& \ano		\\
	\code{\codemenor =}	& Menor o igual que 	& \ano		\\
	\code{==}	& Igual a		& \ano		\\
	\code{!=}	& No igual a		& \ano		\\
	\code{===}	& Identico a 		& \ano		\\
	\code{!==}	& No idéntico a 	& \ano		\\
	\mihline%-------------------------------------------------
	\code{and}	& And Condicional	& \aiz		\\
	\mihline%-------------------------------------------------
	\code{or}	& Or Condicional	& \aiz		\\
	\mihline%-------------------------------------------------
	\code{=} 	& Asignación 		& \ader		\\
	\mihline%-------------------------------------------------
	\code{if}	& If-Else		& \ader		\\
	\code{while}	& Bucle While		& \ader		\\
	\code{do-while}	& Bucle Do-While	& \ader		\\
	\code{for}	& Bucle For		& \ader		\\
	\code{let}	& Declaración de variable local & \ader	\\
	\code{static}	& Evaluación es\-tática	& \ader		\\
	\code{return}	& Finalizar expresión	& \ader		\\
	\code{resend}	& Llamada al miembro heredado & \ano	\\
	\code{break}	& Finalizar bucle 	& \ano		\\
	\code{continue}	& Finalizar iteración	& \ano		\\
   	\mihline%-------------------------------------------------
	\code{;} 	& Secuencia		& \aiz		\\
	\mihlinefinal%--------------------------------------------
	\end{tabular}
	\end{center}
 	\caption{Precedencia y asociatividad de operadores}
	\label{figuraprecedenciaoperadores}
 	\end{figure}

%-------------------------------------------------------------------------------------------
\chapter{Ámbito de una declaración\label{ambito}}
%-------------------------------------------------------------------------------------------
	
	Excepto en el caso de objetos anónimos (\ref{objetosanonimos}), toda declaración asocia un identificador a la entidad declarada, de manera que ésta pueda referenciarse posteriormente. 
	
	Al producirse una referencia a un identificador durante una declaración o en el cuerpo de una expresión, debe comprobarse que dicho identificador es válido y ha sido debidamente declarado en el ámbito en el que se produce la referencia, mediante un proceso conocido de \emph{resolución de nombres} (\ref{resoluciondenombres}). 
	
	Cada nombre debe resolverse unívocamente en una entidad, por lo que es conveniente definir asimismo un \emph{espacio de nombres} para cada declaración (\ref{espaciodenombres}), que defina el rango de situaciones en el que la declaración repetida del mismo identificador deba ser considerada un error, por provocar una situación de ambigüedad durante la resolución.

	Asimismo, toda declaración tiene un \emph{alcance} (\ref{alcance}), que define el rango léxico en el que ésta se puede utilizar. Se permite que una declaración pueda \emph{ocultar} otra declaración anterior de un especio de nombres distinto, por lo que es necesario diferenciar asimismo entre \emph{alcance} y \emph{visibilidad} de un identificador. El alcance define el rango en el que se puede utilizar dicha declaración mientras que la visibilidad es\-tá asociada al rango en el que la o las entidades declaradas se pueden referenciar directamente mediante el identificador asociado.
		
%-------------------------------------------------------------------------------------------
\section{Espacio de nombres de una declaración\label{espaciodenombres}}
%-------------------------------------------------------------------------------------------

	\begin{enumerate}
		\item \emph{Objetos y miembros}: 
		
		Objetos y miembros comparten un mismo espacio de nombres, restringido léxicamente al cuerpo del objeto en el que han sido decladados.
		
		Por tanto, no es posible declarar un objeto y un miembro con el mismo nombre dentro del cuerpo del mismo objeto.
		
		\item \emph{Variables locales y argumentos}:
		
		El espacio de nombres de una variable local se restringe léxicamente a la subexpresión asociada a dicha variable local. 
		
		Por tanto, no es posible declarar dos variables locales con el mismo nombre en la misma expresión \code{let}. En el caso de los argumentos asociados a un miembro, éstos se consideran variables locales de la subexpresión más externa, por lo que no será posible declarar dos argumentos con el mismo nombre en el mismo miembro.	
	\end{enumerate}

%-------------------------------------------------------------------------------------------
\section{Álcance de una declaración\label{alcance}}
%-------------------------------------------------------------------------------------------

	\begin{enumerate}
		\item \emph{Objetos y miembros}:
		
		El alcance de una declaración en el caso de objetos y miembros se compone del cuerpo del objeto en el que son declarados y todas aquellas declaraciones anidadas dentro de dicho cuerpo, incluyendo objetos anidados y expresiones asociadas a los miembros del objeto.
		
		\item \emph{Variables locales y argumentos}:
		
		El alcance de una declaración de variable local será exclusivamente la subexpresión asociada a dicha variable y todas las subexpresiones contenidas a su vez dentro de esta. Los argumentos de un miembro se consideran a todos efectos variables locales de la subexpresión más externa.
		
	\end{enumerate}

%-------------------------------------------------------------------------------------------
\section{Resolución de nombres\label{resoluciondenombres}}
%-------------------------------------------------------------------------------------------

	El significado de un identificador que haya sido referenciado se determina buscando en el espacio de nombres en curso o en los espacios de nombres que lo contienen alguna declaración de dicho nombre. 
	
	El proceso concreto de búsqueda es:

	\begin{enumerate}
		\item Variables locales declaradas para la subexpresión en curso. Después, variables locales declaradas para la subexpresión que engloba a la actual, de manera ordenada y recursiva, hasta llegar a la subexpresión más externa. Los parámetros de un miembro se consideran variables locales de la subexpresión más externa.
		
		\item Miembros u objetos declarados en el cuerpo del objeto en curso, incluyendo miembros heredados. Después, miembros o objetos declarados dentro del objeto que engloba al actual, de manera ordenada y recursiva, hasta llegar al objeto más externo (programa).
	\end{enumerate}

	El proceso se detiene al encontrar la primera coincidencia, lo que implica que nombres declarados en ámbitos más externos pueden quedar ocultos por declaraciones en ámbitos más internos (ocultación de nombres).
	
	En caso de no encontrar ninguna asociación satisfactoria, se producirá un error\footnote{En el lenguaje propuesto, un nombre siempre puede resolverse de manera es\-tá\-ti\-ca por lo que el error se producirá en tiempo de compilación.}.

%-------------------------------------------------------------------------------------------
\chapter{Sintaxis}
%-------------------------------------------------------------------------------------------

%-------------------------------------------------------------------------------------------
\section{Gramática del lenguaje\label{gramatica}}
%-------------------------------------------------------------------------------------------

	A continuación se proporciona una gramática para el lenguaje propuesto. Debe notarse que existe una ambigüedad puntual en dicha gramática para el caso del emparejamiento if-else\footnote{\emph{Dangling else problem}.}, que deberá resolverse en todo caso de acuerdo con lo especificado en \ref{ifelse}.

{
\small
\itshape
 	\begin{longtable}{|lcp{10cm}|}
	\hline
 	&&\\
  	\endfirsthead
	\hline
   	\multicolumn{3}{|r|}{\upshape\footnotesize\emph{(continuación)}}\\
   	&&\\	
   	\endhead
	&&\\\hline
	\endfoot
	
	Main		& \der	& Programa\\
	&&\\	
 	Programa 	& \der 	& \ceromas{CuerpoObjeto}\\
 	&&\\
	Objeto		& \der  & \ceromas{ModificadorObjeto} \cerouno{Identificador \code{::}} Identificador \ceromas{\code{,} Identificador} CuerpoObjeto\\
	&&\\
	CuerpoObjeto & \der & \code{\codeabrellave} \code{\codecierrallave}\\
		     & \obien & \code{\codeabrellave} declobjeto \code{\codecierrallave}\\
		     & \obien & \code{\codeabrellave} NEWLINE \code{\codecierrallave}\\
		     & \obien & \code{\codeabrellave} NEWLINE INDENT declobjeto \ceromas{NEWLINE declobjeto} DEDENT NEWLINE \code{\codecierrallave}\\
	&&\\
	DeclObjeto & \der & Objeto\\
			& \obien & Miembro\\
	&&\\
	ModificadorObjeto & \der & \code{abstract}\\
			& \obien & \code{hidden}\\
			& \obien & \code{native}\\
	&&\\
	Miembro		& \der	& \ceromas{ModificadorMiembro} Identificador \cerouno{Argumentos} \code{:} CuerpoMiembro\\
	&&\\
	CuerpoMiembro & \der & \code{abstract}\\
			& \obien & \code{native}\\
			& \obien & \code{extern} LiteralCadena LiteralCadena LiteralCadena\\
			& \obien & Expresion\\
	&&\\
	ModificadorMiembro & \der & \code{shared}\\
			& \obien & \code{var}\\
	&&\\
	Argumentos	& \der	& \code{(} \cerouno{Identificador \ceromas{\code{,} Identificador}} \code{)}\\
	&&\\
	Parametros 	& \der	& \code{(} \cerouno{Expresion \ceromas{\code{,} Expresion}} \code{)}\\
	&&\\
	Expresion		& \der	 & Expresion15\\
				& \obien & Expresion \code{;} Expresion15\\
	&&\\
	Expresion15	& \der & \code{if} Expresion \cerouno{NEWLINE} \code{then} Expresion15 \cerouno{\code{else} Expresion15}\\
			& \obien & \code{else} Expresion15\\
			& \obien & \code{while} Expresion \cerouno{NEWLINE} \code{do} Expresion15\\
			& \obien & \code{do} Expresion \cerouno{NEWLINE} \code{while} Expresion15\\
			& \obien & \code{for} Expresion \code{,} Expresion \code{,} Expresion \cerouno{NEWLINE} \code{do} Expresion15\\
			& \obien & \code{break}\\
			& \obien & \code{continue}\\
			& \obien & \code{return} Expresion15\\
			& \obien & \code{static} Expresion15\\
 			& \obien & \code{resend} \cerouno{\code{@} Identificador \cerouno{\code{@} Identificador}} \cerouno{Parametros}\\
			& \obien & \code{let} Identificador \cerouno{\code{=} Expresion} \ceromas{\code{,} Identificador \cerouno{\code{=} Expresion}} \cerouno{NEWLINE} \code{in} Expresion15\\
			& \obien & Expresion20\\
	&&\\
	Expresion20		& \der	 & Expresion25\\
				& \obien & Expresion25 \code{=} Expresion20\\
	&&\\
	Expresion25		& \der   & Expresion30\\
				& \obien & Expresion25 \code{or} Expresion30\\
	&&\\
	Expresion30		& \der   & Expresion40\\
				& \obien & Expresion30 \code{and} Expresion40\\
	&&\\
	Expresion40		& \der 	 & Expresion60 \cerouno{OperadorComparacion Expresion60}\\
	&&\\
	Expresion60		& \der	 & Expresion70\\
				& \obien & Expresion60 \code{::} Expresion70\\
	&&\\
	Expresion70		& \der	 & Expresion90\\
				& \obien & Expresion70 \code{:} Expresion90\\
	&&\\
	Expresion90		& \der	 & Expresion100\\
				& \obien & Expresion90 OperadorArit1 Expresion100\\
	&&\\
	Expresion100		& \der	 & Expresion110\\
				& \obien & Expresion100 OperadorArit2 Expresion110\\
	&&\\
	Expresion110		& \der	 & Expresion120\\
				& \obien & OperadorPrefijo Expresion110\\
	&&\\
	Expresion120		& \der	 & Expresion130 \code{is} Identificador\\
				& \obien & Expresion130 \code{is not} Identificador\\
				& \obien & Expresion130 \code{has} Identificador\\
				& \obien & Expresion130 \code{has not} Identificador\\
	&&\\
	Expresion130		& \der		& Expresion140\\
				& \obien	& Expresion130 \code{[} Expresion \code{]}\\
				& \obien	& Expresion130 \code{.} Identificador \cerouno{parametros}\\
	&&\\
	Expresion140		& \der 		& \code{(} Expresion \code{)}\\
				& \obien	& NEWLINE INDENT Expresion \ceromas{NEWLINE expresion} DEDENT\\
				& \obien	& ExpresionAtomica\\
	&&\\
	ExpresionAtomica	& \der	 	& Literal\\
				& \obien	& Identificador \cerouno{Parametros}\\
	&&\\
	Literal		 	& \der  &   LiteralEntero\\
			 	& \obien&   LiteralFlotante\\
			 	& \obien&   LiteralCadena\\
			 	& \obien&   LiteralSecuencia\\
				& \obien&   \code{true}\\
				& \obien&   \code{false}\\
	&&\\
	LiteralSecuencia  	& \der	& \code{[} \cerouno{Expresion} \ceromas{\code{,} Expresion} \code{]}\\
 	&&\\
	OperadorComparacion	& \der & \uno{\ \code{==}\ \obien\ \code{!=}\ \obien\ \code{===}\ \obien\ \code{!==}\ \obien\ \code{\codemenor}\ \obien\ \code{\codemayor}\ \obien\ \code{\codemenor =}\ \obien\ \code{\codemayor =}\ }\\
	&&\\
	OperadorArit1 & \der & \uno{\ \code{+}\ \obien\ \code{-}\ }\\
	&&\\
	OperadorArit2 & \der & \uno{\ \code{*}\ \obien\ \code{/}\ \obien\ \code{\codemod}\ }\\
	&&\\
	OperadorPrefijo  & \der & \uno{\  	\code{not}
			 \ \obien\ 	\code{+}
			 \ \obien\ 	\code{-}\ }\\
	\end{longtable}
}

%-------------------------------------------------------------------------------------------
\section{Gramática del análisis léxico\label{gramaticaanalisislexico}}
%------------------------------------------------------------------------------------ -------

	Por completitud se proporciona una gramática para el análisis léxico, complementaria a la gramática del lenguaje (\ref{gramatica}). Asimismo, se describe la política de generación de marcas de fin de línea y sangrado.

	La gramática es en un principio ambigua, ya que no es\-tá implícita en ella la consideración (expresada en \ref{analisislexico}) de que en caso de existir más de un emparejamiento posible entre la secuencia de caracteres de entrada y varios \emph{tokens}, sólo se considere el emparejamiento más largo.

	Para evitar esta ambigüedad, se considera que el orden de declaración de las producciones es determinante a la hora de construcción del árbol sintáctico: en caso de ambigüedad se optará por la primera producción en perjuicio del resto.
	
{
\small
\itshape
 	\begin{longtable}{|lcp{11cm}|}
	\hline
 	&&\\
  	\endfirsthead
	\hline
   	\multicolumn{3}{|r|}{\upshape\footnotesize\emph{(continuación)}}\\
   	&&\\	
   	\endhead
	&&\\\hline
	\endfoot
	Comentario	& \der 	& \code{//} \uno{\footnotesize Cualquier secuencia que no contenga FinDeLinea}\\
			& \obien & \code{/*} \uno{\footnotesize Cualquier secuencia que no contenga \code{*/}} \code{*/}\\
	&&\\
	Identificador	& \der 	& \uno{Letra \obien \unomas{\code{\codeguionbajo}}} \ceromas{Letra \obien Digito}\\
	&&\\
	LiteralEntero	& \der   & \uno{\code{0b}\obien{\code{0B}}} \unomas{DigitoBinario}\\
			& \obien & \uno{\code{0o}\obien{\code{0O}}} \unomas{DigitoOctal}\\
			& \obien & \uno{\code{0x}\obien{\code{0X}}} \unomas{DigitoHexadecimal}\\
			& \obien & \unomas{DigitoDecimal}\\
			
	&&\\
	LiteralFlotante	& \der	& \unomas{DigitoDecimal} \code{.} \ceromas{DigitoDecimal} \cerouno{Exponente}\\
			& \obien & \code{.} \unomas{DigitoDecimal} \cerouno{Exponente}\\
			& \obien & \unomas{DigitoDecimal} Exponente\\
	&&\\
	LiteralCadena	& \der 	& \code{\codecomillas} \ceromas{Caracter}\code{\codecomillas}\\
	&&\\
	Exponente	& \der & \uno{\code{e}\obien\code{E}} \cerouno{\code{+}\obien\code{-}} \unomas{DigitoDecimal}\\
	&&\\
	Caracter 	& \der	 & \code{\codebackslash\codecomillas}\\
			& \obien & \code{\codebackslash\codebackslash}\\
			& \obien & \code{\codebackslash n}\\
			& \obien & {\footnotesize Cualquier carácter ASCII excepto: } \code{\codecomillas}\\
	&&\\
	DigitoBinario	& \der	& \uno{\code{0}\obien \code{1}}\\
	&&\\
	DigitoOctal	& \der	& \uno{\code{0}\obien \code{1}\obien \code{2}\obien \code{3}\obien \code{4}\obien \code{5}\obien \code{6}\obien \code{7}}\\
	&&\\
	DigitoDecimal	& \der & \uno{\code{0}\obien \code{1}\obien \code{2}\obien \code{3}\obien \code{4}\obien \code{5}\obien \code{6}\obien \code{7}\obien \code{8}\obien \code{9}}\\
	&&\\
	DigitoHexadecimal & \der & \uno{\code{0}\obien \code{1}\obien \code{2}\obien \code{3}\obien \code{4}\obien \code{5}\obien \code{6}\obien \code{7}\obien \code{8}\obien \code{9}\obien \code{a}\obien \code{b}\obien \code{c}\obien \code{d}\obien \code{e}\obien \code{f}\obien \code{A}\obien \code{B}\obien \code{C}\obien \code{D}\obien \code{E}\obien \code{F}}\\
	&&\\
	Digito		& \der	& DigitoDecimal\\
	&&\\
	Letra		& \der	& \uno{\code{a}\obien \code{b}\obien \code{c}\obien \code{d}\obien \code{e}\obien \code{f}\obien \code{g}\obien \code{h}\obien \code{i}\obien \code{j}\obien \code{k}\obien \code{l}\obien \code{m}\obien \code{n}\obien \code{o}\obien \code{p}\obien \code{q}\obien \code{r}\obien \code{s}\obien \code{t}\obien \code{u}\obien \code{v}\obien \code{w}\obien \code{x}\obien \code{y}\obien \code{z}\obien \code{A}\obien \code{B}\obien \code{C}\obien \code{D}\obien \code{E}\obien \code{F}\obien \code{G}\obien \code{H}\obien \code{I}\obien \code{J}\obien \code{K}\obien \code{L}\obien \code{M}\obien \code{N}\obien \code{O}\obien \code{P}\obien \code{Q}\obien \code{R}\obien \code{S}\obien \code{T}\obien \code{U}\obien \code{V}\obien \code{W}\obien \code{X}\obien \code{Y}\obien \code{Z}}\\
	&&\\
	Espacio		& \der  & \uno{ASCII \code{SP}\obien ASCII \code{HT}\obien ASCII \code{FF}}\\
	&&\\
	Fin de Línea   & \der & \uno{ASCII \code{CRLF}\obien ASCII \code{LF}\obien ASCII \code{CR}}\\
	&&\\
	NEWLINE		& \der & {(ver apartado sobre \textit{marcas de sangrado} a continuación de la gramática)}\\
	&&\\
	INDENT		& \der & {(ver apartado sobre \textit{marcas de sangrado} a continuación de la gramática)}\\
	&&\\
	DEDENT		& \der & {(ver apartado sobre \textit{marcas de sangrado} a continuación de la gramática)}\\
	&&\\
	DirectivaInclude\footnote{Nótese que no se considera ningún tipo de directiva \code{pragma}, ya que dicho tipo de directivas se definen a nivel de implementación, no de lenguaje.}	& \der	& \code{\codecarcel include} LiteralCadena\\
	\end{longtable}
}

%-------------------------------------------------------------------------------------------
\parrafo{Marcas de sangrado\label{tokenssangrado}\label{generaciontokenssangrado}}
%------------------------------------------------------------------------------------ -------

	La generación de marcas de sangrado NEWLINE, INDENT y DEDENT se realiza de acuerdo a la siguiente política:

	\begin{itemize}
		\item Si una línea tiene el mismo nivel de sangrado que la línea anterior (descartando líneas en blanco), se genera un token NEWLINE entre ambas líneas.
	
		\item Si una línea tiene un nivel de sangrado mayor que la línea anterior (descartando líneas en blanco), se generan los tokens NEWLINE e INDENT (en este orden) entre ambas, y se almacena el nuevo nivel de sangrado en una estructura tipo pila (\emph{stack})
	
		\item Si una línea tiene un nivel de sangrado menor que la línea anterior (descartando líneas en blanco), éste debe coincidir con alguno de los niveles de sangrado almacenados en la pila. En tal caso, se retirarán de la pila aquellos niveles de sangrado mayores que el actual y se generarán tantos tokens DEDENT como niveles de sangrado se hayan retirado de la pila, seguidos por un token NEWLINE. En caso de que el sangrado de la línea no coincida con ningún nivel de sangrado previo, se considerará que el sangrado es inconsistente con la especificación del lenguaje, debiendose mostrar un mensaje de error. Finalmente, si la pila de sangrado no está vacía al final del programa, se generará un token DEDENT por cada elemento en la pila.
	\end{itemize}
	
%-------------------------------------------------------------------------------------------
\chapter{Tipos de datos nativos\label{tiposdedatosnativos}}
%-------------------------------------------------------------------------------------------

%-------------------------------------------------------------------------------------------
\section{Tipo de dato objeto\label{tipodedatoobjeto}}
%-------------------------------------------------------------------------------------------

\newenvironment{tablamiembros}%
	{
		\small
		\begin{longtable}{p{0.36\linewidth}@{\ - \ }p{0.6\linewidth}}
		%\hline
	}%
	{
		%\hline
		\end{longtable}
		\normalsize
	}

\parrafo{Objeto}
		
	\code{object}
	
\parrafo{Padres}

	---

\parrafo{Descripción}

	El tipo de dato objeto es el tipo de dato básico del lenguaje propuesto. Todo objeto se deriva del tipo de dato objeto, incluyendo el resto de tipos de dato nativos.

\parrafo{Miembros (resumen)}
	
	\begin{tablamiembros}
	\code{self}& Devuelve el objeto actual\\
 	\code{copy}& Devuelve una copia superficial del objeto actual\\
	\code{deepCopy} & Devuelve una copia profunda del objeto actual\\
	\code{lexicalParent}& Devuelve el objeto que contiene al actual.\\
	\code{lexicalSons}& Devuelve un array con los objetos contenidos por el objeto actual\\
	\code{operatorEqual(x)} & Devuelve un objeto booleano indicando si el objeto \code{x} \emph{es} identico al actual\\
	\code{operatorNotEqual(x)} & Devuelve un objeto booleano indicando si el objeto \code{x} \emph{no es} identico al actual\\
	\code{toString}& Devuelve una representación del objeto en forma de cadena de caracteres\\
	\end{tablamiembros}

\parrafo{Miembros (detalle)}
	
	\begin{description}
 	\item[\code{self}]\ 
	
		El miembro \code{self} devuelve el objeto actual (es decir, el objeto cuyo miembro \code{self} ha sido evaluado). Se puede utilizar para acceder a declaraciones ocultas por parámetros o variables locales o simplemente para una mayor simplicidad en el código final. 
		
 	\item[\code{copy}]\ 
 	
 		El miembro copy devuelve una copia superficial del objeto actual, creando una nueva instancia del objeto con los mismos miembros del original. 
		
		Nótese que en el caso de objetos inmutables, este miembro podría redefinirse para devolver como resultado de su evaluación el propio objeto y no una copia del mismo para ahorrar recursos. En caso de no redefinirse, la copia se hará efectiva.

 	\item[\code{deepCopy}]\ 
 	
 		El miembro copy devuelve una copia profunda del objeto actual, creando una nueva instancia del objeto que contenga una copia exacta de cada uno de sus miembros (es decir, se realizará recursivamente una llamada a \code{deepCopy} para obtener a su vez una copia de cada uno de los miembros).
		
		Nótese que en el caso de objetos inmutables que no contengan (ni el propio objeto ni su ascendencia) objetos mutables, este miembro podría redefinirse para devolver como resultado de su evaluación el propio objeto y no una copia del mismo para ahorrar recursos. En caso de no redefinirse, la copia se hará efectiva.
		
	\item[\code{lexicalParent}]\ 
	
		El miembro \code{lexicalParent} devuelve como valor de retorno el objeto que contiene al actual (o la referencia nula en el caso de que el contenedor sea el objeto programa). Se puede utilizar para acceder a declaraciones ocultas por parámetros, variables locales o miembros del objeto actual, o simplemente para obtener una mayor simplicidad en la lectura del código fuente.
		
	\item[\code{lexicalSons}]\ 
	
		El miembro \code{lexicalSons} devuelve un array con los distintos objetos contenidos dentro del objeto actual (o el array vacío en caso de que el objeto actual no contenga ningún objeto). Puede utilizarse para definir y mantener una estructura de objetos en árbol utilizando la propia estructura léxica del programa como relación \emph{dentro de}.
		
	\item[\code{operatorEqual(x)}]\ 
	
		El miembro \code{operatorEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{es} identico al actual o un valor falso (\code{false}) en otro caso. 
	
	\item[\code{operatorNotEqual(x)}]\ 
	
		El miembro \code{operatorNotEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{no es} identico al actual o un valor falso (\code{false}) en otro caso.
	
	\item[\code{toString}]\ 
	
		El miembro \code{toString} devuelve una representación en forma de cadena de caracteres del objeto actual.
	\end{description}	

%-------------------------------------------------------------------------------------------
\section{Tipo de dato nulo\label{tiponull}\label{tipodedatonulo}}
%-------------------------------------------------------------------------------------------

\parrafo{Objeto}
	
	\code{null}
	
\parrafo{Padres}

	\code{object}

\parrafo{Descripción}

	El tipo de dato nulo es un tipo de dato especial utilizado para indicar referencias inválidas o ausencia de valor. Puede tomar sólo un valor, la referencia nula, representada por el objeto \code{null}.

\parrafo{Miembros (resumen)}

	\begin{tablamiembros}
 	\code{self} & Ver \code{object}\\
	\code{copy}& Devuelve una copia superficial del objeto actual\\
	\code{deepCopy} & Devuelve una copia profunda del objeto actual\\
	\code{lexicalParent}& Ver \code{object}\\
	\code{lexicalSons}& Ver \code{object}\\
	\code{operatorEqual(x)} & Devuelve un objeto booleano indicando si el objeto \code{x} \emph{es} una referencia nula\\
	\code{operatorNotEqual(x)} & Devuelve un objeto booleano indicando si el objeto \code{x} \emph{no es} una referencia nula\\
	\code{toString}& Devuelve una representación del objeto en forma de cadena de caracteres\\
	\end{tablamiembros}

\parrafo{Miembros (detalle)}

	\begin{description}
	\item[\code{operatorEqual(x)}]\ 
	
		El miembro \code{operatorEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{es} una referencia nula o un valor falso (\code{false}) en otro caso.
	
	\item[\code{operatorNotEqual(x)}]\ 
	
		El miembro \code{operatorNotEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{no es} una referencia nula o un valor falso (\code{false}) en otro caso.
	
	\item[\code{copy}]\ 
	
		El miembro \code{copy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable.
		
	\item[\code{deepCopy}]\ 		
	
		El miembro \code{deepCopy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable y no contener ni su ascendencia ningún objeto no inmutable.
	
	\item[\code{toString}]\ 
	
		El miembro \code{toString} devuelve una representación en forma de cadena de caracteres del objeto actual.
	\end{description}
		
%-------------------------------------------------------------------------------------------
\section{Tipo de dato booleano\label{tipoboolean}\label{tipobooleano}\label{tipodedatobooleano}}
%-------------------------------------------------------------------------------------------
	
\parrafo{Objeto}

	\code{boolean}
	
\parrafo{Padres}

	\code{object}
	
\parrafo{Descripción}
	
	El tipo de dato booleano representa un valor de verdad. Solo puede tomar dos valores: verdadero (representado por el literal \code{true}) y  falso (representado por el literal \code{false}).

\parrafo{Miembros (resumen)}

	\begin{tablamiembros}
 	\code{self} & Ver \code{object}\\
	\code{copy}& Devuelve una copia superficial del objeto actual\\
	\code{deepCopy} & Devuelve una copia profunda del objeto actual\\
	\code{lexicalParent}& Ver \code{object}\\
	\code{lexicalSons}& Ver \code{object}\\
	\code{operatorEqual(x)} & Devuelve un objeto booleano indicando si el objeto \code{x} \emph{es} un objeto booleano con el mismo valor de verdad\\
	\code{operatorNotEqual(x)} & Devuelve un objeto booleano indicando si el objeto \code{x} \emph{no es} un objeto booleano con el mismo valor de verdad\\
	\code{toString}& Devuelve una representación del objeto en forma de cadena de caracteres\\
	\end{tablamiembros}

\parrafo{Miembros (detalle)}

	\begin{description}
	\item[\code{copy}]\ 
	
		El miembro \code{copy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable.
		
	\item[\code{deepCopy}]\ 		
	
		El miembro \code{deepCopy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable y no contener ni su ascendencia ningún objeto no inmutable.
	
	\item[\code{operatorEqual(x)}]\ 
	
		El miembro \code{operatorEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{es} en un objeto booleano con el mismo valor de verdad que el objeto actual. 
	
	\item[\code{operatorNotEqual(x)}]\ 
	
		El miembro \code{operatorEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{no es} en un objeto booleano con el mismo valor de verdad que el objeto actual. 
	
	\item[\code{toString}]\ 
	
		El miembro \code{toString} devuelve una representación en forma de cadena de caracteres del objeto actual.
	\end{description}

%-------------------------------------------------------------------------------------------
\section{Tipo de dato nu\-mé\-ri\-co entero\label{tipointeger}\label{tipoentero}\label{tipodedatoentero}}
%-------------------------------------------------------------------------------------------

\parrafo{Objeto}
	
	\code{integer}
	
\parrafo{Padres}

	\code{object}

\parrafo{Descripción}
	
	El tipo de dato nu\-mé\-ri\-co entero representa números enteros en el rango $-2147483648$ hasta $2147483647$. 
	
	El tipo de dato nu\-mé\-ri\-co entero es inmutable; cualquier operación sobre un objeto nu\-mé\-ri\-co entero no alterará el valor contenido en dicho objeto, sino que creará un nuevo objeto con el valor resultado de la operación.
	
\parrafo{Miembros (resumen)}

	\begin{tablamiembros}
 	\code{self} & Ver \code{object}\\
	\code{copy}& Devuelve una copia superficial del objeto actual\\
	\code{deepCopy} & Devuelve una copia profunda del objeto actual\\
	\code{lexicalParent}& Ver \code{object}\\
	\code{lexicalSons}& Ver \code{object}\\
	\code{operatorPlus} & Devuelve un objeto nu\-mé\-ri\-co entero con el mismo valor y signo que el actual\\
	\code{operatorMinus} & Devuelve un objeto nu\-mé\-ri\-co entero con el mismo valor que el actual pero con el signo negado\\
	\code{operatorPlus(x)} & Devuelve un objeto nu\-mé\-ri\-co resultado de la suma del objeto actual y \code{x}\\
	\code{operatorMinus(x)} & Devuelve un objeto nu\-mé\-ri\-co resultado de la resta del objeto actual y \code{x}\\
	\code{o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)} & Devuelve un objeto nu\-mé\-ri\-co resultado de la multiplicación del objeto actual y \code{x}\\
	\code{operatorDivision(x)} & Devuelve un objeto nu\-mé\-ri\-co resultado de la división del objeto actual y \code{x}\\
	\code{operatorModulus(x)} & Devuelve un objeto nu\-mé\-ri\-co con el módulo \code{x} del objeto actual\\
	\code{operatorEqual(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es igual a} \code{x}\\
	\code{operatorNotEqual(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{no es igual a} \code{x}\\
	\code{operatorGreater(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es mayor que} \code{x}\\
	\code{operatorLess(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es menor que} \code{x}\\
	\code{operatorGreaterOrEqual(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es mayor o igual a} \code{x}\\
	\code{operatorLessOrEqual(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es menor o igual a} \code{x}\\
	\code{toFloat}& Devuelve una representación del objeto en formato nu\-mé\-ri\-co flotante\\
	\code{toString}& Devuelve una representación del objeto en forma de cadena de caracteres\\
	\end{tablamiembros}

\parrafo{Miembros (detalle)}
	
	\begin{description}
	\item[\code{copy}]\ 
	
		El miembro \code{copy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable.

	\item[\code{deepCopy}]\ 		
	
		El miembro \code{deepCopy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable y no contener ni su ascendencia ningún objeto no inmutable.
	
	\item[\code{operatorPlus}] \  
	
		El miembro \code{operatorPlus} devuelve un nuevo un objeto nu\-mé\-ri\-co entero con el mismo valor y signo que el actual. Equivale en todo caso a \code{self.copy} y solo se considera por completitud.
			
	\item[\code{operatorMinus}] \  
	
		El miembro \code{operatorMinus} devuelve un nuevo un objeto nu\-mé\-ri\-co entero con el mismo valor que el actual pero con el signo negado. 
		
	\item[\code{operatorPlus(x)}] \  
	
		El miembro \code{operatorPlus(x)} devuelve un nuevo objeto nu\-mé\-ri\-co resultado de la suma del objeto actual y \code{x}.
	
		En concreto, si \code{x} es un objeto nu\-mé\-ri\-co entero, \code{operatorPlus(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co entero resultado de la suma del objeto actual y \code{x}. 
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, \code{operatorPlus(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co flotante resultado de evaluar la expresión \code{self.toFloat.operatorPlus(x)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
		
	\item[\code{operatorMinus(x)}] \  		
	
		El miembro \code{operatorMinus(x)} devuelve un nuevo objeto nu\-mé\-ri\-co resultado de la resta del objeto actual y \code{x}.
	
		En concreto, si \code{x} es un objeto nu\-mé\-ri\-co entero, \code{operatorMinus(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co entero resultado de la resta del objeto actual y \code{x}. 
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, \code{operatorMinus(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co flotante resultado de evaluar la expresión \code{self.toFloat.operatorMinus(x)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
	
	\item[\code{o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)}] \  
	
		El miembro \code{o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)} devuelve un nuevo objeto nu\-mé\-ri\-co resultado de la multiplicación del objeto actual y \code{x}.
	
		En concreto, si \code{x} es un objeto nu\-mé\-ri\-co entero, \code{o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co entero resultado de la multiplicación del objeto actual y \code{x}. 
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, \code{o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co flotante resultado de evaluar la expresión \code{self.toFloat.o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.

	\item[\code{operatorDivision(x)}] \  
	
		El miembro \code{operatorDivision(x)} devuelve un nuevo objeto nu\-mé\-ri\-co resultado de la división del objeto actual y \code{x}.
	
		En concreto, si \code{x} es un objeto nu\-mé\-ri\-co entero, \code{operatorDivision(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co entero resultado de la división del objeto actual y \code{x}. 
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, \code{operatorDivision(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co flotante resultado de evaluar la expresión \code{self.toFloat.operatorDivision(x)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.

	\item[\code{operatorModulus(x)}] \  
	
		El miembro \code{operatorModulus(x)} devuelve un nuevo objeto nu\-mé\-ri\-co conteniendo el módulo \code{x} del objeto actual.
	
		En concreto, si \code{x} es un objeto nu\-mé\-ri\-co entero, \code{operatorModulus(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co entero conteniendo el módulo \code{x} del objeto actual. 
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, \code{operatorModulus(x)} devolverá como resultado de su evaluación un nuevo objeto nu\-mé\-ri\-co flotante resultado de evaluar la expresión \code{self.toFloat.operatorModulus(x)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
	
	\item[\code{operatorEqual(x)}] \  
	
		El miembro \code{operatorEqual(x)} devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es igual a} \code{x}.
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.toFloat.operatorEqual(x)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se devolverá el valor booleano \code{false}.
		
	\item[\code{operatorNotEqual(x)}] \  
	
		El miembro \code{operatorNotEqual(x)} devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{no es igual a} \code{x}.
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.toFloat.operatorNotEqual(x)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se devolverá el valor booleano \code{true}.
		
	\item[\code{operatorGreater(x)}] \  
	
		El miembro \code{operatorGreater(x)} devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es mayor que} \code{x}.
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.toFloat.operatorGreater(x)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.

	\item[\code{operatorLess(x)}] \  
	
		El miembro \code{operatorLess(x)} devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es menor que} \code{x}.
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.toFloat.operatorLess(x)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.

	\item[\code{operatorGreaterOrEqual(x)}] \  
	
		El miembro \code{operatorGreaterOrEqual(x)} devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es mayor o igual a} \code{x}
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.toFloat.operatorGreaterOrEqual(x)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
		
		
	\item[\code{operatorLessOrEqual(x)}] \  
	
		El miembro \code{operatorLessOrEqual(x)} devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es menor o igual a} \code{x}
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.toFloat.operatorLessOrEqual(x)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
	
	\item[\code{toFloat}]\ 
	
		El miembro \code{toFloat} devuelve una representación del objeto actual en forma de objeto nu\-mé\-ri\-co flotante. 
				
	\item[\code{toString}]\ 
	
		El miembro \code{toString} devuelve una representación en forma de cadena de caracteres del objeto actual.
	\end{description}
	
%-------------------------------------------------------------------------------------------
\section{Tipo de dato nu\-mé\-ri\-co flotante\label{tipofloat}\label{tipoflotante}\label{tipodedatoflotante}}
%-------------------------------------------------------------------------------------------

\parrafo{Objeto}

	\code{float}
	
\parrafo{Padres}
	
	\code{object}

\parrafo{Descripción}
	
	El tipo de dato nu\-mé\-ri\-co flotante representa números reales en coma flotante IEEE 754 de doble precisión. El rango efectivo de valores manejados y manejo de desbordamiento dependerá en última instancia del lenguaje objeto.

\parrafo{Miembros (resumen)}

	\begin{tablamiembros}
 	\code{self} & Ver \code{object}\\
	\code{copy}& Devuelve una copia superficial del objeto actual\\
	\code{deepCopy} & Devuelve una copia profunda del objeto actual\\
	\code{lexicalParent}& Ver \code{object}\\
	\code{lexicalSons}& Ver \code{object}\\
	\code{operatorPlus} & Devuelve un objeto nu\-mé\-ri\-co flotante con el mismo valor y signo que el actual\\
	\code{operatorMinus} & Devuelve un objeto nu\-mé\-ri\-co flotante con el mismo valor que el actual pero con el signo negado\\
	\code{operatorPlus(x)} & Devuelve un objeto nu\-mé\-ri\-co flotante resultado de la suma del objeto actual y \code{x}\\
	\code{operatorMinus(x)} & Devuelve un objeto nu\-mé\-ri\-co flotante resultado de la resta del objeto actual y \code{x}\\
	\code{o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)} & Devuelve un objeto nu\-mé\-ri\-co flotante resultado de la multiplicación del objeto actual y \code{x}\\
	\code{operatorDivision(x)} & Devuelve un objeto nu\-mé\-ri\-co flotante resultado de la división del objeto actual y \code{x}\\
	\code{operatorModulus(x)} & Devuelve un objeto nu\-mé\-ri\-co flotante con el módulo \code{x} del objeto actual\\
	\code{operatorEqual(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es igual a} \code{x}\\
	\code{operatorNotEqual(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{no es igual a} \code{x}\\
	\code{operatorGreater(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es mayor que} \code{x}\\
	\code{operatorLess(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es menor que} \code{x}\\
	\code{operatorGreaterOrEqual(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es mayor o igual a} \code{x}\\
	\code{operatorLessOrEqual(x)} & Devuelve un objeto booleano indicando si el valor entero contenido en el objeto \emph{es menor o igual a} \code{x}\\
	\code{toInteger}& Devuelve una representación del objeto en formato nu\-mé\-ri\-co entero\\
	\code{toString}& Devuelve una representación del objeto en forma de cadena de caracteres\\
	\end{tablamiembros}

\parrafo{Miembros (detalle)}
		
	\begin{description}
	\item[\code{copy}]\ 
	
		El miembro \code{copy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable.

	\item[\code{deepCopy}]\ 		
	
		El miembro \code{deepCopy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable y no contener ni su ascendencia ningún objeto no inmutable.
	
	\item[\code{operatorPlus}] \  
	
		El miembro \code{operatorPlus} devuelve un nuevo un objeto nu\-mé\-ri\-co flotante con el mismo valor y signo que el actual. Equivale en todo caso a \code{self.copy} y solo se considera por completitud.
			
	\item[\code{operatorMinus}] \  
	
		El miembro \code{operatorMinus} devuelve un nuevo un objeto nu\-mé\-ri\-co flotante con el mismo valor que el actual pero con el signo negado. 
		
	\item[\code{operatorPlus(x)}] \  
	
		El miembro \code{operatorPlus(x)} devuelve un nuevo objeto nu\-mé\-ri\-co flotante resultado de la suma del objeto actual y \code{x}. En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, \code{operatorPlus(x)} devolverá el resultado de evaluar la expresión \code{self.operatorPlus(x.toFloat)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
		
	\item[\code{operatorMinus(x)}] \  		
	
		El miembro \code{operatorMinus(x)} devuelve un nuevo objeto nu\-mé\-ri\-co flotante resultado de la resta del objeto actual y \code{x}. En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, \code{operatorMinus(x)} devolverá el resultado de evaluar la expresión \code{self.operatorMinus(x.toFloat)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
	
	\item[\code{o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)}] \  
	
		El miembro \code{o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)} devuelve un nuevo objeto nu\-mé\-ri\-co resultado de la multiplicación del objeto actual y \code{x}. En caso de que \code{x} sea un objeto nu\-mé\-ri\-co entero, \code{o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x)} devolverá el resultado de evaluar la expresión \code{self.o\-pe\-ra\-tor\-Mul\-ti\-pli\-ca\-tion(x.toFloat)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.

	\item[\code{operatorDivision(x)}] \  
	
		El miembro \code{operatorDivision(x)} devuelve un nuevo objeto nu\-mé\-ri\-co resultado de la división del objeto actual y \code{x}. En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, \code{operatorDivision(x)} devolverá el resultado de evaluar la expresión \code{self.operatorDivision(x.toFloat)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.

	\item[\code{operatorModulus(x)}] \  
	
		El miembro \code{operatorModulus(x)} devuelve un nuevo objeto nu\-mé\-ri\-co conteniendo el módulo \code{x} del objeto actual. En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, \code{operatorModulus(x)} devolverá el resultado de evaluar la expresión \code{self.operatorModulus(x.toFloat)}
		
		En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
	
	\item[\code{operatorEqual(x)}] \  
	
		El miembro \code{operatorEqual(x)} devuelve un objeto booleano indicando si el valor contenido en el objeto \emph{es igual a} \code{x}.
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co entero, el valor devuelto será el resultado de evaluar la expresión \code{self.operatorEqual(x.toFloat)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se devolverá el valor booleano \code{false}.
		
	\item[\code{operatorNotEqual(x)}] \  
	
		El miembro \code{operatorNotEqual(x)} devuelve un objeto booleano indicando si el valor contenido en el objeto \emph{no es igual a} \code{x}.
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.operatorNotEqual(x.toFloat)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se devolverá el valor booleano \code{false}.
		
	\item[\code{operatorGreater(x)}] \  
	
		El miembro \code{operatorGreater(x)} devuelve un objeto booleano indicando si el valor contenido en el objeto \emph{es mayor que} \code{x}.
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.operatorGreater(x.ToFloat)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.

	\item[\code{operatorLess(x)}] \  
	
		El miembro \code{operatorLess(x)} devuelve un objeto booleano indicando si el valor contenido en el objeto \emph{es menor que} \code{x}.
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.operatorLess(x.toFloat)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.

	\item[\code{operatorGreaterOrEqual(x)}] \  
	
		El miembro \code{operatorGreaterOrEqual(x)} devuelve un objeto booleano indicando si el valor contenido en el objeto \emph{es mayor o igual a} \code{x}
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.operatorGreaterOrEqual(x.toFloat)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
		
		
	\item[\code{operatorLessOrEqual(x)}] \  
	
		El miembro \code{operatorLessOrEqual(x)} devuelve un objeto booleano indicando si el valor contenido en el objeto \emph{es menor o igual a} \code{x}
		
		En caso de que \code{x} sea un objeto nu\-mé\-ri\-co flotante, el valor devuelto será el resultado de evaluar la expresión \code{self.operatorLessOrEqual(x.toFloat)}. En caso de que \code{x} no sea un objeto nu\-mé\-ri\-co de ningún tipo, se producirá un error.
	
	\item[\code{toInteger}]\ 
	
		El miembro \code{toInteger} devuelve una representación del objeto actual en forma de objeto nu\-mé\-ri\-co entero. 
				
	\item[\code{toString}]\ 
	
		El miembro \code{toString} devuelve una representación en forma de cadena de caracteres del objeto actual.
	\end{description}

%-------------------------------------------------------------------------------------------
\section{Tipo de dato cadena de caracteres\label{tipostring}}
%-------------------------------------------------------------------------------------------

\parrafo{Objeto}
	
	\code{string}

\parrafo{Padres}

	\code{object}
	
\parrafo{Descripción}
	
	El tipo de datos de cadena de caracteres representa una cadena de texto, compuesto por una secuencia ordenada de caracteres ASCII. El contenido de una cadena de caracteres es inmutable, lo que implica que no se puede modificar su contenido una vez creada.

\parrafo{Miembros (resumen)}
	
	\begin{tablamiembros}
 	\code{self} & Ver \code{object}\\
	\code{copy}& Devuelve una copia superficial del objeto actual\\
	\code{deepCopy} & Devuelve una copia profunda del objeto actual\\
	\code{lexicalParent}& Ver \code{object}\\
	\code{lexicalSons}& Ver \code{object}\\
	\code{operatorEqual(x)} & El miembro \code{operatorEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{representa} la misma cadena de caracteres que el objeto actual.\\
	\code{operatorNotEqual(x)} & El miembro \code{operatorEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{no representa} la misma cadena de caracteres que el objeto actual.\\
	\code{length} & Devuelve la longitud de la cadena expresada en número de caracteres\\
	\code{operatorGet(indice)} & Devuelve una cadena conteniendo el caracter en la posición \code{x} de la cadena.\\
	\code{operatorConcat(x)} & Devuelve una nueva cadena resultado de añadir \code{x} a la cadena actual.\\
	\code{tokens} & Separa una cadena de caracteres en \emph{tokens}\\
	\code{tokens(x)} & Separa una cadena de caracteres en \emph{tokens}\\
	\code{toLower} & Devuelve una version en minúsculas de la cadena\\
	\code{toUpper} & Devuelve una version en mayúsculas de la cadena\\
	\code{toString}& Devuelve una representación del objeto en forma de cadena de caracteres\\
	\end{tablamiembros}

\parrafo{Miembros (detalle)}

	\begin{description}
	\item[\code{copy}]\ 
	
		El miembro \code{copy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable.
		
	\item[\code{deepCopy}]\ 		
	
		El miembro \code{deepCopy} devuelve el propio objeto (miembro \code{self}), al ser éste inmutable y no contener ni su ascendencia ningún objeto no inmutable.
	
	\item[\code{operatorEqual(x)}]\ 
	
		El miembro \code{operatorEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{representa} la misma cadena de caracteres que el objeto actual. 
	
	\item[\code{operatorNotEqual(x)}]\ 
	
		El miembro \code{operatorEqual(x)} devuelve un valor verdadero (\code{true}) si el objeto \code{x} \emph{no representa} la misma cadena de caracteres que el objeto actual. 
	
	\item[\code{length}]\ 
	
		El miembro \code{length} devuelve un objeto nu\-mé\-ri\-co entero con la longitud de la cadena (expresada en número de caracteres). La longitud puede ser cero en el caso de cadenas vacías.
		

	\item[\code{operatorGet(indice)}]\ 
		
		El miembro \code{operatorGet(x)} devuelve una nueva cadena de caracteres de longitud 1, conteniendo el caracter en la posición \code{x} de la cadena. El primer elemento de la cadena corresponderá al índice \code{0}.
		
		El parámetro \code{x} debe ser un objeto nu\-mé\-ri\-co entero cuyo valor esté contenido entre \code{0} y \code{length-1}. En otro caso se producirá un error.
	
	\item[\code{operatorConcat(x)}]\ 
	
		El miembro \code{operatorConcat(x)} devuelve una nueva cadena de caracteres resultado de concatenar la cadena actual con la cadena \code{x}. En caso de que \code{x} no sea una cadena de caracteres, se producirá un error.

	\item[\code{tokens}]\ 
	
		El miembro \code{tokens} devuelve un array de cadenas de caracteres resultado de separar en \emph{tokens} la cadena de caracteres representada por el objeto actual. La separación en \emph{tokens} se realizará utilizando los espacios o fines de línea como separadores entre \emph{tokens}.
			
	\item[\code{tokens(x)}]\ 
	
		Devuelve un array de cadenas de caracteres resultado de separar en \emph{tokens} la cadena de caracteres representada por el objeto actual. La separación en \emph{tokens} se realizará utilizando cualquiera de los caracteres contenidos en la cadena de caracteres \code{x} como separador. En caso de que \code{x} no sea una cadena de caracteres, se producirá un error.
		
	\item[\code{toLower}]\ 

		Devuelve una nueva cadena de caracteres resultado de convertir a minúsculas la cadena actual.
		
	\item[\code{toUpper}]\ 

		Devuelve una nueva cadena de caracteres resultado de convertir a mayúsculas la cadena actual.
	
	\item[\code{toString}]\ 
	
		El miembro \code{toString} devuelve una representación en forma de cadena de caracteres del objeto actual.
	\end{description}
	
%-------------------------------------------------------------------------------------------
\section{Tipo de dato array\label{tipoarray}}
%-------------------------------------------------------------------------------------------

\parrafo{Objeto}

	\code{array}
	
\parrafo{Padres}

	\code{object}

\parrafo{Descripción}
	
	Un array representa una secuencia ordenada de objetos. A cada elemente del array se puede acceder de manera inequívoca mediante un índice entero indicador de la posición que ocupa dicho elemento dentro del array. El primer elemento de un array se asociará al índice \code{0}.
	
\parrafo{Miembros (resumen)}
	
	\begin{tablamiembros}
 	\code{self} & Ver \code{object}\\
	\code{copy}& Ver \code{object}\\
	\code{deepCopy} & Ver \code{object}\\
	\code{lexicalParent}& Ver \code{object}\\
	\code{lexicalSons}& Ver \code{object}\\
	\code{operatorEqual(x)} & Devuelve un objeto booleano indicando si el objeto \code{x} \emph{es} un array equivalente al actual\\
	\code{operatorNotEqual(x)} & Devuelve un objeto booleano indicando si el objeto \code{x} \emph{no es} un array equivalente al actual\\
	\code{length} & Devuelve la longitud del array expresada en número de caracteres\\
	\code{operatorGet(indice)} & Devuelve el elemento correspondiente a ese índice dentro del array\\
	\code{operatorSet(indice,x)} & Modifica el elemento correspondiente a ese índice dentro del array\\
	\code{operatorUnion(x)} & Realiza la unión de dos arrays\\
	\code{toString}& Devuelve una representación del objeto en forma de cadena de caracteres\\
	\end{tablamiembros}

\parrafo{Miembros (detalle)}

	\begin{description}
	\item[\code{operatorEqual(x)}]\ 
	
		El miembro \code{operatorEqual(x)} devuelve un objeto booleano indicando si el objeto \code{x} \emph{es} un array equivalente al actual. Un array será equivalente a otro si contiene el mismo número de elementos y para todos los posibles índices \code{i} del array se cumple \code{self.operatorGet(i)==x.operatorGet(i)}.
	
	\item[\code{operatorNotEqual(x)}]\ 
	
		El miembro \code{operatorEqual(x)} devuelve un objeto booleano indicando si el objeto \code{x} \emph{no es} un array equivalente al actual. Un array será equivalente a otro si contiene el mismo número de elementos y para todos los posibles índices \code{i} del array se cumple \code{self.operatorGet(i)==x.operatorGet(i)}.
	
	\item[\code{length}]\ 
	
		El miembro \code{length} devuelve un objeto nu\-mé\-ri\-co entero con la longitud del array (expresada en número de elementos contenidos en el array). La longitud puede ser cero en el caso de arrays vacíos.

	\item[\code{operatorGet(indice)}]\ 
		
		El miembro \code{operatorGet(indice)} devuelve el elemento en la posición \code{indice} del array. Nótese que el primer elemento del array se corresponde con el índice \code{0}.
		
		El parámetro \code{x} debe ser un objeto nu\-mé\-ri\-co entero cuyo valor esté contenido entre \code{0} y \code{length-1}. En otro caso se producirá un error.
	
	\item[\code{operatorSet(indice,x)}]\ 
		
		El miembro \code{operatorSet(indice,x)} asocia el elemento \code{x} a la posición \code{indice} del array. Nótese que el primer elemento del array se corresponde con el índice \code{0}.
		
		El parámetro \code{x} debe ser un objeto nu\-mé\-ri\-co entero cuyo valor esté contenido entre \code{0} y \code{length-1}. En otro caso se producirá un error.
	
	\item[\code{operatorConcat(x)}]\ 
	
		El miembro \code{operatorConcat(x)} devuelve un nuevo array resultado de unir el array actual con el array \code{x}. La unión se realizará de manera ordenada, de forma que los elementos del objeto actual conservarán sus índices, y se añadirán al final del array los elementos contenidos en \code{x}.
		
		En caso de que \code{x} no sea un array, se producirá un error.
	
	\item[\code{toString}]\ 
	
		El miembro \code{toString} devuelve una representación en forma de cadena de caracteres del objeto actual.
	\end{description}

%-------------------------------------------------------------------------------------------
\chapter{Librería es\-tándar\label{libreriaestandar}}
%-------------------------------------------------------------------------------------------

	Además de los tipos de datos nativos, se proporciona de manera nativa una libería pequeña librería es\-tándar.

%-------------------------------------------------------------------------------------------
\section{Interfaz con el sistema}
%-------------------------------------------------------------------------------------------

\parrafo{Objeto}

	\code{system}

\parrafo{Padres}

	\code{object}

\parrafo{Descripción}

	Interfaz básico con el sistema operativo subyacente (entrada y salida es\-tándar, finalización del programa en curso, etc).
	
\parrafo{Miembros (resumen)}

	\begin{tablamiembros}
		\code{print(x)} &  Escribe una cadena de caracteres a la salida es\-tándar\\
		\code{println(x)} &  Escribe una linea de caracteres a la salida es\-tándar\\
		\code{readln} &  Lee una linea de de caracteres de la entrada es\-tándar\\
		\code{exit} &  Termina el programa en curso\\
	\end{tablamiembros}

\parrafo{Miembros (detalle)}

	\begin{description}
	\item[\code{print(x)}]\ 
	
		El miembro \code{print(x)} escribe la cadena de caracteres \code{x} a la salida es\-tándar. En caso de que \code{x} no sea una cadena de caracteres, se producirá un error.
		
	\item[\code{println(x)}]\ 
	
		El miembro \code{print(x)} escribe la cadena de caracteres \code{x} a la salida es\-tándar, seguida de un retorno de carro. En caso de que \code{x} no sea una cadena de caracteres, se producirá un error.
	
	\item[\code{readln}]\  
	
		El miembro \code{readln} devuelve una cadena de caracteres resultado de leer la entrada es\-tándar hasta la ocurrencia de un retorno de carro.
		
	\item[\code{exit}]\ 
	
		El miembro \code{exit} termina abruptamente la ejecución del programa en curso.
	\end{description}
	
%-------------------------------------------------------------------------------------------
\chapter{GNU Free Documentation License}
%-------------------------------------------------------------------------------------------

	\input{fdl.tex}

\end{document}
