RESU M EN DEM A KLEN GU AJ ESY COM P I LA DORES( Segundo Cuatrimestre)

Autor :Ar ielNa der ar ielnader @gmail.com

Ta bladeSmbolos
La tabla de smbolos es una estructura que es utilizada tanto en los lenguajes dinmicos (en tiempo de ejecucin)
comoenlostipoAlgol(soloentiempodecompilacin,sirvedeapoyoparaelprocesoperounavezquecomienzala
ejecucinlatabladesaparece).
CompilacinMonoltica:Se le llama asicuandola compilacin del programatiene todos los datos suficientespara
llevarse a cabo por completo. Por ejemplo, un programa que dispone de todos los mdulosque se utilizarn en la
ejecucin.Enestecasolatabladesmbolosseusaencompilacinyluegosedescarta.

CompilacionesSeparadas:Sedacuandoloslenguajespermitengenerararchivosdecdigoseparados.
Fuente1

Binario1
Compilador

Fuente2

Linker

Ejecutable

Binario2

Paraestaformadecompilarnosepuededescartarporcompletolatabladesmbolosluegodelacompilacinyaque
una referencia desde uno de los fuentes puede estar apuntando a otro. Por ejemplo, si tengo un procedimiento
CalcularPrecioenelfuente2yesllamadodesdeelfuente1,almomentodecompilaresteltimodebosaberdonde
se encuentra el procedimiento. La informacin sobre el procedimiento se guarda en el mismo binario, es decir, el
binario2mantienelareferenciaCalcularPreciodelprocedimientoyacompiladoparaqueunavezqueseejecuteel
Linkerestepuedaresolverestasreferenciaspendientes.
Loselementosqueinteresanmantenercomoreferenciasnoresueltasparaunbinariodeterminadoson:
Lasestructurasquetieneelbinarioyqueseusanexternamente.
Lasestructurasexternasquesonusadasporestebinario.
De esta forma se dice que la tabla de smbolos sobrevive parcialmente en las compilaciones de este tipo (queda
embebidaenlosbinariosgeneradosenlacompilacinperounavezejecutadoelLinkernoquedanadadeella).

VinculacinDinmica:EselcasodeprogramasconusodeDLL(enWindows)oELF(enLinux).

Fuente1

Binario1
Compilador

Fuente2

Linker1

Ejecutable

Binario2
Biblioteca(dll/elf)

Linker2

EjecutableFinal

Enestemodeloexistendoslinkeos,elprimeroenelmomentodegenerarelejecutable.Luegodeesteprocesoenel
ejecutable quedan referencias no resueltas a procedimientos de las bibliotecas del Sistema Operativo. Luego al
momentodeejecutarelprogramaelSistemaOperativorealizaunsegundolinkeodonderesuelvedichasreferenciasy

deestaformaseejecutaelprograma.Deestaformaexistepartedelatabladesmbolosenelejecutableendiscoque
hacenreferenciasaestructurasdelabibliotecayquesonresueltaspor ellinkerdelSistemaOperativo.

BibliotecasCompartidas:Enestemodeloocurrealgoparecidoqueenelanteriorsoloqueellinker2noresuelvelas
referenciassinohastaqueelprocedimientoesllamadoporelprograma.Elflujodeejecucindeunprogramapuede
llevaranoresolvernuncaunareferenciaparaunprocedimientodeterminado.

Vamos a hablar de algunos conceptos generales sobre los Compiladores. Lo primero que hay que decir es que un
compiladornonecesariamentetienecomosalidaelcdigoejecutable.Porejemplo,elcompiladordeADAgeneraun
fuenteenCqueluegoescompiladoporotroaplicativo.
Cross Compilers: Son compiladores que corren en una mquina y la salida esta preparada para otra mquina. Por
ejemplouncompiladordeCenSunparaunamquinaIBM.
Autocompiladores: Es un compilador de un lenguaje escrito en su mismo lenguaje. Por ejemplo un compilador de
PascalescritoenPascal.
Metacompiladores: Son compiladores que tenian como objetivo crear compiladores. Es una especie de solucin
automatizadaparagenerarcompiladoresautomticos.Almetacompiladordebaproporcionarsele:
Sintaxisdelnuevolenguaje.
Semnticadelnuevolenguaje.
InformacindelSistemaOpertivo(ej:comollamaralosservicios)
Este experimento no se logr hacer con xito pero si se pudo generar Analizadores Lexicos y Sintcticos
automticamente.ElproductomasconocidoquerealizaestatareaesYACC.
Mquinas Objeto: En una poca que faltaba recurso humano que trabaje creando compiladores definieron una
mquina imaginaria y luego crearon un compilador de un cdigo que corra en esa mquina inexistente. Luego
crearon interpretes de esa mquina que ejecutaban sobre mquinas reales. Esta idea finalmente muri pero tiempo
despusresurgiconlaaparicindeJava.
Diagramas T: Para explicar en que consiste un diagrama T primero vamos a hablar de ciertos conceptos. En la
construccindeuncompiladorhaytreslenguajes:
1) Ellenguajequeelcompiladorentiendeyqueesescritoporelprogramador(elfuenteorigen).
2) Elcdigoenelqueelcompiladorescribe(elresultadodelacompilacin).
3) Ellenguajeenelqueestescritoelcompilador.
EsteescenarioserepresentaconundiagramaT:
Lee

Escribe
Est
escrito
en

Porejemplo,uncompiladordelenguajePascalqueestescritoenCygenereunasalidaenAssemblerserepresenta
conelsiguientediagramaT:
Pascal

Assembler
C

Podemos hacer un diagrama T del compilador que estamos creando y tambin podemos hacer el diagrama T del
compiladorconelqueestamoscompilandonuestrocompilador.
Ejemplos(MSCeselnombredeunlenguajedeterminado).

MSC

Assembler
C

AsmSUN

MSC

SUN

Cdigofuentedemi
compilador.

Assembler
SUN

CompiladordeCquecorre
enmquinasSUN

Micompiladorya
compilado

Enesteesquemaserepresentalaaccindeagarrarelcdigofuentedelcompiladorqueestoycreando(primeraT)y
compilarloconuncompiladortradicionaldeCquecorreenmquinasSUN(segundaT)yobtenercomoresultadomi
compiladorperoenbinariolistoparausar(tercerT).Observequecuandohablamosdecompiladoresyacompilados
seleindicaenquemquinacorreenvezdeponerenquelenguajefueescritoporqueunavezcompiladoelprograma
pocoimportaenquelenguajefuecreado.

AcontinuacinmostramosunejemploconunautocompiladoryaquefueescritoenPascalVSyleefuentesdePascal
VS:
PascalVS

AsmIBM

Pascal
VS

Cdigofuentedemi
compiladorde
lenguajePascalVS

PascalVS

AsmIBM

PascalVS

IBM

AsmIBM
IBM

UncompiladordePascal
VSquecorreenIBMy
generaunsoftparaesa
mismamquina

Micompiladorya
compilado

SupongamosquequeremosquenuestrocompiladorcorraenmquinasHPygenerecdigoHP.Entoncesloprimero
quetenemosquehaceresreescribirlasalidayquegenerecdigoHP,quedando:
PascalVS

AsmHP

Pascal
VS

LuegocomosegundopasoescompilarnuestrodesarrolloconnuestrocompiladordePascalVSparaIBMdndonos
comoresultado:
PascalVS

AsmHP
IBM

Si ahoracompilamos el fuentede nuestro compilador connuestrocompiladoren binario que obtuvimosen elpaso

anterior,nosdacomoresultadonuestrocompiladordePascalVScorriendoenHP!

PascalVS

AsmHP
Pascal
VS

PascalVS

AsmHP

PascalVS

IBM

AsmHP
HP

Conlocual,parahacerestosetuvoquecompilardosveceselfuentedenuestroautocompilador,laprimeraconun
compiladorcomnycorrientedenuestrolenguajeylasegundaconnuestropropioautocompiladorresultantedelpaso
anterior.Esaeslaventajadeescribirunautocompilador,simplificalatareadeportarloaotramquina.

Estr uctur adeunCompilador

Elprocesodecompilacinsepuededividirenlassiguientesetapas:

Fuente

Analizador
Lxico

Analizador
Sintctico

Generadorde
Cdigo

Asm,C,
bytecode,etc

Tablade
Smbolos

Elanalizadorlxicodivideelprogramaenfragmentosreconocibles.Porejemplo:
A:=B+10*A
Esteseriaelcdigofuentequedebereconocerelanalizadorlxicoyacontinuacinsemuestraqueesloquesalede
dichoproceso:
<idA><smbolodeasignacin><idB><operador+><constante10><operador*><idA><findelinea>
Esdecir,ignoraespacios,comentariosydeterminacadaunodeloselementosqueexistenenelfuentearrojandoerror
sinoreconocealguno.
CadaunodeestoselementosreconocidossellamanTokens.UtilizaunatabladeTokensdondeseenumerancadano
deellos.
En definitiva, la salida del subproceso del Analizador Lxico es una tira de Tokens reconocidos por medio de sus
cdigosenlatabladeTokens.
Luego el Analizador Sintctico construye el rbol de parsing utilizando las reglas BNF del lenguaje. La salida del
AnalizadorSintcticoeslalistadereglasquecumplieronalconstruirdichorbol.

Ana lizador Sintctico

