[1 point] Dado un conjunto $A$, se define $A^*$ el cierre de Kleene de $A$ como: \( A^* = \cup_{n=1}^{\infty} A^n \) Se admite que $A^0 = { \epsilon }$, donde $\epsilon$ denota la esto es la palabra que tiene longitud cero, formada por cero símbolos del conjunto base $A$.

[1 point] Una producción de la forma $A \rightarrow A \alpha$. se dice que es por la

[1 point] Encuentre una gramática equivalente a esta:

        A: A 'a' | 'b'
      

pero que no sea recursiva por la izquierda:

        A: 
        R: /* vacío */ | 
      

[1 point] Recuerde el analizador sintáctico descendente predictivo recursivo para la gramática:

• $\Sigma = \{ ; =, ID, P, ADDOP, MULOP, COMPARISON, (, ), NUM \}$
• $V = \{ statements, statement, condition, expression, term, factor \}$
• Productions:
  1. statements $ \rightarrow$ statement ';' statements $\vert$ statement
  2. statement $ \rightarrow$ ID '=' expression $\vert$ P expression $ \vert$ IF condition THEN statement·
  3. condition $ \rightarrow$ expression COMPARISON expression
  4. expression $ \rightarrow$ term ADDOP expression $\vert$ term
  5. term $ \rightarrow$ factor MULOP term $\vert$ factor
  6. factor $ \rightarrow$ '(' expression ')' $\vert$ ID $ \vert$ NUM
• Start symbol: $statements$

Rellene las partes que faltan de código CoffeeScript del método que se encarga de reconocer el lenguaje generado por expression:

  expression = ->
    result = term()
    while  and  is "ADDOP"
      type = .
      match "ADDOP"
      right = 
      result =
        type: 
        left: result
        right: right
    result

[3 points] Rellene las partes que faltan de código CoffeeScript del método que se encarga de reconocer el lenguaje generado por statement para la gramática definida anteriormente:

  statement = ->
    result = null
    if  and . is "ID"
      left =
        type: "ID"
        value: .

      match "ID"
      match "="
      right = ()
      result =
        type: "="
        left: left
        right: right
    else if lookahead and lookahead.type is "P"
      match "P"
      right = 
      result =
        type: "P"
        value: right
    else if lookahead and lookahead.type is "IF"
      match "IF"
      left = 
      match "THEN"
      right = 
      result =
        type: "IF"
        left: left
        right: right
    else # Error!
      throw "Syntax Error. Expected identifier but found " + 
        (if lookahead then lookahead.value else "end of input") + 
        " near '#{input.substr(lookahead.from)}'"
    result

[1 point] Rellene las partes que faltan del código CoffeeScript que reconoce el sublenguaje generado por condition:

  condition = ->
    left = 
    type = .
    match "COMPARISON"
    right = ()
    result =
      type: type
      left: left
      right: right
    result
  

[1 point] Complete este fragmento de slim que establece el favicon de la página HTML:

    link rel="" type="image/jpg" href="images/favicon.jpg"

[6 points] Para que un repositorio con una aplicación escrita en Ruby-Sinatra pueda desplegarse en Heroku con nombre chuchu el primer comando que debemos escribir es:

      heroku  
      

Este comando crea un remoto git cuyo nombre es y cuya URL es

        git@heroku.com:.git
      

La URL de publicación/despliegue será: http://..com/
Una vez que todo esta listo, para publicar nuestra versión en la rama master en heroku debemos ejecutar el comando:

      git   master
      

      

Si la versión que queremos publicar en heroku no está en la rama master sino que está en la rama tutu deberemos modificar el comando anterior:

      git push  :
      

Para ver los logs deberemos emitir el comando:

       heroku 
      

[1 point] Con que subcomando del cliente heroku abro el navegador en la URL del proyecto?

    heroku 
    

[1 point] Escriba la parte que falta para que el programa PEGJS reconozca el lenguaje $\{ a^n b^n c^n\ /\ n \ge{} 1\}$

      S =  'a'+ B !('a'/'b'/'c')
      A = 'a' A? 'b'
      B = 'b' B? 'c'
      

[1 point] Rellene las partes que faltan de este código para que funcione:

var PEG = require ("pegjs");
var grammar = "s = ('a' / 'b')+";
var parser = PEG.(grammar);
var input = process.argv[] || 'abba';
console.log(parser.parse(input))

Cuando se ejecuta, este código produce:

[~/srcPLgrado/pegjs/examples(master)]$ node abba.pegjs abb
[ 'a', 'b', 'b' ]

[1 point] Complete las partes que faltan para que el PEGjs reconozca este clásico ejemplo de lenguaje que no es independiente del contexto $\{ a^nb^nc^n / n \ge{} 1 \}$

S = ( ) 'a'+ B: !('c'/[]) { return B; }
A = 'a' A:A? 'b' { if (A) { return A+1; } else return 1; }
B = 'b' B:B? 'c' { if (B) { return B+1; } else return 1; }

[1 point] rellene las partes que faltan del siguiente programa PEGjs que reconoce los comentarios Pascal:

P     =   prog:N+                          { return prog; }
N     =   chars:$(!Begin ANY)+             { return chars;}
        / C
C     = Begin chars: End                { return chars.join(''); }
T     =   C 
        / (!  char:ANY)           { return char;}
Begin = '(*'
End   = '*)'
ANY   =   'z'    /* any character */       { return 'z';  }
        / char:                        { return char; }    

[4 points] Rellene las partes que faltan de esta clase que implementa persistencia para programas PL0 usando el ORM DataMapper:

DataMapper.(:default,·
                 ENV['DATABASE_URL'] || "sqlite3://#{Dir.pwd}/database.db" )

class PL0Program
  include ::
··
   :name, String, :key => true
   :source, String, :length => 1..1024
end

  DataMapper.
  DataMapper.

[1 point] Rellene las partes que faltan del siguiente fragmento de código de la ruta /save que guarda el programa solicitado:

post '/save' do
  name = params[:fname]
  c  = PL0Program.(:name => name)
  if c
    c.source = params["input"]
    c.
  else
    c = PL0Program.new
    c.name = params["fname"]
    c.source = params["input"]
    c.
  end
   '/'
end

[4 points] En la práctica del PEGjs tratabamos las expresiones aritméticas mediante estas dos reglas:

exp    = t:term   r:(ADD term)*   { return tree(t,r); }
term   = f:factor r:(MUL factor)* { return tree(f,r); }
ADD      = _ op:[+-] _ { return op; }
MUL      = _ op:[*/] _ { return op; }

Complete el código de tree:

{
  var tree = function(f, r) {
    if (r. > 0) {
      var last = r.();
      var result = {
        type:  ,
        left: ,
        right: 
      };
    }
    else {
      var result = f;
    }
    return result;
  }
}