Sintaxis de Gobstones

Version 2.10
Pablo E. Martnez Lopez
fidel@unq.edu.ar

Eduardo Bonelli
ebonelli@unq.edu.ar

21 de marzo de 2010

A.

Sintaxis de Gobstones

Este documento presenta una breve referencia de la estructura de un programa

Gobstones en su versi
on 2.10, con la intencion de servir de consulta rapida.
Para la presentaci
on se utiliza notacion estilo BNF, que es com
un en la manera
de transmitir estructura de lenguajes de programacion. En esta notacion se presentan
conjuntos de elementos a traves de un nombre, lo cual se escribe como
< conjunto >
y se asocia ese nombre con las diferentes formas que puede tener a traves de una clausula
de formato llamada producci
on, la cual se escribe como
< conjunto > definici
on
y donde la definici
on puede contener alternativas separadas por el smbolo |, o sea,
< conjunto > alternativa1 | alternativa2 | . . . | alternativan
y los smbolos en negrita determinan elementos finales.
Por ejemplo, la siguiente definicion
< conj >
< elem >

< elem1 > -> < elem2 >

X|Y

determina que los elementos del conjunto < elem > son X e Y, y los del conjunto < conj >
son X->X, X->Y, Y->X e Y->Y. Observar que < elem1 > adopta todas las posibles formas
de un elemento del conjunto < elem >, y lo mismo para < elem2 >, y que poner dos
elementos juntos simplemente los coloca uno a continuacion del otro.
La notaci
on permite adem
as elementos opcionales, escrito como
[< elemOpcional >]
y eliminaci
on de los elementos de un conjunto de otro conjunto dado, escrito como
< conjBase >/< conjAEliminar >

Por ejemplo, modificando la definicion anterior a

< conj >
< elem >

< elem1 > [->< elem2 >]

X|Y

los elementos de < conj > seran los de antes, mas X e Y, pues el smbolo -> y el siguiente
elemento se anotaron como opcionales. Si en cambio se definiese
< ej >
< conj >
< elem >
< idem >

< conj >/< idem >

< elem1 > -> < elem2 >
X|Y
X -> X

los elementos del conjunto < ej > seran X->Y, Y->X e Y->Y. Observar que X->X esta en
el conjunto < conj > pero no en el conjunto < ej >.
Con esta notaci
on, podemos escribir la forma de un programa Gobstones, lo cual se
lleva a cabo en las siguientes subsecciones.

A.1.

Programas Gobstones

Un programa Gobstones es un elemento del conjunto < gobstones >. Cada programa
est
a conformado por una lista de definiciones de procedimientos o funciones, la u
ltima
de las cuales es la definici
on del procedimiento Main.
< gobstones >

< defs >

< defs >

< def >
< maindef >

< maindef > | < def >< defs >

procedure < procName > < params > < procBody >
function < funcName > < params > < funBody >
procedure Main() < mainBody >

< params >

< varTuple >

El cuerpo de un procedimiento es una lista de comandos encerrados entre llaves.

El cuerpo de una funci
on es similar, excepto que termina con el comando return.
Finalmente, el cuerpo de Main tiene un return opcional, pero solo de variables.
< procBody >
< funcBody >
< mainBody >

{ < cmds > }

{ < cmds > return < gexpTuple >[;] }
{ < cmds > [return < varTuple >[;]] }

Los comandos se definen en la siguiente seccion (A.2), las tuplas de expresiones y

variables, en la secci
on A.4, y los nombres de funciones y procedimientos tambien en la
secci
on A.4.

A.2.

Comandos

Los comandos pueden ser simples o compuestos, y pueden estar agrupados en bloques.
2

< blockcmd >

< cmds >
< necmds >
< cmd >

{ < cmds > }

[< necmds >[;]]
< cmd > | < cmd >[;] < necmds >
< simplecmd > | < compcmd >

Los comandos simples son los comandos basicos del cabezal, la invocacion de procedimientos y la asignaci
on (de variables, y de resultados de llamados a funcion).
< simplecmd >

< procCall >

|
|
|
|
|
|
|
|
|

Skip
BOOM(< string >)
Poner(< gexp >)
Sacar(< gexp >)
Mover(< gexp >)
IrAlOrigen()
VaciarTablero()
< procCall >
< varName > := < gexp >
< varTuple > := < funcCall >
< procName > < args >

Las invocaciones a funci

on y los argumentos para las invocaciones se describen en la
secci
on A.3, y los nombres de variables en la seccion A.4.
Los comandos compuestos son las alternativas (condicional e indexada), las repeticiones (condicional e indexada) y los bloques.
< compcmd >

|
|
|
|
|

if (< gexp >) < blockcmd > else < blockcmd >
if (< gexp >) < blockcmd >
case (< gexp >) of < branches >
while (< gexp >) < blockcmd >
repeatWith < varName > in < range > < blockcmd >
< blockcmd >

< range >

< branches >

|
|

< gexp >..< gexp >

-> < blockcmd >
< lits > -> < blockcmd >[;] < branches >
< literal > | < literal >, < lits >

< lits >

El conjunto de literales < literal > se define en la seccion A.3.

Observar que las condiciones de las alternativas y de la repeticion condicional deben
ir obligatoriamente entre parentesis.

A.3.

Expresiones

La expresiones se obtienen combinando ciertas formas basicas en distintos niveles.

El nivel b
asico tiene las variables, las expresiones atomicas para indicarle al cabezal que
cense del tablero, los literales, y las invocaciones de funcion y primitivas. Sobre ese nivel
se construyen las expresiones aritmeticas (sumas, productos, etc.) con la precedencia
habitual. Sobre el nivel aritmetico se construyen las expresiones relacionales (compara3

ci
on entre n
umeros y otros literales) y sobre ellas, las expresiones booleanas (negacion,
conjunci
on y disyunci
on) tambien con la precedencia habitual.