Luego de que el Analizador Lxico haya procesado el cdigo de entrada, se ejecuta el Analizador Sintctico. Este
tomalatiradetokensgeneradayaplicandolagramticadevuelveunalistadereglasqueseaplicparacrearelrbol
deparsing.Esterbolesabstracto,esdecir,nosecreaenmemoriasinoqueseexpresaatravsdelalistadereglas
aplicadasquesonoutputalprocesodelAnalizadorSintctico.

ParsingAscendenteoBottomUp
EselprocesodeAnlisisSintcticoenelquesepartedelprogramadeusuariohastallegaralsmbolodistinguido.Se
dicequeesteprocesoesLR:
LaLsignificaLeftporqueleeelprogramadeusuariodeizquierdaaderecha.
LaRsignificaRightporqueparaaplicarlasreglasbuscamachearconelladoderechodeladefinicinen
cadaregla.
Ejemplo:
Tenemoslassiguientesreglas:
1.
2.
3.
4.
5.
6.
7.

<ASIG>id:=<EXPRESION>
<EXPRESION><EXPRESION>+<TERMINO>
<EXPRESION><TERMINO>
<TERMINO><TERMINO>*<FACTOR>
<TERMINO><FACTOR>
<FACTOR>id
<FACTOR>cte

Pararesolverlasiguienteasignacin:
ID:=ID+ID*CTE
Yhacemoselrboldeparsing:

<ASIG>
regla1
<EXPRESION>
regla2
<EXPRESION><TERMINO>
regla3regla4
<TERMINO><TERMINO>
regla5regla5
<FACTOR><FACTOR>

<FACTOR>

regla6regla6regla7

ID

:=

ID

+ID*CTE

Tiradereglasaplicadas:6,5,3,6,5,7,4,2,1.

ParsingDesendenteoTopDown
EselprocesodeAnlisisSintcticoenelquesepartedelsmbolodistinguidohastallegaralprogramadeusuario.Se
dicequeesteprocesoesLL:
LaprimerLsignificaLeftporqueleecadacontenidodelaregladeizquierdaaderecha.
LasegundaLsignificatambinLeftporqueaplicalasreglasbuscandoelmacheoconlaparteizquierda,es
decirconelelementoqueestsiendodefinidoenunaregla.
Ejemplo:
Tenemoslassiguientesreglas:

1. <ASIG>id:=<EXPRESION>
2. <EXPRESION><EXPRESION>+<TERMINO>
3. <EXPRESION><TERMINO>
4. <TERMINO><TERMINO>*<FACTOR>
5. <TERMINO><FACTOR>
6. <FACTOR>id
7. <FACTOR>cte
Pararesolverlasiguienteasignacin:
ID:=ID+ID*CTE
Yhacemoselrboldeparsing:
<ASIG>
regla1
ID:=

<EXPRESION>
regla2
<EXPRESION>

<TERMINO>

regla3regla4
<TERMINO><TERMINO>*<FACTOR>
regla5regla5

regla7

<FACTOR><FACTOR>CTE
regla6regla6

IDID

Tiradereglasaplicadas:1,2,3,5,6,4,5,6,7.

MtodoRecursivoDescendente(ParsingDescendente)

Esteeselprimermtodoqueutilizlaconstruccindeunrboldescendente.Apartirdelsmbolodistinguidosevan
aplicandolasreglassobreelNoTerminalqueseencuentramasalaizquierda.Ejemplo:

Tenemoslassiguientesreglas:

1. <ASIG>id:=<EXPRESION>
2. <EXPRESION><EXPRESION>+<TERMINO>
3. <EXPRESION><TERMINO>
4. <TERMINO><TERMINO>*<FACTOR>
5. <TERMINO><FACTOR>
6. <FACTOR>id
7. <FACTOR>cte
Pararesolverlasiguienteasignacin:
ID:=ID+ID*CTE
//Ponemoselsmbolodistinguido
<ASIG>
//Usamosregla1conelnoTerminal<ASIG>
ID:=<EXPRESION>
//Aplicamoslaregla2con<EXPRESION>yaqueeselprimernoterminaldesdelaizquierda
ID:=<EXPRESION>+<TERMINO>
//Aplicamoslaregla2con<EXPRESION>nuevamenteyaqueeselprimernoterminaldesdelaizquierda
ID:=<EXPRESION>+<TERMINO>+<TERMINO>
//Aplicamoslaregla2con<EXPRESION>nuevamenteyaqueeselprimernoterminaldesdelaizquierda
ID:=<EXPRESION>+<TERMINO>+<TERMINO>+<TERMINO>

Acahayunproblema!Comoelalgoritmoloquehaceesaplicarunareglaconelnoterminalqueseencuentremasala
izquierda,estoentraenunloopinfinito.Conestollegamosalaconclusindequelasgramticasparaalgoritmosde
parsingdescendentesnopuedenserrecursivasaizquierda.
Debidoaesto,estealgoritmoparaserusadodebetenerunagramticaconBNFrecursivaaderechacomolasiguiente:

1. <ASIG>id:=<EXPRESION>
2. <EXPRESION><TERMINO>+<EXPRESION>
3. <EXPRESION><TERMINO>
4. <TERMINO><FACTOR>*<TERMINO>
5. <TERMINO><FACTOR>
6. <FACTOR>id
7. <FACTOR>cte
Pararesolverlasiguienteasignacin:
ID:=ID+ID*CTE
//Ponemoselsmbolodistinguido
<ASIG>
//Usamosregla1conelnoTerminal<ASIG>
ID:=<EXPRESION>
//Aplicamoslaregla2con<EXPRESION>
ID:=<TERMINO>+<EXPRESION>
//Aplicamoslaregla4con<TERMINO>yaqueeselprimernoterminaldesdelaizquierda
ID:=<FACTOR>*<TERMINO>+<EXPRESION>
//Luegoaplicalaregla6paratenerlaprimervariable!
ID:=ID*<TERMINO>+<EXPRESION>

//Pero nosencontramoscon unproblema, elsmbolo *no seencuentra ennuestro cdigo original asi que
tenemosquehacerunBackTrackingqueesvolveratrssobrelasreglasaplicadasparaprobarotrocamino.
Asiquedeshacemoslosefectosdelaregla6yla4quehemosrealizadoypasamosahacerlaregla5.
ID:=<FACTOR>+<EXPRESION>
//Ahorasi,podemosaplicarlaregla6para<FACTOR>
ID:=ID+<EXPRESION>
//Sevapareciendoalcdigooriginal,ahoraaplicamoslaregla2con<EXPRESION>
ID:=ID+<TERMINO>+<EXPRESION>
// Pero si seguimos con esto nos damos cuenta que el segundo smbolo + nos va a provocar un Back
Trackingasiquetenemosqueaplicarlaregla3enelanteriorpaso
ID:=ID+<TERMINO>
//Aplicamoslaregla4con<TERMINO>
ID:=ID+<FACTOR>*<TERMINO>
//Aplicamoslaregla6con<FACTOR>
ID:=ID+ID*<TERMINO>
//Yacasiest,aplicamoslaregla4con<TERMINO>
ID:=ID+ID*<FACTOR>*<TERMINO>
//EstonosvaaproducirotroBackTrackingenunpasoposteriorasiquevolvamosyapliquemoslaregla5
ID:=ID+ID*<FACTOR>
//Yporregla7terminamos!
ID:=ID+ID*CTE
Finalmenteaplicamoslassiguientesreglas:1,2,5,6,3,4,6,5,7.

Este algoritmo es muy lento, hace muchos BackTracking y tiene mensajes de error complicados. Para no tener
BackTrackingsedebefactorizarlagramtica.
Elprocesodefactorizarunagramticaesobtenercadareglaquepuedaserambiguayobtenerelfactorcomnde
todasellasparagenerarunresultado.Porejemplo:
Teniendo:
ET+E
ET
Podemosfactorizara:
ETR
R+E
R[vacio]
Esdecir,unaexpresinesunterminoseguidodealgo,esealgopuedeserun+expresinosimplementenada.
Con esta gramtica y el algoritmo anterior, se obtiene un Analizador Sintctico que no hace Back Tracking. En
estascondicioneselalgoritmotieneelsiguientenombre:
MtodoLL(1)oPredictivoDesendente(ParsingDesendente)
Veamosunejemplo.
Gramticafactorizada:

1. <ASIG>id:=<EXPRESION>
2. <EXPRESION><TERMINO><R>
3. <R>+<EXPRESION>
4. <R>[vacio]
5. <TERMINO><FACTOR><Q>
8

6. <Q>*<TERMINO>
7. <Q>[vacio]
8. <FACTOR>id

