===== El lenguaje de script SSL =====

Para cubir ciertas funcionalidades como el manejo de variables de perfil, variables de sesión, preguntas condiciones, y funciones de evaluación, Siette ha definido su propio lenguaje de programación de scripts, denominado SSL (//Siette Script Language//).

Es un lenhguaje sencillo, con una sintaxis similar a la familia de C, Java y Javascript, con muchas menos funcionalidades (ya que solo se pretende usar para escribir pequeños trozos de código) y con algunas facilidades añadidas para manejar los ítems y las respuestas de los alumnos. En esta sección no se pretende describir exhaustivamente el lenguaje ni enseñar su funcionamiento. Calquier programador acostumbrado a Java o Javascript entenderá facilmente como usarlo. Se hará especial hincapié en las diferencias con estos lenguajes.

En cada una de las secciones de Siette donde se usa el lenguaje se describe su funcionalidad. En esta página se describe el lenguaje en si desde el punto de vista léxico y sintáctico:

==== Aspectos léxicos ====

=== Separadores y comentarios ===
Los espacios en blanco, tabuladores uy fin de línea solo sirven para separar las palabras. Se utilizan dos tipos de comentarios al igual que en Java/Javascript

    * <nowiki>//</nowiki> desde este punto hasta final de línea se considera un comentario.
    * <nowiki>/* .. */</nowiki> todo lo incluido dentro es un comentario.

=== Constantes numéricas ===
En SSL no hay tipos, no se hace distinción entre números enteros y números reales. Todas las operaciones que implican números se ejecutan como números reales. Desde el punto de vista léxico las constantes numércias se escriben de la misma forma que en Java/Javascript. Asimismo se pueden usar números en formato octal y hexadecimal.

=== Constantes de cadenas de caracteres ===
al igual que en Javascript las constantes de caracteres se pueden escribir de dos formas, con comillas simples, o comillas dobles al principio y al final de la cadena. Se pueden utilizar caracteres de escape habituales para fin de línea, tabuladores, etc. y para los caracteres en unicode, i.e: '\u1234'

=== Palabras reservadas ===
Son palabras reservadas aquellas que tienen un significado especial en el lenguaje, entre ellas:

    int float char boolean
    true false
    if else 
    do while 
    for in to downto step 
    switch
    return 
    print length 
    round  

a las que hay que añadir los identificadores predefinidos. Actualmente no todas las sentencias correspondientes a algunas de estas palabras reservadas están implementadas, algunas están simplemente reservadas para futuros usos.

=== Identificadores ===
Siguen las mismas reglas que en Java/Javascript. La mayor diferencia es que dependiendo del contexto hay algunos identificadores predefinidos que toman un valor dependiendo del contexto. Entre ellos:

    * ''answer''. contiene el texto de la respuesta del alumno. En caso de que la respuesta del alumno sea múltiple la variable ''answer'' contiene una matriz que puede accederse como ''answer[0]'', ''answer[1]'', etc. En ese caso la variable ''answer'' sigue conservando la matriz completa.
    * ''respuesta'', contiene exactamente lo mismo que la anterior, para poder escribir el código en español.

=== Operadores ===
Los operadores son tambien los habituales en Java/Javascript, con la misma prioridad y asociatividad que en estos lenguajes, no se han implementado los operadores a nivel de bits. El siguiente cuadro reumen los operadores del lenguaje de mayor a menor prioridad:

^Operador ^Tipo ^Asociatividad ^
|<nowiki>++ --</nowiki> |Aritmetico, unario, notación postfija 	|Derecha |
|<nowiki>++ -- + -</nowiki> |Aritmetico, unario, notación prefija |Derecha |
|(int) (float) (char) (boolean) (string) |Cast, unario, notacion prefija | Derecha |
|* / % 	|Aritméticos, binarios 	|Izquierda |
|+ - 	|Aritméticos, binarios 	|Izquierda |
|<nowiki>< <= > >=</nowiki> |Relacionales, binarios 	|Izquierda |
|== != 	|Relacionales, binarios 	|Izquierda |
|!      |Lógico, unario, notación prefija 	|Derecha |
|&& 	|Lógico, binario 	|Izquierda |
|<nowiki>||</nowiki> 	|Lógico, binario 	|Izquierda |
|?: 	|Operador condicional, ternario 	|Derecha |
|= += -= *= /= %= 	|Asignación, binario 	|Derecha |


==== Aspectos sintácticos ====

Desde un punto de vita sintactico un programa es una lista de sentencias, que a su vez pueden ser simples o compuestas. El lenguaje no tiene tipos y no requiere de sentencias de declaración. Tampoco tiene funciones, salvo algunas predefinidas. Para describir la sintaxis se utiliza una gramática de contexto libre siguiendo la notación clásica de [[wpes>YACC]] ((Las secuencias entre comillas representan símbolos terminales del lenguaje, asi como los identificadores en mayúsculas. Los identificadores en minúsculas son símbolos no terminales)). Este sería el cuerpo principal de esta gramática:

<code>
axioma: listaSent
      ;
         
listaSent: listaSent sent 
         |  
         ;

sent: sentComp
    | asig optPYC 
    | sentReturn optPYC
    | sentIf  
    | sentWhile 
    | sentDo optPYC
    | sentFor
    | sentPrint 
    ;

optPYC: ';'
       |
       ;
       
sentComp: '{' listaSent '}'
	;				
</code>

=== Expresiones ===
Son prácticamente las mismas que en Javascript, añadiendole el [[wp>Elvis_operator|operador elvis]]. Las variables pueden ser variables simples o matrices de una sola dimensión, en cuyo caso pueden estar indexadas por una expresión.

<code>
exp: exp '+' exp
   | exp '-' exp
   | exp '*' exp
   | exp '/' exp
   | exp '%' exp
   | '-' exp
   | cond '?' exp ':' exp
   | exp '?:' exp
   | '(int)' exp
   | 'round' '(' exp ')'
   | '(' exp ')'
   | var
   | asig
   | CONSTANTE_ENTERA
   | CONSTANTE_REAL
   | CONSTANTE_STRING
   ;

var: IDENTIFICADOR
   ;
</code>

=== Condiciones ===
Son expresiones lógicas que tienen como resultado un valor booleano.

<code>
cond: exp '==' exp
    | exp '!=' exp
    | exp '<' exp
    | exp '<=' exp
    | exp '>=' exp
    | exp '>' exp
    | cond '||' cond
    | cond '&&' cond
    | '!' cond  
    | '(' cond ')'   
    | 'true'
    | 'false'
    ;  
</code>

=== Sentencias de asignación ===
Lo mas destacable de las sentencias de asignación de SSL es que puede asignarse a una variable el valor booleano de una condición

<code>
asig: var '=' exp
    | var '=' cond
    | var '+=' exp
    | var '-=' exp
    | var '*=' exp
    | var '/=' exp
    | '++' var
    | '--' var
    | var '++'
    | var '--'
    ;	
</code>

=== Sentencia if ===

<code>
sentIf: 'if' '(' cond ')' sent
      | 'if' '(' cond ')' sent 'else' sent
      ;	
</code>


=== Sentencia while ===

<code>
sentWhile: 'while' '(' cond ')' sent
         ;	
</code>


=== Sentencia do-while ===

<code>
sentDo: 'do' sent 'while' '(' cond ')'
      ;	
</code>


=== Sentencia for ===
<code>
sentFor: 'for' '(' exp ',' cond ',' exp ')' sent
       ;	
</code>

=== Sentencia return ===
La sentencia return puede devolver un valor numérico, una cadena de caracteres o bien el valor booleano correspondiente a una expresión.

<code>
sentFor: 'return' exp 
       | 'return' cond
       ;	
</code>


=== Sentencia print ===
<code>
sentPrint: 'print' '(' exp ')' 
         ;	
</code>

=== Arrays ===
Pueden definirse arrays unidimensionales son la siguiente sintaxis:

<code>
asig: var '=' '{' listaExp '}'
    ;	
listaExp: listaExp ',' exp
        | exp
        ;
</code>

y acceder a sus elementos mediante:

<code>
var: IDENTIFICADOR '[' exp ']'
   ;
</code>


==== Aspectos semánticos ====

El lenguaje no tiene tipos. Cuando se realiza una operación SSL intenta acomodar la semántica de la operación a un posible tipo que infiere de sus operadores. Así por ejemplo, la operación ''x=2+2'', tendrá como resultado ''x=4'' pero la operación ''x='a'+'b''' tendrá como resultado ''x='ab'''.

Las operaciones entre números se hacen siempre considerando que los operadores son números reales.