Tipos by nuhman10

VIEWS: 68 PAGES: 21

									2.2 Gramática acondicionada
              Decs ::= Dec | Decs ; Dec
              Dec ::= DecTipo | DecVar | DecProc
              DecTipo ::= tipo ident = Tipo
              DecVar ::= identificador : tipo

              Tipo ::= boolean | character | natural | integer | float | ident |
                      array [num] of Tipo | record {Campos} | pointer Tipo
              Campos ::= Campos ; Campo | Campo
              Campo ::= ident : Tipo

              Instr ::= InstrAsignacion | InstrLectura | InstrEscritura | INew | IDispose

              InstrAsignacion ::= Mem := Exp

              INew ::= new Mem
              IDel ::= dispose Mem
              Mem ::= id | Mem-> | Mem[Exp] | Mem.id




Con tu gramática sólo permites declaraciones por grupos, es decir, primero declarar los
tipos, luego las variables y luego los procedimientos, es decir todas las declaraciones de
tipos juntas, una detrás de otra, con la que te pongo yo se pueden intercalar unas con
otras.
Con esta nueva gramática no hay que aplicar ningún tipo de recursión a izquierdas
exceptuando en la declaración de los campos.
La declaración de TIPO para los punteros la he cambiado por esto: Tipo ::= pointer Tipo
He cambiado el orden de Campos ::= Campos ; Campo | Campo para que se vea bien la
recursión a izquierdas.
Yo creo que también deberíamos cambiar la instrucción in de esta forma InstrLectura ::=
in(Mem)



2.2.1 Gramática acondicionada

              Decs ::= Dec RDecs
              RDecs ::= ; Dec RDecs
              RDecs ::= λ
              Dec ::= DecTipo | DecVar | DecProc
              DecTipo ::= tipo ident = Tipo
              DecVar ::= identificador : tipo

              Tipo ::= boolean | character | natural | integer | float | ident |
                      array [num] of Tipo | record {Campos} | pointer Tipo
              Campos ::= Campo RCampos
              RCampos ::= ; Campo RCampos
              RCampos ::= λ

              Instr ::= InstrAsignacion | InstrLectura | InstrEscritura | INew | IDispose

              InstrAsignacion ::= Mem := Exp

              INew ::= new Mem
              IDel ::= dispose Mem
              Mem ::= id | Mem-> | Mem[Exp] | Mem.id