9. <FACTOR>cte
Pararesolverlasiguienteasignacin:
ID:=ID+ID*CTE
//Ponemoselsmbolodistinguido
<ASIG>
//Usamosregla1conelnoTerminal<ASIG>
ID:=<EXPRESION>
//Aplicamoslaregla2con<EXPRESION>
ID:=<TERMINO><R>
//Usoregla5con<TERMINO>
ID:=<FACTOR><Q><R>
//Porlaregla8,<FACTOR>esunID
ID:=ID<Q><R>
//Ahoradebemosaplicarunareglapara<Q>,tenemosdosposiblesperosabemosquelaregla6nopuedeser
aplicadayaqueelsmbolo*delareglaentraenconflictoconelsmbolo+denuestrocdigo.Porlo
tantousamoslaregla7,haciendodesaparecera<Q>
ID:=ID<R>
//Usamoslaregla3con<R>sabiendoquenosepuedeaplicarla4porquetenemosunsmbolo+ennuestro
cdigooriginal
ID:=ID+<EXPRESION>
//Usamosregla2con<EXPRESION>
ID:=ID+<TERMINO><R>
//Aplicamoslaregla5con<TERMINO>
ID:=ID+<FACTOR><Q><R>
//Aplicamoslaregla8con<FACTOR>
ID:=ID+ID<Q><R>
//Para<Q>usamoslaregla6,yaquetieneelsmbolo*talcualseutilizaenelcdigooriginal
ID:=ID+ID*<TERMINO><R>
//Regla5para<TERMINO>
ID:=ID+ID*<FACTOR><Q><R>
//Regla9para<FACTOR>
ID:=ID+ID*CTE<Q><R>
//Regla7para<Q>
ID:=ID+ID*CTE<R>
//Regla4para<R>
ID:=ID+ID*CTE
Finalmenteaplicamoslassiguientesreglas:1,2,5,8,7,3,2,5,8,6,5,9,7,4

ImplementacindelMtodoLL(1)oPredictivoDesendente(ParsingDesendente)

Vamosaverlaimplementacindeestemtodo.

ListadeTokens

ListadeReglas

LL(1)

Tabla

Pila

Comoentradarecibelalistadetokensgeneradaporleanalizadorlxico,utilizaunatablayunapilaparaelprocesoy
tiene como salida una lista de reglas que fueron aplicadas para construir el rbol de parsing. Para explicar en que
consistenambasestructurasutilizadasporelalgoritmodebemosconoceralgunosconceptos.

Seguimostrabajandoconestagramtica:

1. <ASIG>id:=<EXPRESION>
2. <EXPRESION><TERMINO><R>
3. <R>+<EXPRESION>
4. <R>[vacio]
5. <TERMINO><FACTOR><Q>
6. <Q>*<TERMINO>
7. <Q>[vacio]
8. <FACTOR>id
9. <FACTOR>cte

LosPrimeros:sedefinecomoprimerodeunNoTerminaldado,todoaquelTerminalqueapareceenprimerlugar
dentrodealgunasdesusreglasquelodefinen.
Obtenemoslosprimerosdeloselementosdelagramtica:
Porregla1vemosqueenlaasignacinloprimeroque apareceesunid.
Prim(ASIG)={id}
ComoEXPRESIONtienecomoprimerelementoaTERMINO,loqueestprimeroenTERMINOsersuprimero.
Prim(EXPRESION)=Prim(TERMINO)={id,cte}
ParaR,elprimeroesunsigno+yaqueel[vaco]nosetieneencuenta.
Prim(R)={+}
ComoTERMINOtienecomoprimerelementoaFACTOR,loqueestprimeroenFACTORsersuprimero.
Prim(TERMINO)=Prim(FACTOR)={id,cte}
Paraq,elprimeroesunsigno*yaqueel[vaco]nosetieneencuenta.
Prim(Q)={* }
EnambasreglasdeFACTORloqueapareceprimerosonelidylacte.
Prim(FACTOR)={id,cte}

Nota:SielprimerNoTerminaldeunNoTerminaltieneunareglaquesehace[vaco]deboobtenerlosprimerosdel
siguiente.Ejemplo:
ETR
T[vaco]
Entonces:
Prim(E)=Prim(R)

10

LosSiguientes:sedefinecomosiguientedeunNoTerminaldado,todoaquelTerminalqueapareceacontinuacin
peroquenoespartedeladefinicindelNoTerminalencuestin.

Obtenemoslossiguientesdeloselementosdelagramtica:
Se dice que para el smbolo distinguido se le da como elemento siguiente al signo $ que representa el final de mi
cadenadedatosaanalizar.
Sgt(ASIG)={$}
La EXPRESION tiene por un lado la regla 1 por lacual, lo que se encuentre al final de ASIG seguir al final de
EXPRESION. Porotro lado,porla regla 2 vemosquelo que haya al final deR ser lomismo quehayal finalde
EXPRESION.
Sgt(EXPRESION)=Sgt(ASIG)USgt(R)={$}
Enlaregla3vemosqueloqueloquehayalfinaldeEXPRESIONesloquetieneRalfinal.
Sgt(R)=Sgt(EXPRESION)={$}
Porregla2,loquevienedespusdeTERMINOesloprimerodeR.PerosiResvaco,loquevieneesloltimode
EXPRESION.
Sgt(TERMINO)=Prim(R)USgt(EXPRESION)={+,$}
Porregla5eselsiguientedeTERMINO
Sgt(Q)=Sgt(TERMINO)={+,$}
Porregla5,despusdeFACTORestaelprimerodeQ.Porregla6,despusdeFACTORvieneelsiguientedeQ.Si
Qesvacoenlaregla5,loquevieneeselsiguientedeTERMINO
Sgt(FACTOR)=Prim(Q)USgt(Q)USgt(TERMINO)={*,+,$}

TablaqueutilizaelMtodoLL(1)

Apartirdelosconceptosvistosanteriormente,searmalasiguientetabla:

id
ASIG
EXPRESION
R
TERMINO
Q
FACTOR

:=

cte

Id:=<EXPRESION>
<TERMINO><R>

<TERMINO><R>
+<EXPRESION>

[vaco]

<FACTOR><Q>

<FACTOR><Q>
[vaco]

id

*<TERMINO>

[vaco]
cte

Paraconstruirlatablasetomacadareglaysehaceelsiguienteprocedimientoqueseexplicaconlaregla1:

Tomamos la fila de ASIG ya que es el elemento No Terminal que define y luego tomamos la columna del primer
elementoTerminalqueapareceenlaregladespusdelaflechadedefinicin(enestecasoid)yescribimosel
contenidodelaregla(Id:=<EXPRESION>).

11

Paraelcasodereglascon[vaco]seusanlossiguientesdelelementoNoTerminalqueseestdefiniendo.Ejemplo
deestoeslaregla4.

EjecucindelAlgoritmo

Vamosaresolverlasiguienteasignacin:
ID:=ID+ID*CTE
PILA
EXPLICACION
ASIG
Puseelsmbolodistinguido
EXPRESION:=id Usola regal1metiendolaen laPila(siempreloselementos van al
reves)
EXPRESION:=
Sacoeliddelapilayaquefuereconocido
EXPRESION
Sacoel:=delapilayaquefuereconocido
RTERMINO
Usolaregla2
RQFACTOR
Usolaregla5
RQid
Usolaregla8
RQ
Sacoeliddelapilayaquefuereconocido
R
Usolaregla7
EXPRESION+
Usolaregla3
EXPRESION
Sacoel+delapilayaquefuereconocido
RTERMINO
Usolaregla2
RQFACTOR
Usolaregla5
RQid
Usolaregla8
RQ
Sacoeliddelapilayaquefuereconocido
RTERMINO*
Usolaregla6
RTERMINO
Sacoel*delapilayaquefuereconocido
RQFACTOR
Usolaregla5
RQcte
Usolaregla9
RQ
Sacolactedelapilayaquefuereconocida

LOQUEFALTADETECTAR
id:=id+id*cte$
id:=id+id*cte$

R
$

Usolaregla7
Usolaregla4yreconozcoel$

:=id+id*cte$
id+id*cte$
id+id*cte$
id+id*cte$
id+id*cte$
+id*cte$
+id*cte$
+id*cte$
id*cte$
id*cte$
id*cte$
id*cte$
*cte$
*cte$
cte$
cte$
cte$
$

Finalmenteaplicamoslassiguientesreglas:1,2,5,8,7,3,2,5,8,6,5,9,7,4

ParsingAscendenteoBottomUp
EselprocesodeAnlisisSintcticoenelquesepartedelprogramadeusuarioysellegaalsmbolodistinguido.Se
dicequeesteprocesoesLR:
Losmtodosson:
SLR
LR(1)
LALR
Con estos mtodos ya no es necesario que las gramticas estn factorizadas y es indiferente que sean recursivas a
derechaoaizquierda.Loniconecesarioesquenoseaunagramticaambigua.

ImplementacindelMtodoSLR(ParsingAscendente)
Vamosaverlaimplementacindeestemtodo.Aqutenemosunarepresentacindelproceso:

ListadeTokens

ListadeReglas

SLR

Tabla

Pila

12

Tenemoslasiguientegramtica:
0. <ASIG><ASIG>
1. <ASIG>id:=<EXPRESION>

2. <EXPRESION><EXPRESION>+<TERMINO>
3. <EXPRESION><TERMINO>
4. <TERMINO><TERMINO>*<FACTOR>
5. <TERMINO><FACTOR>
6. <FACTOR>id
7. <FACTOR>cte
Comosepuedeapreciar,lagramticaestaaumentada,esoquieredecirqueexistelareglaceroqueenglobaalquea
prioriseranuestrosmbolodistinguido.Ahoraeldistinguidoes<ASIG>.

AlgoritmodeConstruccindelaTabla
Antesdecomenzarconelalgoritmo,cabeexplicarunanotacinnuevaqueusaremos.Alanalizarunaregla,selevaa
incluirunpunto(.)enunlugardeterminado,demaneraqueloqueestdelantedelpuntoseconsiderayaanalizado,y
loqueestdespusdelpuntoporanalizar.
Ejemplos:
Recinagarrolaregla,debobuscarinformacinsobre<EXPRESION>:
<EXPRESION>.<EXPRESION>+<TERMINO>
Yaanalic<EXPRESION>,ahorabuscoinformacinsobre+<TERMINO>:
<EXPRESION><EXPRESION>. +<TERMINO>
Termindeaplicarlaregla:
<EXPRESION><EXPRESION>+<TERMINO>.