|
|
|
|
|
|
|
|
|
|
|
|

< bexp >

< bterm > | < bterm >||< bexp >
< bfact > | < bfact >&&< bterm >
not < batom > | < batom >
< nexp >
< nexp >< rop >< nexp >
< nterm > | < nexp >< nop >< nterm >
< nfactH > | < nterm >*< nfactH >
< nfactL > | < nfactL >< mop >< nfactL >
< natom > | < nfactL >^< natom >
< varName >
< liter >
-< natom >
nroBolitas(< gexp >)
hayBolitas(< gexp >)
puedeMover(< gexp >)
minBool() | maxBool()
minDir() | maxDir()
minColor() | maxColor()
siguiente(< gexp >) | previo(< gexp >)
opuesto(< gexp >)
< funcCall >
(< gexp >)

< rop >

< nop >
< mop >

== | /= | < | <= | >= | >

+|div | mod

< funcCall >

< args >

< funcName > < args >

< gexpTuple >

< gexp >

< bexp >
< bterm >
< bfact >
< batom >
< nexp >
< nterm >
< nfactH >
< nfactL >
< natom >

(infixr)
(infixr)

(infixl)
(infixl)
(infixl)

Las tuplas de expresiones se definen en la seccion A.4.

Los literales pueden ser numericos, booleanos, de color o de direccion.
< literal >
< literN >
< literB >
< literC >
< literD >

< literN > | < literB > | < literC > | < literD >
< num >
False | True
Verde | Rojo | Azul | Negro
Norte | Sur | Este | Oeste

La forma de los n
umeros se definen en la seccion A.5

A.4.

Definiciones auxiliares

En esta secci
on se definen diversos conjuntos utilizados como auxiliares en las definiciones previas. Los nombres de variables y de funciones son identificadores que co-

mienzan con min

usculas. Los nombres de los procedimientos son identificadores que
empiezan con may
usculas.
< varName >
< funcName >
< procName >

< lowerid >

< lowerid >
< upperid >

Las tuplas son listas de elementos encerrados entre parentesis y separados por comas.
Opcionalmente, una tupla puede estar vaca, o sea, no contener ning
un elemento.
< varTuple >
< varNames >

() | (< varNames >)

< varName > | < varName >,< varNames >

< gexpTuple >

< gexps >

() | (< gexps >)

< gexp > | < gexp >,< gexps >

A.5.

Definiciones lexicogr
aficas

Las definiciones lexicogr

aficas establecen la forma de las palabras que conforman
el lenguaje. Ellas incluyen los n
umeros, los identificadores, las palabras reservadas, los
operadores reservados y los comentarios.
Los n
umeros son simplemente secuencias de dgitos.
< num >
< digits >
< digit >
< nonzerod >

< digit > | < nonzerodigit > < digits > | -< num >
< digit > | < digit > < num >
0 | < nonzerod >
1|2|3|4|5|6|7|8|9

Los identificadores son de dos tipos: los que comienzan con min
uscula y los que
comienzan con may
uscula. El smbolo de tilde () puede ser parte de un identificador
(excepto el primero). Las palabras reservadas no pueden ser identificadores.
< lowerid >
< lowname >
< lowchar >

< lowname >/< reservedid >

< lowchar > | < lowchar > < chars >
a | ... | z

< upperid >

< uppname >
< uppchar >

< uppname >/< reservedid >

< uppchar > | < uppchar > < chars >
A | ... | Z

< chars >

< char >

< char > | < char > < chars >

< lowchar > | < uppchar > | < digit > | |

Los strings son secuencias de caracteres distintos de la comilla doble ("), encerrados
entre comillas dobles.

< string >

" < anySymbols >/" "

Algunos caracteres pueden usarse precedidos por una barra (\) llamada escape. Dentro de un string, la barra \\ y las comillas dobles \" siempre deben escaparse. La
categora de caracteres escapados incluye representaciones portables para los caracteres
alert(\a), backspace(\b), form feed (\f), new line (\n), carriage return(\r),
horizontal tab (\t), and vertical tab (\v). Observar que las comillas escapadas no
son consideradas comillas, por lo que pueden usarse dentro de un string.
Las palabras y los smbolos reservados son todos aquellos utilizados en alg
un comando predefinido o como separadores.
< reservedid >

< reservedop >

|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|

|
|
|
|

if | else | not | True | False

case | of
while | Skip
repeatWith | in
procedure | function | return
Mover | Poner | Sacar
BOOM
IrAlOrigen | VaciarTablero
div | mod
hayBolitas | nroBolitas | puedeMover
Norte | Sur | Este | Oeste
minBool | maxBool
minDir | maxDir
minColor | maxColor
siguiente | previo
opuesto
Verde | Rojo | Azul | Negro
:= | ..
,|;|(|)|{|}
|| | && | + | * | - | ^
== | /= | < | <= | >= | >
-- | {- | -} | // | /* | */

Finalmente, los comentarios son de lnea o de parrafo. Los primeros empiezan con
uno de los smbolos reservados -- o // y terminan con el fin de lnea, y los segundos
empiezan con los smbolos reservados {- o /* y terminan con la primera aparicion del
smbolo -} o */ respectivamente.
< comment >
< linecomm >
< parcomm >

< linecomm > | < parcomm >

-- < anySymbols >/\n \n
// < anySymbols >/\n \n
{- < anySymbols >/-} -}
/* < anySymbols >/*/ */