3.2.2 Construcción de la tabla de símbolos


             Programa ::= Decs & Instrs
                   Instrs.tsh = Decs.ts
                   Decs.nh = 0
                   Decs.tsh= TablaDeSimbolos()



             Decs ::= Decs ; Dec
                    Decs1.tsh = Decs.tsh
                    Dec.tsh = Decs1.ts
                    Decs1.nh = Dec.nh Decs0.nh
                    Decs0.ts = insertar(Decs1.ts, Dec.id, Dec.props)

             Decs ::= Dec
                    Dec.tsh = Decs.tsh
                    Dec.nh = Decs.nh
                    Decs.ts = inserta(Decs.tsh || inicializa(), Dec.id,
                                      Dec.props)

             Dec ::= DecTipo
                     Dec.id = DecTipo.id
                     Dec.props = <clase:tipo, tipo:DecTipo.tipo, nivel: Dec.nh >

             Dec ::= DecVar
                     Dec.id = DecVar.id
                     Dec.props = <clase:var, tipo:DecVar.tipo, nivel: Dec.nh >

             Dec ::= DecProc
                     Dec.id = DecProc.id
                     DecProc.tsh = Dec.tsh
                     Dec.props = DecProc.props x {nivel:Dec.nh}

             DecTipo ::= tipo ident = Tipo
                   DecTipo.id = iden.lex
                   DecTipo.tipo = Tipo.tipo

             DecVar ::= identificador : tipo
                   DecVar.id = ident.lex
                   DecVar.tipo = Tipo.tipo

             DecProc ::= proc nombreProc FParams Bloque
                     DecProc.id = nombreProc.lex
                     DecProc.props = <clase: proc, tipo: <t:proc,params:FParams.params>>
                     FParams.tsh = TablaDeSimbolos(DecProc.tsh)
                     Bloque.tsh= insertar (FParamas.ts, DecProc.id, DecProc.props x
             {nivel:DecProc.nh+1}
                     FParams.nh = Bloque.nh = DecProc.nh +1


             Bloque ::= Decs & Instr
                     Decs.tsh = Bloque.tsh
                     Decs.nh = Bloque.nh
                     Instr.tsh = Decs.ts
             Bloque.ts = Decs.ts
Bloque ::= Instr
       Instsr.tsh= Bloque.tsh

FParams ::= ( LFParams )
      FParams.params = LFParams.params
      LFParams.tsh = FParams.tsh
      FParam.ts = LFParams.ts
      LFParams.nh = FParams.nh


FParams ::= Lambda
      FParams.params = {}
      FParamas.ts = FParams.tsh

LFParams::= LFParams, FParam
      LFParams0.params = LFParams1.params ++ FParam.params
      LFParams0.ts = inserter(LFParams1.ts, FParam.id, FParam.props)
      LFParams1.tsh = LFParams0.tsh
      LFParams1.nh = FParam.nh = LFParams0.nh

LFParams::= FParam
      LFParam.params = {FParam.params}
      FParam.nh = LFParams.nh
      LFParams.ts= inserter(LFParams.tsh, FParam.id, FParam.props)

FParam ::= var nombreVar : Tipo
      FParam.id = nombreVar.lex
      FParam.props = <clase:pvar, tipo: Tipo.tipo, nivel: FParam.nh>
      FParam.params = <modo: variable, tipo: Tipo.tipo>

FParam ::= nombreVar : Tipo
      FParam.id = nombreVar.lex
      FParam.props = <clase.var, tipo : Tipo.tipo, nivel: FParam.nh>
      FParam.params = <modo : valor, tipo: Tipo.tipo>




Tipo ::= natural
        Tipo.tipo = <t: NATURAL, tam:1>
Tipo ::= integer
        Tipo.tipo = <t: INTEGER, tam:1>
Tipo ::= caracter
        Tipo.tipo = <t: CARÁCTER, tam:1>
Tipo ::= float
        Tipo.tipo = <t:FLOAT, tam:1>
Tipo ::= boolean
        Tipo.tipo = <t:BOOLEAN, tam:1>
Tipo ::= iden
        Tipo.tipo = <t:ref, id:iden.lex, tam: obtenerSimbolo(ident.lex).tam>
Tipo ::= array [num] of Tipo
        Tipoo.tipo = <t:array, nelems:valorDe(num.lex), tbase:Tipo1.tipo, tam:
num*Tipo1 .tipo>
Tipo ::= pointer Tipo
        Tipoo.tipo = <t:puntero, tbase:Tipo1.tipo, tam: Tipo1.tam>
Tipo ::= record {Campos}
        Tipo.tipo = <t:rec, campos:Campos.campos, tam:Campos.tam>
        Campos.tsh= Tipo.tsh

Campos ::= Campos ; Campo
     Camposo.campos = añadirEnLista(Campos1.campos, Campo.campo)
     Campos0.tam= Campos1.tam + Campo.tam
     Campos1.tsh= Campos0.tsh
     Campo.tsh= Campos0.tsh
     Campo.desph= Campos1.tam


Campos ::= Campo
     Campos.campos = creaLista(Campo.campo)
     Campos.tam= Campo.tam
     Campo.desph= 0


Campo ::= iden : Tipo
      Campo.campo = <id:iden.lex, tipo:Tipo.tipo, desp:Campo.desph>
      Tipo.tsh= Campo.tsh
      Campo.tam= Tipo.tam


Instrs ::= Instrs ; Instr
  Instrs1.tsh = Instr.tsh = Instrs.tsh

Instrs ::= Instr
  Instr.tsh = Instrs.tsh

Instr ::= InstrAsignacion
  InstrAsginacion.tsh = Instr.tsh

Instr ::= InstrLectura
  InstrLectura.tsh = Instr.tsh

Instr ::= InstrEscritura
  InstrEscritura.tsh = Instr.tsh

Instr ::= InstrLLamada
         InstrLLamada.tsh = Instr.tsh



Instr ::= InstrNew
  InstrNew.tsh = Instr.tsh

Instr ::= InstrIDispose
  InstrIDispose.tsh = Instr.tsh

InstrAsignacion ::= Mem := Exp
  Mem.tsh = InstrAsignacion.tsh
  Exp.tsh = InstrAsignacion.tsh

InstrLectura ::= in(Mem)
  Mem.tsh = InstrLectura.tsh

InstrEscritura ::= out(Exp)
  Exp.tsh = InstrEscritura.tsh
INew ::= new Mem
  Mem.tsh = INew.tsh

IDel ::= dispose Mem
  Mem.tsh = IDel.tsh

InstrLlamada ::= nombreProc AParams
        AParams.tsh = InstrLLamada.tsh
        AParams.fparamsh= InstrLlamada.tsh[nombreProc.lex].tipo.params

Aparams ::= ( LAParams )
      LAParams.tsh = AParams.tsh
      LAParams.fparamsh = Aparams.fparamsh


Aparams ::= Lambda


LAParams ::= LAParams, Exp
      LAParams0.nparams = LAParams1.nparams +1
      LAParams1.tsh = Exp.tsh = LAParams0.tsh


LAParams ::= Exp
      Exp.tsh = LAParams.tsh
      LAParams.nparams = 1


Exp0 ::= Exp1 Op0 Exp1
  Exp10.tsh = Exp11.tsh = Exp0.tsh
       Exp0.modo = val

Exp0 ::= Exp1
  Exp1.tsh = Exp0.tsh
       Exp0.modo = Exp1.modo

Op0 ::= < | > | <= | >= | = | =/=

Exp1 ::= Exp1 Op1 Exp2
  Exp11.tsh = Exp2.tsh = Exp10.tsh
       Exp11.modo = val

Exp1 ::= Exp2
  Exp2.tsh = Exp1.tsh
       Exp1.modo = Exp2.modo

Op1 ::= + | - | or

Exp2 ::= Exp2 Op2 Exp3
  Exp21.tsh = Exp3.tsh = Exp20.tsh
       Exp21.modo = val

Exp2 ::= Exp3
  Exp3.tsh = Exp2.tsh
       Exp2.modo = Exp3.modo

Op2 ::= * | / | % | and

Exp3 ::= Exp4 Op3 Exp3
  Exp4.tsh = Exp31.tsh = Exp30.tsh
Exp30.modo = val

Exp3 ::= Exp4
  Exp4.tsh = Exp3.tsh
       Exp3.modo = Exp4.modo

Op3 ::= << | >>

Exp4 ::= Op4 Exp4
  Exp40.tsh = Exp41.tsh
Exp40.modo= val //seria un tema permitir parametros con menos y cosas asi,
pero creo que es una compliacacion excesiva, y no tendria una gran
recompensa

Exp4 ::= |Exp4|
  Exp40.tsh = Exp41.tsh
       Exp40.modo = val


Op4 ::= not | - | (float) | (int) | (nat) | (char)

Exp4 ::= natural | entero | real | caracter | true | false | identificador |
Exp4.modo = val

Exp4 ::= (Exp0)
Exp4.modo = Exp0.modo

Exp4 :: Mem
  Exp4.tsh = Mem.tsh
        Exp4.modo = var

Mem ::= id

Mem ::= Mem->
 Mem1.tsh = Mem0.tsh

Mem ::= Mem[Exp]
 Mem1.tsh = Exp.tsh = Mem0.tsh

Mem ::= Mem.id
       Mem1.tsh = Mem0.tsh
4.4 Gramática de atributos
       Programa ::= Decs & Instrs
         Programa.err = Decs.err OR Instrs.err OR Decs.pend <> vacio


       Decs ::= Decs ; Dec
              Decs0.err = Decs1.err  Dec.err
              Decs0.pend = Decs1.pend  Dec.pend –
              (si Dec.props.clase = tipo entonces {Dec.id} si no )

       Decs ::= Dec
              Decs.err = Dec.err
              Decs.pend = Dec.pend –(si Dec.props.clase = tipo entonces {Dec.id}
              si no )

       Dec ::= DecTipo
               Dec.err = DecTipo.err
               Dec.pend = DecTipo.pend

       Dec ::= DecVar
               Dec.err = DecVar.err
               Dec.pend = DecVar.pend

       DecTipo ::= tipo iden = Tipo
             DecTipo.err = Tipo.err existeID(DecTipo.tsh,iden.lex) 
                              referenciaErronea(Tipo.tipo,DecTipo.ts h)
             DecTipo.pend = Tipo.pend

       DecVar ::= iden: Tipo
             DecVar.err = Tipo.err existe (DecVar.tsh,iden.lex)
                              referenciaErronea(Tipo.tipo,DecVar.tsh)
             DecVar.pend = Tipo.pend

       DecProc ::= proc nombreProc FParams Bloque
                DecProc.err = FParams.err or Bloque.err or (existe(DecProc.tsh,
       nombreProc.lex) and FParams.ts[nombreProc.lex.nivel = DecProc.nh +1 // Esto
       ulitmo lo que hace es comprobar que no está en el nivel actual, ya que puede
       estar en los niveles de los padres


       Bloque ::= Decs & Instr
              Bloque.err = Decs.err or Instr.err


       Bloque ::= Instr
              Bloque.err = Instr.err

       FParams ::= ( LFParams )
             FParams.err= LFParams.err


       FParams ::= Lambda
             FParams.err= false

       LFParams::= LFParams, FParam
             LFParams0.err= LFParams1.err or FParam.err or (existe(LFParams1.ts,
       FParam.id) and LFParams1.ts[FParam.id].nivel = LFParams0.nh)

       LFParams::= FParam
        LFParam.err = FParam.err

FParam ::= var nombreVar : Tipo
      FParam.err= Tipo.err

FParam ::= nombreVar : Tipo
      FParam.err= Tipo.err


Tipo ::= natural
        Tipo.err = false
        Tipo.pend = 

Tipo ::= integer
        Tipo.err = false
        Tipo.pend = 

Tipo ::= caracter
        Tipo.err = false
        Tipo.pend = 

Tipo ::= float
        Tipo.err = false
        Tipo.pend = 

Tipo ::= boolean
        Tipo.err = false
        Tipo.pend = 

Tipo ::= iden
        Tipo.err = Si existeID(Tipo.tsh,iden.lex) entonces
                               Tipo.tsh [iden.lex].clase tipo
                   Si no false
        Tipo.pend = Si existe(Tipo.tsh,iden.lex) {iden.lex}
                     Si no 

Tipo ::= array [num] of Tipo
        Tipo0.err = Tipo1.err referenciaErronea(Tipo1.tipo,Tipo0.tsh)
        Tipo0.pend = Tipo1.pend

Tipo ::= pointer Tipo
        Tipo0.err = Tipo1.err
        Tipo0.pend = Tipo1.pend

Tipo ::= record {Campos}
        Tipo.err = Campos.err
        Tipo.pend = Campos.pend

Campos ::= Campos ; Campo
     Campos0.err = Campos1.err
     contieneCampo?(Campos.campos,Campo.id)
                    Campo.err
     Campos0.pend = Campos1.pend Campo.pend

Campos ::= Campo
     Campos.err = Campo.err
     Campos.pend = Campo.pend

Campo ::= iden : Tipo
      Campo.err = Tipo.err referenciaErronea(Tipo.tipo,Campo.tsh)
        Campo.pend = Tipo.pend


Instrs ::= Instrs ; Instr
  Instrs0.err = Instrs1.err OR Instr.err

Instrs ::= Instr
  Instrs.err = Instr.err

Instr ::= InstrAsignacion
  Instr.err = InstrAsignacion.err

Instr ::= InstrLectura
  Instr.err = InstrLectura.err

Instr ::= InstrEscritura
  Instr.err = InstrEscritura.err

Instr ::= InstrNew
  Instr.err = InstrNew.err

Instr ::= InstrIDispose
  Instr.err = InstrDispose.err

Instr ::= InstrLlamada
         Inst.err = InstrLlamada.err

InstrAsignacion ::= Mem := Exp
  InstrAsignacion.err = compatibles(Mem.tipo, Exp.tipo, InstrAsignacion.tsh)

InstrLectura ::= in(Mem)
  InstrLectura.err = no existe(InstrLectura.tsh, Mem.id)

InstrEscritura ::= out(Exp)
  InstrEscritura.err = Exp.err

INew ::= new Mem
  INew.err = Mem.tipo.t <> puntero

IDel ::= dispose Mem
  IDel.err = Mem.tipo.t <> puntero

InstrLlamada ::= nombreProc AParams
        Instr.err = ¬existe(InstrLlamada.tsh, nombreProc.lex) or
InstrLlamada.tsh[nombreProc.lex].clase <> proc or AParams.err

Aparams ::= ( LAParams )
      AParams.err = LAParams.err or |AParams.fparamsh| <>
LAParams.nparams //comprueba que el numero de parámetros es correcto


Aparams ::= Lambda
      AParams.err= |AParams.fparamsh|>0


LAParams ::= LAParams, Exp
       LAParams0.err= LAParams1.err or Exp.err or LAParams0.nparams >
|LAParams0.fparamsh| or (LAParams0.fparamsh[LAParams0.nparams].modo =
var and Exp.modo = val) or
¬compatibles(LAParams0.fparamsh[LAParams.nparams].tipo, Exp.tipo,
           LAParams0.tsh) //Hay que comprobar como function esta funcion y si cumple el
           Nuevo cometido, y también hay que subir el modo de las expresiones de
           alguna manera, aunque parece trivial que solo son var, si se tratan de tipos
           mem

           LAParams ::= Exp
                  LAParams.err= Exp.err or |LAParams.fparamsh| <> 1 or
           (LAParams0.fparamsh[LAParams0.nparams].modo = var and Exp.modo = val)
           or ¬compatibles(LAParams0.fparamsh[LAParams.nparams].tipo, Exp.tipo,
           LAParams0.tsh)

HABRÍA QUE CONTINUAR A PARTIR DE AQUÍ SIMPLEMENTE HE COPIADO LO DE LA
ANTERIOR ENTREGA ASI QUE HABRÍA QUE EDITARLO

           Exp0 ::= Exp1 Op0 Exp1
             Exp0.err = Exp10.err
                         OR
                         Exp11.err
                         OR
                         (Si no SonComparables(Op0.op, Exp10.tipo, Exp11.tipo)
                         AND
                         Si no SonBooleanos(Op0,op, Exp11.tipo, Exp10.tipo))

           Exp0 ::= Exp 1
             Exp0.err = Exp1.err

           Op0 ::= < | > | <= | >= | = | =/=

           Exp1 ::= Exp1 Op1 Exp2
             Exp10.err = Exp11.err
                          OR
                          Exp2.err
                          OR
                          (¬SonAritmeticos(Op1.op, Exp11.tipo, Exp2.tipo)
                           AND
                          ¬SonBooleanos(Op1.op, Exp11.tipo, Exp2.tipo))

           Exp1 ::= Exp2
             Exp1.err = Exp2.err

           Op1 ::= + | - | or

           Exp2 ::= Exp2 Op2 Exp3
             Exp20.err = Exp21.err
                         OR
                         Exp3.err
                         OR
                         (¬SonMultiplicativos(Op2.op, Exp21.tipo, Exp3.tipo)
                         AND
                         ¬SonDivisibles(Op2.op, Exp21.tipo, Exp3.tipo)
                         AND
                         ¬SonModulo(Op2.op, Exp21.tipo, Exp3.tipo)
                         AND
                         ¬SonBooleanos(Op2.op, Exp21.tipo, Exp3.tipo))

           Exp2 ::= Exp3
                  Exp2.err = Exp3.err

           Op2 ::= * | / | % | and
Exp3 ::= Exp4 Op3 Exp3
       Exp30.err = ¬SonDesplazables(Op3.op, Exp4.tipo, Exp31.tipo)

Exp3 ::= Exp4
       Exp3.err = Exp4.err

Op3 ::= << | >>

Exp4 ::= Op4 Exp4
       Exp40.err =         ¬EsNegacion(Op4.op, Exp41.tipo)
                           AND
                           ¬EsUnario(Op4.op, Exp41.tipo)
                           AND
                           ¬ EsConversion(Op4.op, Exp41.tipo)
                           AND
                           ¬EsValorAbsoluto(Exp4.tipo)

Exp4 ::= |Exp4|
       Exp40.err = no EsValorAbsoluto(Exp41.tipo)

Op4 ::= not | - | (float) | (int) | (nat) | (char)

Exp4 ::= natural | entero | real | carácter | true | false | Identificador
       Exp4.err = false

Exp4::=(Exp0)
       Exp4.err = Exp0.err

Exp4 ::= natural | entero | real | caracter | true | false | identificador | (Exp0)

Exp4 :: Mem
  Exp4.tipo = Mem.tipo

Mem ::= id
 Mem.tipo = Si existeID(Tipo.tsh, iden.lex)
               Si Mem.tsh[iden.lex].clase = var
                  ref! (Mem.tsh[iden.lex].tipo, Mem 0.tsh)
               Si no <t:err>
            Si no <t:err>


Mem ::= Mem->
 Mem0.tipo = Si Mem1.tipo.t = puntero
                ref! (Mem1.tipo.tbase, Mem0.tsh)
             Si no <t:err>

Mem ::= Mem[Exp]
 Mem0.tipo = Si Mem1.tipo.t = array AND Exp.tipo.t = num
                ref! (Mem1.tipo.tbase, Mem0.tsh)
             Si no <t:err>


Mem ::= Mem.id
 Mem0.tipo = Si Mem1.tipo.t = registro
                Si campo? (Mem1.tipo.campos, iden.lex)
                   ref! (Mem1.tipo.campos[iden.lex], Mem0.tsh)
                Si no <t:err>
             Si no <t:err>
               *

   5.3 Gramática de atributos
Nuevas instrucciones de la máquina P:

apila-ind
       Pila[ST]  Mem[Pila[ST]]
       PC  PC + 1
desapila-ind
       Mem[Pila[ST-1]]  Pila[ST]
       ST  ST + 2
       PC  PC + 1

mueve(s)
       para i  0 hasta s-1 hacer
              Mem[Pila[ST-1]+i]  Mem[Pila[ST]+i]
       ST  ST - 2
       PC  PC + 1



               InstrAsignacion ::= Mem := Exp
                 InstrAsignacion.cod = Si compatible(Mem.tipo, listaTiposBasicos, Exp.tsh)
                                        entonces
                                           Mem.cod || Exp.cod || desapila-ind
                                        Si no
                                           Mem.cod || Exp.cod || mueve(Mem.tipo.tam)
                 Mem.etqh = InstrAsignacion.etqh
                 Exp.etqh = Mem.etq
                 InstrAsignacion.etq = Exp.etq + 1


               INew ::= new Mem
                 INew.cod = Mem.cod ||
                            new if Mem.tipo.tbase = ref entonces
                                    INew.tsh[Mem.tipo.tbase,id].tam
                                Else Mem.tipo.tbase.tam ||
                            desapila-ind
                 Mem.etqh = INew.etqh
                 INew.etq = Mem.etq + 2


               IDel ::= dispose Mem
                 IDel.cod = Mem.cod ||
                            del if Mem.tipo.tbase = ref entonces
                                      IDel.tsh[Mem.tipo.tbase,id].tam
                                   Else Mem.tipo.tbase.tam ||
                             desapila-ind
                 Mem.etqh = IDel.etqh
                 IDel.etq = Mem.etq + 1
Exp4 :: Mem
  Exp4.cod = Si compatible(Mem.tipo, listaTiposBasicos, Exp4.tsh) entonces
                 Mem.cod || apila-ind
             Si no
                Mem.cod
  Mem.etqg = Exp4.etqh
  Exp4.etq = Si compatible(Mem.tipo, listaTiposBasicos, Exp4.tsh) entonces
                 Mem.etq + 1
             Si no
                Mem.etq


Mem ::= id
       Mem.cod = apila(Mem.tsh[id.lex].dir)
       Mem.etq = Mem.etqh + 1}


Mem ::= Mem->
 Mem0.cod = Mem1.cod || apila-ind
 Mem1.etqh = Mem0.etqh
 Mem0.etq = Mem1.etq + 1


Mem ::= Mem[Exp]
 Mem0.cod = Mem1.cod || Exp..cod || apila(Mem 1.tipo.tbase.tam) || multiplica ||
             Suma
 Mem1.etqh = Mem0.etqh
 Exp.etqh = Mem1.etqh
 Mem0.etq = Exp.etq + 3


Mem ::= Mem.id
 Mem0.cod = Mem1.cod || apila(Mem1.tipo.campos[ident.lex].desp) || suma
 Mem1.etqh = Mem0.etqh
 Mem0.etq = Mem1.etq + 2
7.1 Acondicionamiento de la Gramática para la Construcción de la tabla de símbolos

           Tipo ::= record {Campos}
                   Tipo.tipo = <t:rec, campos:Campos.campos>

           Campos::= Campo RCampos
                RCampos.camposh= lista(Campo.campos)
                RCampos.tsph= Campos.tsph
                RCampos.tamh= Campo.tam
                Campo.desph= 0
                RCampos.desph= Campo.tam
                Campos.campos= RCampos.campos
                Campos.tam= RCampos.tam


           RCampos::= ; Campo RCampos
                        RCampos1.camposh= añadirEnLista(RCampos0.camposh,
           Campo.campos)
                        Campo.tsph= RCampos0.tsph
                        RCampos1.tsph= Campos.tsph
                        RCampos1.tamh= Campo.tam
                        RCampos1.desph= Campo.tam
                        RCampos0.campos= RCampos1.campos
                        RCampos0.tam= RCampos1.tam


           Campo ::= iden : Tipo
                 Campo.campo = <id:iden.lex, tipo:Tipo.tipo, desp:Campo.desph>
                 Tipo.tsh= Campo.tsh
                 Campo.tam= Tipo.tam
7.1 Acondicionamiento de la Gramática para las Restricciones Contextuales

           Tipo ::= record {Campos}
                   Tipo.tipo = <t:rec, campos:Campos.campos>

           Campos::= Campo RCampos
                RCampos.errorh= Campo.error
                Campos.error= RCampos.error


           RCampos::= ; Campo RCampos
           RCampos1.errorh= contieneCampo?(RCampos0.campos, Campo.id)
                OR Campo.error
           RCampos0.error= RCampos1.error


           Campo ::= iden : Tipo
Generación Tabla de símbolos
Restricciones contextuales
Generación de código


            Programa ::= Decls &
                  { Instrs.tsh = Decs.ts}
                   & Instrs
                  {Programa.err = Decs.err OR Instrs.err OR Decs.pend <> vacio;
                    Programa.cod = Instrs.cod || stop}

            Decs ::= Dec
                   { RDecs.tsh = insertar(TablaDeSimbolos() || inicializa(),Dec.id,<dir:0,
                   tipo:Dec.tipo, catLexica:Dec.cl>;
                   RDecs.errh = Dec.err}
                    RDecs
                   { Decs0.ts = RDecs.ts;
                   Decs.err = RDecs.err}

            RDecs ::= ; Dec
                  { RDecs1.tsh=insertar(RDecs0.tsh, Dec.id, <dir:RDecs0.dir+1,
                  tipo:Dec.tipo,catLexica:Dec.cl);
                  RDecs1.errh = RDecs0.errh OR existe(RDecs0.tsh, Dec.id)}
                   RDecs
                  {RDecs0.ts = RDecs1.ts;
                  RDecs0.err = RDecs1.err}


            RDecs ::= λ
                  {RDecs.ts = RDecs.tsh;
                  RDecs.err = RDecs.errh}


            Dec ::= DecTipo
                    {Dec.id = DecTipo.id
                    Dec.props = <clase:tipo, tipo:DecTipo.tipo>
                    Dec.err = DecTipo.err
                    Dec.pend = DecTipo.pend}


            Dec ::= DecVar
                    {DecVar.id = ident.lex
                    DecVar.tipo = Tipo.tipo
                    Dec.err = DecVar.err
                    Dec.pend = DecVar.pend}

            DecTipo ::= tipo ident = Tipo
                  {DecTipo.id = iden.lex
                  DecTipo.tipo = Tipo.tipo
                  DecTipo.err = Tipo.err existeID(DecTipo.tsh,iden.lex) 
                                   referenciaErronea(Tipo.tipo,DecTipo.ts h)
                  DecTipo.pend = Tipo.pend}
DecVar ::= ident : Tipo
      {DecVar.id = ident.lex
      DecVar.tipo = Tipo.tipo
      DecVar.err = Tipo.err existe (DecVar.tsh,iden.lex)
                        referenciaErronea(Tipo.tipo,DecVar.ts h)
      DecVar.pend = Tipo.pend}


Tipo ::= boolean
        {Tipo.tipo = BOOLEAN,
        Tipo.tam = 1}

Tipo ::= caracter
        {Tipo.tipo = CARÁCTER,
        Tipo.tam = 1}

Tipo ::= natural
        {TIPO.tipo = NATURAL,
        Tipo.tam=1}

Tipo ::= integer
        {TIPO.tipo = INTEGER,
        Tipo.tam = 1}

Tipo ::=float
        {TIPO.tipo = FLOAT,
        Tipo.tam = 1}

Tipo ::=iden
        { Tipo.tipo = <t:ref, id:iden.lex, tam: obtenerSimbolo(ident.lex).tam>
         Tipo.err = Si existeID(Tipo.tsh,iden.lex) entonces
                                  Tipo.tsh [iden.lex].clase tipo
                    Si no false
        Tipo.pend = Si existe(Tipo.tsh,iden.lex) {iden.lex}
                      Si no 
        }

Tipo ::= array [num] of Tipo
        { Tipoo.tipo = <t:array, nelems:valorDe(num.lex), tbase:Tipo1.tipo, tam:
num*Tipo1 .tipo>
        Tipo0.err = Tipo1.err referenciaErronea(Tipo1.tipo,Tipo0.tsh)
        Tipo0.pend = Tipo1.pend}

Tipo ::=
        pointer Tipo
        { Tipoo.tipo = <t:puntero, tbase:Tipo1.tipo, tam: Tipo1.tam>
        Tipo0.err = Tipo1.err
        Tipo0.pend = Tipo1.pend}

Tipo ::= record {Campos}
        Campos.tsh= Tipo.tsh
        { Tipo.tipo = <t:rec, campos:Campos.campos, tam:Campos.tam>
        Tipo.err = Campos.err
        Tipo.pend = Campos.pend}


Campos::=
     Campo.desph= 0
     Campo
     {RCampos.errorh= Campo.error
        RCampos.camposh= lista(Campo.campos)
        RCampos.tsph= Campos.tsph
        RCampos.tamh= Campo.tam
        RCampos.desph= Campo.tam}
        RCampos
        {Campos.error= RCampos.error
        Campos.campos= RCampos.campos
        Campos.tam= RCampos.tam}



RCampos::= ;
     Campo.tsph= RCampos0.tsph
     Campo
     { RCampos1.errorh= contieneCampo?(RCampos0.campos, Campo.id)
     OR Campo.error
     RCampos1.camposh= añadirEnLista(RCampos0.camposh,
     Campo.campos)
     RCampos1.tsph= Campos.tsph
     RCampos1.tamh= Campo.tam
     RCampos1.desph= Campo.tam}
     RCampos
     {RCampos0.error= RCampos1.error
     RCampos0.campos= RCampos1.campos
     RCampos0.tam= RCampos1.tam}

Campo ::= iden :

        { Tipo.tsh= Campo.tsh}
        Tipo
        {Campo.campo = <id:iden.lex, tipo:Tipo.tipo, desp:Campo.desph>
        Campo.tam= Tipo.tam}


Instr ::=
         { InstrNew.tsh = Instr.tsh }
         InstrNew
         { Instr.err = InstrNew.err }


Instr ::=
         { InstrIDispose.tsh = Instr.tsh }
         InstrIDispose
         { Instr.err = InstrDispose.err}




INew ::=
       {Mem.tsh = INew.tsh
       Mem.etqh = INew.etqh }
       new Mem
       {INew.cod = Mem.cod ||
               new if Mem.tipo.tbase = ref entonces
                       INew.tsh[Mem.tipo.tbase,id].tam
                   Else Mem.tipo.tbase.tam ||
               desapila-ind
        INew.etq = Mem.etq + 2}
IDel ::=
           {Mem.tsh = IDel.tsh
           Mem.etqh = IDel.etqh}
           dispose Mem
           {IDel.cod = Mem.cod ||
                del if Mem.tipo.tbase = ref entonces
                         IDel.tsh[Mem.tipo.tbase,id].tam
                   Else Mem.tipo.tbase.tam || desapila-ind
           IDel.etq = Mem.etq + 1}


Exp4 ::
           { Exp4.tsh = Mem.tsh
           Mem.etqh = Exp4.etqh }
           Mem
           {Exp4.cod = Si compatible(Mem.tipo, listaTiposBasicos, Exp4.tsh)
                        entonces
                            Mem.cod || apila-ind
                         Si no
                            Mem.cod
           Exp4.etq = Si compatible(Mem.tipo, listaTiposBasicos, Exp4.tsh)
                       entonces
                            Mem.etq + 1
                         Si no
                            Mem.etq}
           Exp4.tipo = Mem.tipo}


  Mem ::= id
      {Mem.tipo = Si existeID(Tipo.tsh, iden.lex)
               Si Mem.tsh[iden.lex].clase = var
                  ref! (Mem.tsh[iden.lex].tipo, Mem 0.tsh)
               Si no <t:err>
             Si no <t:err>
      Mem.cod = apila(Mem.tsh[id.lex].dir)
       Mem.etq = Mem.etqh + 1}


Mem ::=
       {Mem1.etqh = Mem0.etqh
       Mem1.tsh = Mem0.tsh}
       Mem->
       { Mem0.tipo = Si Mem1.tipo.t = puntero
                       ref! (Mem1.tipo.tbase, Mem0.tsh)
                       Si no <t:err>
       Mem0.cod = Mem1.cod || apila-ind
       Mem0.etq = Mem1.etq + 1}


Mem ::=
       {Mem1.tsh = Exp.tsh = Mem 0.tsh
       Mem1.etqh = Mem0.etqh
       Exp.etqh = Mem1.etqh}
       Mem[Exp]
       { Mem0.cod = Mem1.cod || Exp..cod || apila(Mem 1.tipo.tbase.tam) ||
       multiplica || Suma
       Mem0.etq = Exp.etq + 3
       Mem0.tipo = Si Mem1.tipo.t = array AND Exp.tipo.t = num
                                      ref! (Mem1.tipo.tbase, Mem0.tsh)
                                   Si no <t:err>}


               Mem ::=
                      {Mem1.tsh = Mem0.tsh
                      Mem1.etqh = Mem0.etqh}
                      Mem.id
                      {Mem0.cod = Mem1.cod || apila(Mem1.tipo.campos[ident.lex].desp) ||
                                   suma
                      Mem0.etq = Mem1.etq + 2
                      Mem0.tipo = Si Mem1.tipo.t = registro
                               Si campo? (Mem1.tipo.campos, iden.lex)
                                  ref! (Mem1.tipo.campos[iden.lex], Mem0.tsh)
                               Si no <t:err>
                            Si no <t:err>




3. Estructura y construcción de la tabla de símbolos

Las entradas de la tabla de símbolos tienen los siguientes campos para almacenar:
     Lexema: significado de cada token
      Dirección de memoria: Este valor se usa sólo para las variables. Los demás tokens
       tendrán el valor -1
      Tipo: En este campo se indica el tipo de las variables. Esta propiedad sólo es válida
       cuando la Categoría léxica es VARIABLE.
      Tam: En este campo se indica el tamaño del tipo.
      Categoría léxica: La categoría léxica sirve para indicar la clase del token. Así un token
       que sea un identificador tendrá asociado un tipo por ser variable y una categoría léxica
       que indique que es una variable. La categoría léxica nos sirve también para hacer
       distinciones entre los tokens.
            o PALABRARESERVADA
            o VARIABLE
            o OPERADOR
            o EXPONENCIAL
            o DECIMAL
            o NATURAL
            o ARRAY
            o PUNTERO
           o REGISTRO
      CAMPOS: Lista de objetos de tipo CAMPO con los campos de los registros. Esta
       propiedad sólo es válida cuando la Categoría léxica es REGISTRO.
      numElementos: Número de elementos que componen el array. Esta propiedad sólo es
       válidad cuando la Categoría léxica es ARRAY.
      tipoBase: Tipo de los objetos del array. Esta propiedad sólo es válida cuando la
       Categoría léxica es ARRAY o PUNTERO



Nuevo objeto CAMPO
Este nuevo objeto representa un campo para los registros. Los atributos que va a
contener cada campo son:
      Id: identificador del campo.
      Tipo: tipo del campo
      Desplazamiento: Desplazamiento para el campo.

								
To top