Elalgoritmoparagenerarlatablaconstadeirnavegandoporlasreglaseirgenerandoestados.Vemosloenforma
prcticaparalagramticaanteriormentemostrada.
Estado0:Comenzamosgenerandoesteestadoconlareglacero:
<ASIG>.<ASIG>
Observequeelpuntoadelanteindicaqueaunnohemosvistoelrestodelaregla.Acontinuacindebemosdefinirque
elementosvlidossonlosquepuedenllegaraveniracontinuacindelpunto.ComoelpuntoestadelantedeunNo
Terminal,debemosaplicarunareglapararesolverlo,amedidaquehacemosestogeneramosotroestado.
Entonces,teniendoelNoTerminal<ASIG>,debemosverquereglaslodefinen:

1. <ASIG>id:=<EXPRESION>
Bueno,sabiendoesto,tenemosqueprobarquepasacuandoestandoenestado0,nosllegaun<ASIG>(queeselNo
Terminal buscado) y un id que es el primer elemento que aparece en nuestra nica regla posible. Para cada
posibilidadvamosagenerarunestado.
Resumiendo,loselementosvlidosparaelestado0quepuedenveniracontinuacinson:<ASIG>,id.

13

Estado1(0,ASIG):GeneramosunestadonuevoquesurgederecibirelNoTerminal<ASIG>estandoenelestado0
(deahlasdoscosasqueestncontenidasenelparntesis).Estosignificaquehemostenidoencuentael<ASIG>que
esperbamosenelestado0,dejndonos:
<ASIG><ASIG>.
Observemos que el punto avanzo porque ya atendimos la llegada del <ASIG>. Con lo cual, cuando el punto se
encuentraalfinaldetodo,damosporterminadoelanlisisdeesteestado.
Estado2 (0,id): Este es el otrocaso enelque estando en estado0nosllega unid,paralgeneramos un nuevo
estadoquellamamos2.Ahoratenemos:
<ASIG>id.:=<EXPRESION>
Estamosdentrodela regla1porqueeste estadosurgi delaposibilidadde aplicar dicha regla. Por lotanto,lo que
haceescomenzarconelavancedelaregla.Poreso,yluegodehaberconsumidoelidubicamoselpuntopordetrs
del:=.
En este estado el elemento siguiente es el Terminal :=. Por este motivo, el nico elemento que debe venir a
continuacinesese.
Elementosvlidosacontinuacin::=.

Estado3(2,:=):avanzamosporlaregla1,tenemos:
<ASIG>id:=.<EXPRESION>
Bueno,ahoravolvemosatenerunNoTerminaldelantedelpunto,estavezes<EXPRESION>.Entoncesbuscamos
lasreglasquedefinenaesteNoTerminal:

2. <EXPRESION>.<EXPRESION>+<TERMINO>
3. <EXPRESION>.<TERMINO>
4. <TERMINO>.<TERMINO>*<FACTOR>
5. <TERMINO>.<FACTOR>
6. <FACTOR>.id
7. <FACTOR>.cte
Ademsdelasreglas2y3quedefinena<EXPRESION>seincluyeronlasreglas4y5porqueuna<EXPRESION>
es un <TERMINO> segn regla 3. Por el mismo motivo se agregaron las reglas 6 y 7 a travs de <FACTOR>.
Recuerdeque<EXPRESION>seincluyepordosmotivosenlalista,primeroporqueeselelementoNoTerminalque
estadelantedelpuntoysegundoporqueexisteunaregla(la2)enlaqueeselprimerelementoenaparecerdentrode
ladefinicin.
Elementosvlidosacontinuacin:<EXPRESION>,<TERMINO>,<FACTOR>,id,cte.
Estado 4 (3, EXPRESION): Aca hay dos cuestiones, la primera es tomar a <EXPRESION> por haber sido el
elementoqueenelestado3estabadetrsdelpunto,paralocualpodemosmedirelavance:
<ASIG>id:=<EXPRESION>.
Por otrolado, tomamos a<EXPRESION>comoel primerelementode la regla2queeralaprimerposibilidaddel
estadoanterior.Segnesto,debemosmedirelavancededichareglaparalocualestamosasi:

<EXPRESION><EXPRESION>. +<TERMINO>
14

Bueno,ahoradebemosdefinirqueelementosvienenacontinuacin.Simiramoselprimeravance,vemosqueelpunto
estaalfinaldelareglaconlocualeseavanceterminaah.Ahoravemoselsegundoavanceyseobservaquehayun
Terminal+acontinuacin.
Elementosvlidosacontinuacin:+

Estado5(3,TERMINO):Enestecasoocurrelomismo,tenemosdosavances:

<EXPRESION><TERMINO>.
y

<TERMINO><TERMINO>.*<FACTOR>
Estosedebeaqueenelestadoanteriorhaydosreglasquecomienzancon<TERMINO>ensucuerpodedefinicin.
Talcomovimos,elprimeravancese descartaporhaberfinalizadoyconelotroesperamosa*.
Elementosvlidosacontinuacin:*

Estado6(3,FACTOR):Enesteestado,elavancees:

<TERMINO><FACTOR>.
Yacterminamosconesteestado.
Estado7(3,id):Enesteestado,elavance es:

<FACTOR>id.
Yacterminamosconesteestado.
Estado8(3,cte):Enesteestado,elavancees:

<FACTOR>cte.
Yacterminamosconesteestado.

Estado9(4,+):Enesteestado,elavancees:

<EXPRESION><EXPRESION>+. <TERMINO>
AhoranosencontramosconelNoTerminal<TERMINO>,veamosquereglaspuedoaplicar:

4. <TERMINO>.<TERMINO>*<FACTOR>
5. <TERMINO>.<FACTOR>
6. <FACTOR>.id
7. <FACTOR>.cte
Elementosvlidosacontinuacin:<TERMINO>,<FACTOR>,id,cte.

15

Estado10(5,*):Enesteestado,elavancees:

<TERMINO><TERMINO>*.<FACTOR>
SevieneelFACTOR,veamosquereglaspuedoaplicar:

6. <FACTOR>.id
7. <FACTOR>.cte
Recordemosqueademasdelidylacte,unelementoqueseesperaenesteestadoes<FACTOR>yaqueeselNo
Terminalqueestaacontinuacindelpunto.
Elementosvlidosacontinuacin:<FACTOR>,id,cte.

Estado11(9,TERMINO):Tenemos:
<EXPRESION><EXPRESION>+<TERMINO>.
y
<TERMINO><TERMINO>.*<FACTOR>
ComoparaesteNoTerminalhayunareglaademasdeserelesperado,tienedosavances.Enelprimeroseterminala
reglayenelsegundoseesperaun*acontinuacin.
Elementosvlidosacontinuacin:*

Estado12(9,FACTOR):Esteestadofinalmentenoestenidoencuenta.EstoesasiporquedeaplicarFACTORal
estado9,elavancequedariaasi:
<TERMINO><FACTOR>.
Observequeeseavanceesexactamenteelmismoqueelquetieneelestado6,conlocualnosetieneencuenta.Lo
quesivamosatenerencuentaesqueelpar(9,FACTOR)vaaestarasociadoconelestado6:

Estado6(9,F ACTOR).
Estado12(9,id):Pasalomismoqueenelanteriorperoconelestado7.

Estado7(9,id).
Estado12(9,cte):Pasalomismoqueenelanteriorperoconelestado8.

Estado8(9,cte).

Estado12(10,FACTOR):Elavancees:

<TERMINO><TERMINO>*<FACTOR>.
Terminamosconesteestado.
16

Estado13(10,id):):Pasalomismoqueenlasrepeticionesanterioresconelestado7.

Estado7(10,id).
Estado13(10,cte):):Pasalomismoqueenelanteriorperoconelestado8.

Estado8(10,cte).
Estado13(11,*):):Pasalomismoqueenelanteriorperoconelestado10.

Estado10(11,*).

Listo, a este punto no tenemos abierto ningn estado de los que generamos con lo cual damos por finalizado el
algoritmodegeneracindeestados.
Latablaestacompuestaportantasfilascomoestadoshayamosgenerado(enesteejemploson13estados)yencuanto
alascolumnasestadivididaendos,elprimergrupoparalosNoTerminalesyelsegundoparalosTerminales.
id

:=

cte

ASIG

EXPRESION TERMINO

FACTOR

0
1
2
3
4
5
6
7
8
9
10
11
12

LapartesombreadadecelesteselellamaAccinylapartegrisGoto.
ComenzamosallenarlapartedeGoto,paraellovamosadetectaraquellosestadosenlosquesellegacuandorecibe
unTerminal.Estosson:
Estado1(0,ASIG)
Estado4(3,EXPRESION)
Estado5(3,TERMINO)
Estado6(3,FACTOR)
Estado11(9,TERMINO)
Estado6(9,FACTOR)
Estado12(10,FACTOR)
ObservequeloselegidossoncadaunodelosparescuyosegundoelementoesunNoTerminal.Concadaunosedebe
ubicar la fila del estado original, la columna del No Terminal y dentro de la celda escribir el estado destino. Por
ejemplo,paralafila0ycolumnaASIGelvalorser1.Completadoquedadelasiguientemanera:

17

id

:=

cte

ASIG

EXPRESION TERMINO

FACTOR

0
1
2

11

6
12

4
5
6
7
8
9
10
11
12

EstaseccinquesellamaGotobsicamenteloquenosbrindaeslaposibilidaddesaberaqueestadodebemos ir
cuandoelalgoritmodelanalizadorsintcticoSLRdeberecurrireconoceunNoTerminalydependiendodelestadoen
que se encuentre. Por ejemplo, si se encuentra en estado 3 y reconoce una <EXPRESION> debe ir al estado 4.
Observequeel avancedelestado4eraelsiguiente:
<ASIG>id:=<EXPRESION>.
Loquesignificaquehemosreconocidoyconsumidola<EXPRESION>quenoshaballegado.
AcontinuacinvamosacomenzarallenarlaseccindeAcciones.Paraellodebemossaberqueexistendostiposde
acciones:
Desplazar:Eselactodeconsumirelcarctersiguientequeformapartedelalecturadelaentradadelusuario
deizquierdaaderecha.Porejemplo,cuandosetieneid:=...estandoparadoentreamboscaracteresyse
solicitaavanzarconsumiendoel:=.
Reducir: Es el acto de reconocer a un grupo de elementos y definirlos como el elemento que los engloba
segn la regla apropiada. Por ejemplo, cuando se reconoce a <EXPRESION> + <TERMINO> como una
<EXPRESION>.
Comenzaremosallenarloscasillerosparalosdesplazamientos.Paraestovamosadetectaraquellosestadosenlosque
sellegacuandorecibeunNoTerminal.Estosson:
Estado2(0,id)
Estado3(2,:=)
Estado7(3,id)
Estado8(3,cte)
Estado9(4,+)
Estado10(5,*)
Estado7(9,id)
Estado8(9,cte).
Estado7(10,id).
Estado8(10,cte).
Estado10(11,*).

18

Observequeloselegidos son cadauno delospares cuyo segundoelementoes unTerminal.Con cada unosedebe

ubicarlafiladelestadooriginal,lacolumnadelTerminalydentrode laceldaescribirelestadodestinojuntoauna
Dquesignificadesplazamiento.Porejemplo,paralafila0ycolumnaidelvalorserD2.Completadoquedade
lasiguientemanera:
id
0

:=

cte

D2

ASIG

EXPRESION TERMINO

FACTOR

D3

2
3

D7

D8

11

6
12

D9

D10

5
6
7
8
9
10

D7
D7

11

D8
D8
D10

12

A continuacin vamos a completar las celdas para las reducciones. Para eso primero debemos obtener aquellos
estadosquetienenalmenosunareglaconelpuntoalfinaldetodo,esdecir,cuandohancompletadoelavance.Estos
son:
Estado1(0,ASIG):<ASIG><ASIG>.
Estado4(3,EXPRESION):<ASIG>id:=<EXPRESION>.
Estado5(3,TERMINO):<EXPRESION><TERMINO>.
Estado6(3,FACTOR): <TERMINO><FACTOR>.
Estado7(3,id):<FACTOR>id.
Estado8(3,cte): <FACTOR>cte .
Estado11(9,TERMINO):<EXPRESION><EXPRESION>+<TERMINO>.
Estado6(9,FACTOR): <TERMINO><FACTOR>.
Estado7(9,id): <FACTOR>id.
Estado8(9,cte): <FACTOR>cte .
Estado12(10,FACTOR): <TERMINO><TERMINO>*<FACTOR>.
Estado7(10,id): <FACTOR>id.
Estado8(10,cte): <FACTOR>cte.
Antesdeexplicarcomosecompletalatabla,hayqueobtenerlosSiguientesdecadaelementoNoTerminal:
Sgt(ASIG)={$}
Sgt(ASIG)=Sgt(ASIG)={$}
Sgt(EXPRESION)=Sgt(ASIG)U{+}={$,+}
Sgt(TERMINO)=Sgt(EXPRESION)U{*}={$,+,*}
Sgt(FACTOR) =Sgt(TERMINO)={$,+,*}
Bueno, por ejemplo, para el estado 1 que obtuve en la lista anterior estoy aplicando la regla 0 que define al No
Terminal<ASIG>,tomamoslafila1ylascolumnasquerepresentenlosSiguientesdeeseelemento(enestecaso
solo$)yescriboenlaceldaunR0yaquelareglaesla0.
Paraelestado4,tomamoslosSiguientesde<ASIG>quetambines$yescribimosunR1yaquelareglaque
seaplicaenesteestadoesla1.
Latablaquedaraasi:

19

id
0

:=

cte

FACTOR

R0
D7

D8
D9
R3
R5
R6
R7

4
5
6
7
8

10

EXPRESION TERMINO

D3

ASIG

D2

D10
R5
R6
R7

D7
D7

D8
D8
R2
R4

11
12

11

6
12

R1
R3
R5
R6
R7

D10
R4

R2
R4

Porltimovamosahacerunretoque.Eslgicopensarquesiaplicamoslaregla0enalgunmomentodelalgoritmo
podemosdecirqueelprogramaestabienestructuradoporqueestaramosllegandoalsmbolodistinguido.Conlocual
ponemosunokenlaaplicacindelaregla.Latablaquedadelasiguientemanera:

id
0

:=

cte

D2

FACTOR

OK
D7

D8
D9
R3
R5
R6
R7

4
5
6
7
8

10

EXPRESION TERMINO

D3

ASIG

11
12

D8
D8
R2
R4

11

6
12

R1
R3
R5
R6
R7

D10
R5
R6
R7

D7
D7

D10
R4

R2
R4

Yconestofinalizamoslaconstruccindelatabla.

EjecucindelAlgoritmo

Vamosaresolverlasiguienteasignacin:
ID:=ID+ID*CTE
Loque vamosatener en la pilasonlosestadosen los que estaremosacada momento.Tambin vamos atenerun
smboloquesernuestroelementoactivoyenlaltimacolumnatendremosnuestraentradaqueiremosconsumiendo
hastafinalizar.

20

PILA

SIMBOLO

EXPLICACION
LOQUEFALTADETECTAR
Iniciamosenelestado0.
id:=id+id*cte$
id
Recibimos el id, buscamos la celda [0, id] y :=id+id*cte$
encontramosD2.Con locualconsumimosel idy
quedamosenestado2.
023
id:=
Recibimosel :=,con[2,:=] = D3,desplazamos id+id*cte$
yquedamosenestado3.
0237
id:=id
Recibimos un Nuevo id, con [3, id] = D7, +id*cte$
desplazamosynosvamosalestado7.
0236
id:=F
Ahoraencontramosun+, yen elhay unreducir +id*cte$
porque [7, +]= R6. La regla 6indica F id,
conlocualtomoelltimoidylotransformoa
F.Ademsdeboquitar unelementodeestado de
la pila, quedndome con el estado anterior que
es 3. Luego, utilizo la tabla de GOTO con el
estado actualy elelementoNo Terminal con el
quesehareducido,estoda[3,F]=6,yeste
ltimo es el nuevo estado. Observe que el
smbolo + no ha sido consumido porque no hubo
desplazamiento.
0235
id:=T
Vuelvo a recibir el +, tenemos [6, +] = R5. +id*cte$
Reducimos por regla 5, que es T F, quitamos
el estado 6 y hacemos [3, T] = 5, este ltimo
esnuestronuevoestado.
0234
id:=E
Vuelvo a recibir el +, tenemos [5, +] = R3. +id*cte$
Reducimos por regla 3, que es E T, quitamos
el estado 5 y hacemos [3, E] = 4, este ltimo
esnuestronuevoestado.
02349
id:=E+
Vuelvo a recibir el +, con [4, +] = D9, id*cte$
desplazamosel+.
023497
id:=E+id
Recibounid,con[9,id]=D7.
*cte$
023496
id:=E+F
Recibo un *, con [7, *] = R6. La regla 6 es F *cte$
id.Quitamoselestado 7yhacemos [9, F]=
6.
0234911
id:=E+T
Recibo un *, con [6, *] = R5. La regla 5 es T *cte$
F. Quitamos el estado 6 y hacemos [9, T] =
11.
023491110
id:=E+T*
Recibimos un *, con [11, *] = D10, consumimos cte$
el*.
0234911108 id:=E+T*cte Recibimos la cte, con [10, cte] = D8, $
desplazamoslacte.
02349111012 id:=E+T*F
Nosllegaelsmbolofinaldelagramtica,con $
[8,$] = R7,la regla7es F cte,y[10,F]
=12.
0234911
id:=E+T
Recib el$,con[12, $] = R4, regla4esT $
T * F, la utilizo. Al momento de quitar
estados, no vamos a quitar uno solo sino los
ltimos 3 estados ya que la definicin de la
regla tiene 3 elementos (T * F), con lo cual
quedamos enelestado 9.Hacemos [9,T] = 11y
eseesnuestronuevoestado
0234
id:=E
Recibimos nuevamente el $, con [11, $] = R2, $
aplicamosregla2queesEE+T.Quitamos3
estados quedndonos con el estado 3, y hacemos
[3,E]=4.
01
A
Recibimos $, con [4, $] = R1, usamos regla 1 $
queesAid:=E,reducimosyquitamoslos3
estadosquedndonosconel0.Con[0,A]=1.
Recibimos $, con [1, $] = OK, con lo cual $
aplicamos regla 0 (A A) Y finalizamos
concluyendo que la sentencia no tiene errores
sintcticos.
0
02

Finalmenteaplicamoslassiguientesreglas:6,5,3,6,5,7,4,2,1,0.

21

Gener acindeCdigo
Ahoraveremoselprocesodegenerarcdigo.EsteprocesorecibecomoentradaunalistadereglasqueelAnalizador
Sintcticoutilizoparaprocesarlaentradadetokens.
Vamosausarestagramticadeejemplo:

1.
2.
3.
4.
5.
6.
7.
8.
9.

<ASIG>id:=<EXPRESION>
<EXPRESION><EXPRESION>+<TERMINO>
<EXPRESION><EXPRESION> <TERMINO>
<EXPRESION><TERMINO>
<TERMINO><TERMINO>*<FACTOR>
<TERMINO><TERMINO>/<FACTOR>
<TERMINO><FACTOR>
<FACTOR>id
<FACTOR>cte

Supongamosquetenemoscdigo:
precio:=costo*1.4+transporte/20bonific
Lasentenciapuedeversecomo:
id:=id*cte+id/cteid
Sihacemoselrboldeparsing:

<ASIG>
regla1

<EXPRESION>
regla3
<EXPRESION>
regla2
<EXPRESION>
regla4
<TERMINON><TERMINO>
regla5regla6
<TERMINO><TERMINO><TERMINO>
regla7regla7

regla7

<FACTOR><FACTOR><FACTOR><FACTOR><FACTOR>
regla8regla9regla8regla9regla8

ID

:=

ID

*CTE+ID/CTE

Tiradereglasaplicadas:8,7,9,5,4,8,7,9,6,2,8,7,3,1.

22

ID

El resultado de ese proceso es la tira de reglas, que es lo que arroja el Analizador Sintctico, como se dijo
anteriormente,peroademsdeesto,lasreglas8y9vienenacompaadasporelndicedelaTabladeSmbolosala
queapuntan:

Costo20
Transporte
1.4Bonific
Ahorasi,estaeslaentradatalcuallatomaelGeneradordeCdigojuntoalaTabladeSmbolos.
El rbol sintctico es una estructura similar al rbol de parsing como el que hicimos anteriormente en la que se
eliminanlosNoTerminales.Semuestraacontinuacin:

:=
precio

bonific

+
*

costo

1.4

transporte

20

Cadanodoesunaoperacinentresusdoshijos.Porejemplo,elnodo*esunamultiplicacinentrecostoy1.4,
el nodo / es unadivisin entre trasportey20,el resultado deambos esuna suma dentrodel nodo +yasi
sucesivamente.Enlaprctica, los nodosqueapuntana una constante o a unavariabletieneelndice a laTablade
Smbolos.
Si el rbol es recorrido en orden simtrico se obtiene el mismo programa que se est compilando. La forma de
recorrerloporestemtodoesempezarconelnodopadre,encadanodoprimeroseresuelveelprimerhijo,luegose
tomaelnodopadreyluegoseresuelveelsegundohijo.Porejemplo,comienzocon:=tomandoaprecio,luego
tomo el := y luego resuelvo todo lo que hay debajo de (el resultado ser costo * 1.4 + transporte / 20 si
continuamosconelalgoritmo).Finalmentetomamosel,luegobonificylisto.
Peroexisteotra formade tomar laentrada, estasellama Polaca Inver sa.Con este mtodo,se debe tomarelnodo
padre y en cada nodo primero se resuelve el primer hijo, luego el segundo nodo y por ltimo el mismo padre. Si
hacemosestoelresultadoser:
preciocosto1.4*transporte20/+bonific :=

23

Paraverlounpocomasclaro,sedebetenerencuentaquecadaoperadortomacomooperandoslosdosquetienepor
delante:
El*afectaacostoy1.4.
El/afectaatransportey20.
El+afectaa(costo*1.4)y(transporte/20).
Elafectaa((costo*1.4)+(transporte/20))ybonific.
El:=afectaa(((costo*1.4)+(transporte/20)) bonific)yprecio.

Otraformade representar las operaciones es la llamada Ter cetos.Es unaagrupacin de cadauno delos nodosde
maneracadaunotienelostreselementosutilizandoreferenciasentrelasoperacionesintermendias:
1)
2)
3)
4)
5)

(*,costo,1.4)
(/,transporte,20)
(+,1,2)
(,3,bonific)
(:=,precio,4)

Losvaloresentrecomillassonreferenciasaotrodelostercetos.
Otra forma parecida a esta es la de Cuar tetos. Es igual a la anterior pero con un elemento mas que es el sitio
simblicodondeseguardaelresultadodelaoperacinintermedia:
1)
2)
3)
4)
5)

(*,costo,1.4,aux1)
(/,transporte,20,aux2)
(+,aux1,aux2,aux3)
(,aux3,bonific,aux4)
(:=,precio,aux4,)

Luegodeestaintroduccinalosmtodos,vamosavereldetalleelprocesodegeneracindeCdigoAssembler:

Tercetos

ListadeReglas

ArboldeParsing

ArbolSintctico

Cuartetos

Assembler

PolacaInversa

Enestecuadroestilustradoelcaminooriginalporelquedebepasarlalistadereglasparatransformarseencdigo
assembler.EnrealidadelArboldeParsingnoseusa,esunconceptoterico,mientrasquesedebeutilizarTercetoso
PolacaInversayaqueelmtododeCuartetosesobsoleto(seusabaantiguamenteenmquinasconinstruccionesde
tresoperandos).

24

Peroexistenposibilidadesdesaltarsemuchosdelospasosconlocualhaymuchosprocesosdiferentesdegeneracin.
El puntoest enelegirque camino tomaremosala horade desarrollar nuestro proceso.Esadecisin seva a basar
respectoalobjetivosquetengamos,loscualpuedenser:
Sequiereobteneruncompiladorrpidoycompacto
Etapas:
1. ListadeReglas
2. Assembler

Sequierequenuestrocompiladorobtengaejecutableseficientes
Etapas:
1. ListadeReglas
2. ArbolSintctico
3. Tercetos
4. Assembler
Pocoesfuerzoalahoradedesarrollarnuestrocompilador
Etapas:
1. ListadeReglas
2. PolacaInversa
3. Assembler

TodaslasetapasmenosladeAssemblerdependendellenguajequeestamoscreando,peroasuvezestadependedela
mquinadondecorrelosejecutablesqueseobtengancomoresultado.Conlocual,laprimeraopcinnoesportable,
en cambio, las otras opciones solo requieren que se desarrolle nuevamente la etapa de Assembler al momento de
transformarnuestrocompiladoraotraplataforma.
Lasegundaopcinejecutalasetapasdondesetratantodaslasoptimizacionesconocidas,poresogeneraejecutables
maseficientes.

Acontinuacinvemosdosejemplosdeoptimizacin.
Ejemplo1:
Z:=3*9*k
EnestasentenciasepuedeaplicarlaoptimizacindeReduccinSimp le,tomandoelvalorde3*9ycompilando
losiguiente:
Z:=27*k
Ejemplo2:
Z:=a*b*c+4*a*b
EnestasentenciasepuedeaplicarlaoptimizacindeRedundancia,tomandoelvalordea*bparaevitarquela
mismamultiplicacinserealicedosveces,conunaalcanza.

25

Tr aduccindeListadeRegla sar bolSintctico

Acontinuacinvamosaexplicarlaformadeconstruirelrbolsintcticoenmemoria.Utilizaremoslagramticade
siembre:

1.
2.
3.
4.
5.
6.
7.
8.
9.

<ASIG>id:=<EXPRESION>
<EXPRESION><EXPRESION>+<TERMINO>
<EXPRESION><EXPRESION> <TERMINO>
<EXPRESION><TERMINO>
<TERMINO><TERMINO>*<FACTOR>
<TERMINO><TERMINO>/<FACTOR>
<TERMINO><FACTOR>
<FACTOR>id
<FACTOR>cte

Laideaesgenerarenmemoriaunaseriedenodosqueestninterconectados.Paraeso,cadaunotienedospunteros,
unoalhijoizquierdoyelotroalhijoderecho.AsuvezvamosatenertantospunterosanodocomoNoTerminales
exista en nuestra gramtica. Estos punteros van a ir siendo desplazados a medida de que se va reconociendo la
sentenciaacompilar.Paranuestrocasoestosserian:

Aptr
Eptr
Tptr
Fptr

El algoritmolo que hacees ejecutarunafuncinasociadaa cada regla enelmomentode aplicarla. Acontinuacin

vamosaexplicarcadauna:

1. <ASIG>id:=<EXPRESION>
Aptr =cr ear Nodo(:=,crear Hoja(id),Eptr )
Secreaelnodoquecontienealsignodeasignacinytomacomohijoizquierdounahojacreadacon
el id reconocido ycomohijoderecho laexpresin reconocidaen Eptr. El nodo resultantequeda
apuntadoporelpunteroAptr.Esdecir,construyelosiguiente:

:=
ID

2. <EXPRESION><EXPRESION>+<TERMINO>
Eptr =cr ear Nodo(+,Eptr ,Tptr )
Creaunnuevonodoparalasumayponecomohijosalaexpresinyalterminoreconocidos.

+
E

26

3. <EXPRESION><EXPRESION> <TERMINO>
Eptr =cr ear Nodo(,Eptr ,Tptr )
Parecidoalanteriorperoconelnododeresta.
4. <EXPRESION><TERMINO>
Eptr =Tptr
Conestasentencia,elnodoqueestabaapuntandoTptr(porlotanto,quehastaesemomentoeraun
Termino)ahorapasaaserapuntadoporEptr(esdecir,ahorapasaaserunaExpresin).
5. <TERMINO><TERMINO>*<FACTOR>
Tptr =cr ear Nodo(*,Tptr ,Fptr )
Secrea elnodo que contiene a la multiplicacin y toma comohijo izquierdo al nodo apuntadoen
Tptr y como hijo derecho al nodo apuntado por Fptr. El nodo resultante queda apuntado por el
punteroTptr.Esdecir,construyelosiguiente:

*
T

6. <TERMINO><TERMINO>/<FACTOR>
Tptr =cr ear Nodo(/,Tptr ,Fptr )
Parecidoalanteriorperoconelnododedivisin.
7. <TERMINO><FACTOR>
Tptr =Fptr
Conestasentencia,elnodoqueestabaapuntandoFptr(porlotanto,quehastaesemomentoeraun
Factor)ahorapasaaserapuntadoporTptr(esdecir,ahorapasaaserunTermino).
8. <FACTOR>id
Fptr =cr ear Hoja(id)
Estafuncincreaunnuevonodoenmemoriayleponeelvalorpasadocomoparmetroalcontenido.
Enestecasoid.
9. <FACTOR>cte
Fptr =cr ear Hoja(cte)

27

Estafuncincreaunnuevonodoenmemoriayleponeelvalorpasadocomoparmetroalcontenido.
Enestecasocte.
Acontinuacinvamosacomenzarconelseguimientoalalgoritmo.Recordemosqueestamoscompilandolasiguiente
asignacin:
precio:=costo*1.4+transporte/20bonific
Debemosrecorrerlalistadereglasresultantesdelaseccinanterioreirejecutandolospasos:
Regla8: <FACTOR>id

SereconocecomounFactoralidentificadorprecio.Estoejecutalasentencia:
Fptr=crearHoja(costo)
Nosqueda:

Aptr:null
Eptr:null
Tptr:null
Fptr:nodocosto

costo

Regla7: <TERMINO><FACTOR>
SereconocealFactorquereconocimosltimocomounTermino.Ejecuta:
Tptr=Fptr
Nosqueda:

Aptr:null
Eptr:null
Tptr:nodocosto
Fptr:nodocosto

costo

Regla9: <FACTOR>cte

SereconocecomounFactoralaconstante1.4.Estoejecutalasentencia:
Fptr=crearHoja(1.4)
Nosqueda:
Aptr:null
Eptr:null
Tptr:nodocosto
Fptr:nodo1.4

costo

28

1.4

Regla5: <TERMINO><TERMINO>*<FACTOR>

ReduceelTerminoyelFactorquehabiamosreconocidoltimogenerandoelnododemultiplicacin.Esto
ejecutalasentencia:
Tptr=crearNodo(*,Tptr,Fptr)

Nosqueda:
Aptr:null
Eptr:null
Tptr:nodo*
Fptr:nodo1.4

1.4

costo

Regla4: <EXPRESION><TERMINO>
Ejecuta:
Eptr=Tptr

Nosqueda:
Aptr:null
Eptr:nodo*
Tptr:nodo*
Fptr:nodo1.4

1.4

costo

Regla8: <FACTOR>id

Ejecuta:
Fptr=crearHoja(transporte)

Nosqueda:
Aptr:null
Eptr:nodo*
Tptr:nodo*
Fptr:nodotransporte

1.4

costo

29

transporte

Regla7: <TERMINO><FACTOR>
Ejecuta:
Tptr=Fptr
Nosqueda:
Aptr:null
Eptr:nodo*
Tptr:nodotransporte
Fptr:nodotransporte

costo

1.4

transporte

1.4

transporte

Regla9: <FACTOR>cte

Ejecuta:
Fptr=crearHoja(20)
Nosqueda:
Aptr:null
Eptr:nodo*
Tptr:nodotransporte
Fptr:nodo20

costo

20

Regla6: <TERMINO><TERMINO>/<FACTOR>

Ejecuta:
Tptr=crearNodo(/,Tptr,Fptr)
Nosqueda:
Aptr:null
Eptr:nodo*
Tptr:nodo/
Fptr:nodo20

1.4

costo

30

transporte

20

Regla2: <EXPRESION><EXPRESION>+<TERMINO>

Ejecuta:
Eptr=crearNodo(+,Eptr,Tptr)

+
Nosqueda:
Aptr:null
Eptr:nodo+
Tptr:nodo/
Fptr:nodo20

1.4

costo

20

transporte

Regla8: <FACTOR>id

Ejecuta:
Fptr=crearHoja(bonific)

bonific

+
Nosqueda:
Aptr:null
Eptr:nodo+
Tptr:nodo/
Fptr:nodobonific

1.4

costo

20

transporte

Regla7: <TERMINO><FACTOR>
Ejecuta:
Tptr=Fptr
bonific

+
Nosqueda:
Aptr:null
Eptr:nodo+
Tptr:nodobonific
Fptr:nodobonific

1.4

costo

31

transporte

20

Regla3: <EXPRESION><EXPRESION><TERMINO>

Ejecuta:
Eptr=crearNodo(,Eptr,Tptr)

bonific

+
Nosqueda:
Aptr:null
Eptr:nodo
Tptr:nodobonific
Fptr:nodobonific

1.4

costo

Regla1: <ASIG>id:=<EXPRESION>

20

transporte

:=

Ejecuta:
precio

Aptr=crearNodo(:=,crearHoja(precio),Eptr)

Nosqueda:
bonific

+
Aptr:hoha:=
Eptr:nodo
Tptr:nodobonific
Fptr:nodobonific

1.4

costo

transporte

20

Seacabaronlasreglas,porlotantoterminaelalgoritmoyelpunteroAptrquedaapuntandoalcomienzodel
rbolsintcticoquequedlistoenmemoria.

Nota:Tomemoscomoejemploelsiguientecdigo:
intx,y
x=y+2
Sabemosquelaprimersentencia,queesdedeclaracin,novaagenerarcdigoassembler.Porlotantonos
podemospreguntarsiesnecesarioarmarunrbolsintcticocomoelsiguiente:
32

Sentencia1

Declaracin

Sentencia2

int

Lista

Sentencia3

Lista

...

La respuesta es que no esta mal hacerlo pero no es necesario. Lo mas prctico es separar las sentencias
ejecutablesdelasdedeclaracinydejarqueestasltimasseencarguendegenerarTabladeSmbolos.

TiposdeDa tosenlaConstr uccindelr bolSintctico

Elalgoritmoexplicadoanteriormentenotieneencuentasilasvariablesyconstantessondediferentetipode
dato. Por ejemplo, costo podra ser un float, bonific un long, etc. Vamos a ver que se modifica del
algoritmoanteriorparasercontempladoestetema.
Enprimerlugar,envezdetenersolounpunteroporcadaNoTerminal,ahoratenemosunaestructurapor
cadauno.Estaestructuraestacompuestaporelpunteroyporeltipodedato.
Entoncesserian:

A{A.ptr,A.tipo}
E{E.ptr,E.tipo}
T{T.ptr,T.tipo}
F{F.ptr,F.tipo}

Yactualizamoslasfuncionesqueseejecutanalaplicarlasreglas,yaqueahorahayquetratarconlasestructuras:

1. <ASIG>id:=<EXPRESION>
A.ptr =cr ear Nodo(:=,cr ear Hoja(id,id.tipo),Eptr ,id.tipo)
2. <EXPRESION><EXPRESION>+<TERMINO>
33

E.tipo=fun(E.tipo,T.tipo)
E.ptr =cr ear Nodo(+,E.ptr ,T.ptr ,E.tipo)
3. <EXPRESION><EXPRESION> <TERMINO>
E.tipo=fun(E.tipo,T.tipo)
E.ptr =cr ear Nodo(,E.ptr ,T.ptr ,E.tipo)
4. <EXPRESION><TERMINO>
E.ptr =T.ptr
E.tipo=T.tipo
5. <TERMINO><TERMINO>*<FACTOR>
T.tipo=fun(T.tipo,F.tipo)
T.ptr =cr ear Nodo(*,T.ptr ,F.ptr ,T.tipo)
6. <TERMINO><TERMINO>/<FACTOR>
T.tipo=fun(T.tipo,F.tipo)
T.ptr =cr ear Nodo(/,T.ptr ,F.ptr ,T.tipo)
7. <TERMINO><FACTOR>
T.ptr =F.ptr
T.tipo=F.tipo
8. <FACTOR>id
F.ptr =cr ear Hoja(id,id.tipo)
F.tipo=id.tipo
9. <FACTOR>cte
F.ptr =cr ear Hoja(cte,cte.tipo)
F.tipo=cte.tipo
La funcin llamada fun en las reglas que mostramos anteriormente es utilizada para obtener un tipo de dato
resultantedeoperarconlosdostiposdedatospasadoscomoparmetros.
Vamosaverunejemplo.Tenemos:
x:=3+z

:=

Elrbolseraelsiguiente:
+,float

X,long

3,int

34

Z,float

Cadanodotieneelelementoyeltipodedatosdelnodo.Amedidaquesevaoperandosevaconociendoeltipode
datoquenosqueda.Porejemplo,enelrbolsevcomolasumaentreelentero3yelfloatzdacomoresultado
unvalordetipofloat.Estosellamasntesisdedatos.Enelejemplo,alaplicarlaregla2yreducirlasuma,seejecuta
lallamadaalafuncinquenosindicaeltipodedatodelresultado.
Enlamayoradeloslenguajes,dadodostipodedatostenemoselmismoresultanteindependientementedeltipode
operacinqueseestrealizando.Estostienenunatabladelassiguientescaractersticas:
Int
Int
Float
142

Int
Float
Str ing

Floa t
Float
Float
143

Str ing
142
143
String

Enesteejemplovemoscomocadapardetipodedatostieneunresultado.EnelcasodelStringelejemplosuponeque
operarconcualquiertiponumricodaerroryelnmeroenlatablaeselcdigodeerror.
Estatablapuedecrecerencompilacincuandoellenguajetienesobrecargadeoperadores(connuevosusoparael+,
,*,etc).Encasocontrario,denopodersedefinirlatablaesfija.Esdecir,estodependedequesielnuevotipodedato
puedaoperarseono.Porejemplo,podemoscreardostiposdedatosnuevos,perasybananas,perosiestasnopueden
sumarseorestarsenotienesentidosaberquetipodedatoeselresultanteporquenuncalonecesitaremos.

Enelrbolpuedesermasdetalladoencuantoalasconversionesquegeneraelcdigo.Porejemplo,esteeselrbol
masdetalladodelejemploanterior:
:=

+,float

Conv(float
tolong)

Z,float

Conv(int
tofloat)

X,long

3,int

Es importante tener clara la diferencia de operar un int y un float al momento de generar cdigo porque por
ejemplo,elprimerosesumaenCPUyelsegundoenelcoprocesadormatemtico.Sinoseutilizaesterbol,sedeben
tenerencuentalasconversionesalmomentodegenerarelassembler.
Parafacilitarestatarea,loscompiladoresamplianlatablaquevimosmasarribaagregandoademasdeltipodedato
resultante,sisedebeconvertiralgunodelosdosoperandos:

Int
Float
Str ing

Int
Float
142

Int

Floa t

C(inttofloat)

Float
Float
143

35

C(inttofloat)

142
143
String

Str ing

Comovemos,cuandoelprimerelementoesunIntyelsegundoesunfloat,laprimercolumnadelastresindicael
tipodedatoresultantequeesfloat,lasegundaindicaqueelprimerelementodebehacerunaconversindesdeint
afloatylatercercolumnaindicaqueelsegundooperandoquedatalcualest.
Puededarsequealoperarlongyfloat,comosontipodedatosquecomoresultadopuedendaralgomasgrande
quenoentraenlostiposdedatosdelosoperandos,tengamosalgoasi:

float
long

double

C(longtodouble)

C(floattodouble)

Tr aduccinder bolSintcticoa Assembler (sinconver sindetiposysiendotodos int )

Vamos a realizar un mtodo que utiliza variables auxiliares y por ahora no nos vamos a meter con los
diferentestiposdedatosquepuedetenerellenguaje.Realizaremoslatraduccindelsiguienterbol:
a:=(2b)*(c+d)/x

:=

Loprimeroque sedebehacer es recorrer el rbol enbusca del nodoque tenga los doshijos lo mas a la
izquierdaposible.Enelejemploesenodoeseldelaresta.

36

Luegosegeneraelcdigoparaesenodo.
MOV
SUB
MOV

R1,2
R1,b
aux1,R1

Tanto b como aux1 son dos posiciones de memoria (estamos suponiendo que es un lenguaje esttico). Vale
aclararquehayporcionesdeestatraduccinquesonsiemprefijas,sonlasmarcadasacontinuacin:
MOV
SUB
MOV

R1,2
R1,b
aux1,R1

Luego de esto se debe dar de alta a aux1 en la tabla de smbolos. Tambin se elimina el nodo atendido y se
reemplazaporunosinhijosquehacereferenciaalavariableresultanteaux1.
Volvemosacomenzarelcicloeligiendoelnodoconhijosmasalaizquierdadentrode nuestrorbolresultante.

:=

aux1

c
Elegimoselnododelasuma:

Estogeneraelsiguientecdigo:
MOV
ADD
MOV

R1,c
R1,d
aux2,R1

37

Es un cdigo muy similar al anterior con la diferencia que los operandos y la operacin son otros y genera otra
variableauxiliarquetambinescreadaenlatabladesmbolos.
Continuoconloquefalta:

:=

aux2

aux1

Elnodoelegidoeseldelamultiplicacin.Cdigoresultado:
MOV
MUL
MOV

R1,aux1
R1,aux2
aux3,R1

Continuoconloquefalta:

:=

aux3

Elnodoelegidoeseldeladivisin.Cdigoresultado:
MOV
DIV
MOV

R1,aux3
R1,x
aux4,R1

38

Continuoconloquefalta:

:=

aux4

Elnodoelegidoeseldelaasignacin,dehechoeselltimo.Cdigoresultado:
MOV
MOV

R1,aux4
a,aux4

Yfinalizamos.Todoestecdigoquefuimosgenerandoeselresultadodelatraduccindelrbolaassembler.Existen
compiladoresquehacenunapostoptimizacinrepasandolasinstruccionesyeliminandoloquepuedaestardems.

Hay compiladores que utilizan registros del CPU en vez de variables auxiliares mientras estos estn libres. A esta
tcnicaselallamaseguimientoderegistrosporqueelcompiladordebesaberqueregistrosestnsiendoutilizadoscon
valoresintermediosparaseguirconstruyendolassentenciasdeoperacin.Paraestefin,setieneunatablaqueindica
paracadaregistrosiestalibreuocupado:
Registro
R1
R2
R3
R4

Estado
Libre
Libre
Libre
Libre

Alrealizarcadaunodelospasosanteriormentedescriptos,elcompiladorbuscaelprimerregistrolibre y loutiliza.
Luegomarcacomoocupadoelregistroqueutilizycontinua.Veamoselmismoejemploanterioraplicadoconesta
tcnica.

a:=(2b)*(c+d)/x
Enelprimerpasosegeneraelcdigoparaelnododelaresta.
MOV
SUB

R1,2
R1,b

UsamosR1porqueeselprimerregistromarcadocomolibreenlatabla.Luegodeestoloponemoscomoocupado.

Registro
R1
R2
R3
R4

Estado
Ocupado
Libre
Libre
Libre

Nosquedaelrboldelasiguientemanera:

39

:=

R1

c
Elegimoselnododelasuma.Estogeneraelsiguientecdigo:
MOV
ADD

R2,c
R2,d

UsamosR2porqueeselprimerregistromarcadocomolibreenlatabla.Luegodeestoloponemoscomoocupado.
Registro
R1
R2
R3
R4

Estado
Ocupado
Ocupado
Libre
Libre

Nosquedaelrboldelasiguientemanera:

:=

R1

R2

40

Elnodoelegidoeseldelamultiplicacin.Cdigoresultado:
MUL

R1,R2

LiberamoselR2yaquehemosguardadoelresultadoenelR1.
Registro
R1
R2
R3
R4

Estado
Ocupado
Libre
Libre
Libre

Nosquedaelrboldelasiguientemanera:

:=

R1

Elnodoelegidoeseldeladivisin.Cdigoresultado:
DIV

R1,x

Continuoconloquefalta:

:=

R1

Elnodoelegidoeseldelaasignacin,dehechoeselltimo.Cdigoresultado:
MOV

a,R1

LiberamoselR1dejndonostodoslosregistroslibres.
Yfinalizamos.Comopodemosver,conestatcnicaseahorramuchsimasinstrucciones yvariablesauxiliares.Pero
noevitaelusodevariablesauxiliaressilasentenciatienemuchostrminos(lacantidadderegistroseslimitada).
Dependiendodedondeseencuentra lasvariablesquesevanaoperarelcompiladorsedacuentadedebetomarun
registrooliberarlo.Veamosloscasos:

41

operador

Estenodosiempreocupaunregistronuevo.
Variable1

Variable2

operador

EstenodosiempreliberaelR2

R1

R2

operador

Estenodonorealizaningunaocupacinniliberacin

R1

Variable1

Enestecaso,silaoperacinesconmutativanoocurre
nada(trabajaracomoelejemploanterior,invirtiendolos
elementos).Perosinoloes,primeroseocupaunnuevo
registroconelvalordelavariable,seoperaconR1
sobreeseregistronuevoyseliberaR1.Elvalorqueda
enelnuevoregistro.

operador

Variable

R1

:=
EstenodosiempreliberaelR1.Alterminarlaoperacin
deasignacin,noquedaningnregistroocupado.
Variable

R1

Nota:Algenerarassemblernosedebeutilizarelnombredelasvariablesqueledioelusuario.Veamosunejemplo.
Elusuariocreolasiguientesentenciaennuestrolenguaje:

42

MOV:=ADD
Siutilizramostalcuallosnombres,nuestrocompiladorgeneraralosiguiente:
MOVMOV,ADD

Estoprovocaraunerror.Paraevadiresteproblema,debemosagregarlealgomasalosnombresdevariableselegidos
porlosusuarios,porejemplo,elcarcter$adelante:
MOV$MOV,$ADD

Ahorasi,notenemosproblemas.

43