TECNOLÓGICO NACIONAL DE MÉXICO INSTITUTO TECNOLÓGICO DE ACAPULCO “Educación Tecnológica con Compromiso Social” Carrera: Ingeniería en Sistemas Computacionales Asignatura: Lenguajes y Autómatas II
Reporte de actividades de aprendia!e " pr#cticas Unidad : !eneración de código intermedio""
Co$petencia espec%&ica a desarro''ar #ise$a mediante el uso de reglas sem%nticas dirigidas por sinta&is' un anali(ador sem%ntico para un compilador"
Pro&esor( Sil)estre *edolla Solano Integrantes del e+uipo: ,
No$)rede'a'*$no( Pera'ta Arec,i-a Sa$*e' .a!ardo /arreiro Ed*ardo Rodri-*e Aparicio 0arina Mite' /a*tista santos A'e!andro
N+$erodecontro' ,-- ,-- ,--./01 ,--.22
Acapulco' !uerrero' 3&"' 0 de Septiem4re del .,0"
1ndice Contenido
Introd*cci2n.......................................................................................3 Actividad 34........................................................................................4 Detectar Errores Se$#nticos4..................................................................4 E!e$p'os De La Actividad Uno4 ..............................................................7 Actividad 54......................................................................................23 Dise6ar 7 Se'eccionar In&or$aci2n So)re La Constr*cci2n De Un Ana'iador Se$#ntico4.......................................................................................23 E!e$p'os De La Actividad Dos.............................................................28 Actividad 84...................................................................................... 46 Reconocer E' Mane!o De Tipos En Las E9presiones 7 E' Uso De Operadores4......46 Actividad :4......................................................................................54 Esta)'ecer Las Re-'as Para La Conversi2n De Tipos ;Castin-< En E9presiones4...54 Conversiones I$p'%citas.................................................................... 56 Conversiones E9p'%citas.................................................................... 56 E9cepciones De Las Conversiones De Tipos En Tie$po De E!ec*ci2n............ 58 Actividad =4...................................................................................... 59 A-re-ar Acciones Se$#nticas A La Estr*ct*ra De La Gra$#tica4.....................59 Actividad >4...................................................................................... 70 Manip*'ar La Ta)'a De Conversi2n De S%$)o'os 7 De Errores 7 Direcciones4...... 70 Actividad ?4......................................................................................65 Inte-rar E@*ipos De Tra)a!o Para La Constr*cci2n De Un Ana'iador Se$#ntico4. 65 Actividad 4...................................................................................... 81 Prop*esta De Pro"ecto Para E' Ana'iador LB9ico 7 Sint#ctico4....................... 81 Conc'*siones.................................................................................... 82 Bibliografía.................................................................................... 83
Actividad 34 Aplicar los tipos de notación para la conversión de expres iones: Infija, prefija y posfija
2.3 Los Esquema esquemasde degeneración generación son las estrategias o acciones que se deberán realizarse y tomarse en cuenta en el momento de generar código intermedio.
2
.
Los esquemas de generación dependen de cada lenguaje. Tomaremos algunos esquemas de generación del lenguaje C. Variables y constantes Las ariables y constantes deben separarse de tal manera que queden las e!presiones una por una de manera simple. "or ejemplo int a#b#c$ se descompone a int a$ int b$ intc$ respectiamente. E!presiones En esta %unción recibe una cadena que representa una l&nea de código intermedio y toma las medidas oportunas para que ese código se utilice. Estas medidas pueden ser escribir la l&nea en un %ic'ero adecuado# almacenar la instrucción en una lista que despu(s se pasará a otros módulos# o cualquier otra que necesitemos en nuestro compilador. E!presiones aritm(ticas )on aquella donde los operadores que interienen en ella son num(ricos# el resultado es un n*mero y los operadores son aritm(ticos. Los operadores aritm(ticos más com*nmente utilizados son+ ,#- # # / y 0. Comenzamos el estudio por las e!presiones aritm(ticas. Lo que tendremos que 'acer es crear por cada tipo de nodo un m(todo que genere el código para calcular la e!presión y lo emita. Ese código dejará el resultado en un registro# cuyo nombre deolerá el m(todo como resultado. "ara reserar estos registros temporales# utilizaremos una %unción# resera. En principio bastar 1a con que esta %unción deuela un registro distinto cada ez que se la llame. Cada nodo generará el código de la siguiente manera+ "or cada uno de sus operandos# llamara al m(todo correspondiente para que se eal*e la sub e!presión. )i es necesario# reserara un registro para guardar su resultado. Emitirá las instrucciones necesarias para realizar el cálculo a partir de los operandos.
nstrucciones de asignación La sinta!is general de la instrucción de asignación es+ nombredelaariable 4 alor El alor a la derec'a del signo igual puede ser una constante# otra ariable
3
o una e!presión que combine constantes y ariables# pero siempre la ariable y su alor deben ser del mismo tipo de dato. Ejemplos+ edad0 4 5 area6 4 72.3 nombre8 4 9"edro:
nstrucciones de asignación compuesta
Las instrucciones de asignación compuesta realizan primero una operación en una e!presión antes de asignarla a un elemento de programación. En el siguiente ejemplo se muestra uno de estos operadores# ,4# que incrementa el alor de la ariable del lado izquierdo del operador con el alor de la e!presión de la derec'a. ;na instrucción de asignación asigna el alor de una e!presión a una ariable. En general# si la ariable que se a a asignar es una propiedad# la propiedad debe ser de lectura y escritura o de sólo escritura$ en caso contrario# se produce un error de compilación. )i la ariable es una ariable de sólo lectura# la asignación debe producirse en un constructor )'ared o un constructor de instancia apropiado para el tipo de la ariable$ en caso contrario# se producirá un error de compilación. nstrucciones de control Esta %orma de programación sólo permite resoler problemas sencillos. "ara resoler problemas más complejos# nos puede interesar que dependiendo de los alores de los datos# se ejecuten unas instrucciones u otras. Las instrucciones condicionales nos an a permitir representar (ste tipo de comportamiento. )entencias < y )=TC>. En otros casos# nos encontraremos con la necesidad de repetir una instrucción o instrucciones un n*mero determinado de eces. En (stos casos utilizaremos instrucciones de control iteratias o repetitias ?ciclos@. )entencias =>LE# AB-=>LE y
Actividad 1 4
package infixpostfix4; import java.util.Scanner; import java.util.Stack; public class InfixPostfix4 { public static void main(String[ args! { ""#ntrada de datos S$stem.out.println(%&#scribe una expresi'n algebraica %!; Scanner leer ) ne* Scanner(S$stem.in!; ""+epurar la expresion algebraica String expr ) depurar(leer.next,ine(!!; String[ arra$Infix ) expr.split(% %!; ""+eclaraci'n de Stack < String > Stack < String > para operadores Stack < String >
las pilas E = new Stack < String > (); ""Pila entrada P = new Stack < String > (); ""Pila temporal S = new Stack < String > (); ""Pila salida
""-adir la arra$ a la Pila de entrada (#! for (int i ) arra$Infix.lengt/ 0 1; i 2) 3; i00! { #.pus/(arra$Infix[i!;
tr$ { ""-lgoritmo Infijo a Postfijo while (!E.isEmpty()) { switch (pref(E.peek())){ case 1 P.psh(E.p"p()); #reak; case $ case % while(pref(P.peek()) >= pref(E.peek())) { S.psh(P.p"p()); & P.psh(E.p"p()); #reak; case ' while(!P.peek().eals(()) { S.psh(P.p"p()); & P.p"p(); E.p"p(); #reak;
5
*efalt S.psh(E.p"p()); & &
""#liminacion de 5impure6as7 en la expresiones algebraicas String infix ) expr.replace(% %8 %%!; String postfix ) S.toString(!.replace-ll(%[9999[8%8 %%!; "":ostrar resultados S$stem.out.println(%#xpresion Infija % infix!; S$stem.out.println(%#xpresion Postfija % postfix!; catc/(#xception ex!{ S$stem.out.println(%#rror en la expresi'n algebraica%!; S$stem.err.println(ex!; ""+epurar expresi'n algebraica private static String depurar(String s! { s ) s.replace-ll(%99s%8 %%!; ""#limina espacios en blanco s ) %(% s %!%; String simbols ) %0&"(!%; String str ) %%; ""+eja espacios entre operadores for i ) 3; i < s.lengt/(!; i! { if (int (simbols.contains(%% s.c/ar-t(i!!! { str ) % % s.c/ar-t(i! % %; else str ) s.c/ar-t(i!; return str.replace-ll(%99s%8 % %!.trim(!; ""=erar>uia de los operadores private static int pref(String op! { int prf ) ??; if (op.e>uals(%@%!! prf ) A; if (op.e>uals(%&%! BB op.e>uals(%"%!! prf ) 4; if (op.e>uals(%%! BB op.e>uals(%0%!! prf ) C; if (op.e>uals(%!%!! prf ) D; if (op.e>uals(%(%!! prf ) 1; return prf;
6
Actividad 54 Dise6ar " se'eccionar in&or$aci2n so)re 'a constr*cci2n de *n ana'iador se$#ntico4 Atri)*tos " Gra$#ticas con Atri)*tos
7
In5ormalmente' se llamar% atributos de un s&mbolo de la gramática a toda in5ormación a$adida en el %r4ol de deri)ación por el anali(ador sem%ntico' asociada a los sím4olos de los nodos anotados" Un componente importante de las gram%ticas de atri4utos es el algoritmo de c%lculo de los )alores" Ejemplos de atri4utos: o o o
Tipo de una )aria4le 6alor de una e&presión U4icación en memoria de una )aria4le
o o
Código de unsigni5icati)os procedimiento 78meroo4jeto de dígitos en un n8mero
Una gram%tica de atri4utos es una gram%tica independiente del conte&to en la cual a sus sím4olos terminales y no terminales se les dota de unos atri4utos y a sus producciones de unas 5unciones de e)aluación que 'acen que dic9os atri4utos se propaguen a tra)s de la gram%tica" Su 5in es conocer un determinado )alor de un atri4uto en cual+uier parte del %r4ol de deri)ación y tomar la decisión oportuna" Un atri4uto es una propiedad asociada a una estructura sint%ctica" Si una estructura sint%ctica representada por el sím4olo gramatical ; tiene asociado un atri4uto a lo representaremos por ;"a <7om4re sím4olo" 7om4re atri4uto= Ejemplo: numero >? numero digito @ digito a=
numero>? digito
numero")alor digito")alor 4= digito")alor
numero >? numero digito numero,")alor numero")alor B ,.
Las 5unciones sem%nticas relacionan los )alores de los atri4utos de5inidos so4re la gram%tica atri4uida y )an asociadas a producciones de la gram%tica atri4uida"
#e5inición 5ormal Una gram%tica de atri4utos est% 5ormada por una tripleta !A D!IC' A' F ! G gram%tica independiente del conte&to
8
A G atri4utos asociados a los sím4olos terminales y no terminales G 5unción de e)aluación' 5unción asociada a producción +ue determina como o4tener unos atri4utos en 5unción de otros dentro de la misma producción
a es un atri4uto asociado al sím4olo no terminal A y o4tiene su )alor en 5unción de los atri4utos: a asociado a ;,' 4 asociado a ; 'Hy ( asociado a ;m < es un atri4uto o4tenido en 5unción de la parte derec9a de la producción=
a es un atri4uto asociado al sím4olo ;, y o4tiene su )alor en 5unción de los atri4utos: a asociado a A' 4 asociado a ;
A'-orit$os para C#'c*'o de Atri)*tos Al igual +ue e&isten 9erramientas +ue construyen anali(adores sint%cticos a partir de gram%ticas li4res de conte&to' tam4in e&isten 9erramientas autom%ticas +ue generan e)aluadores de gram%ticas atri4uidas o' en la mayor parte de los casos' de5iniciones dirigidas por sinta&is" En muc9as ocasiones' las 9erramientas de 9
desarrollo de procesadores de lenguaje o5recen la posi4ilidad de especi5icar' de un modo imperati)o en lugar de declarati)o' las reglas sem%nticas de las de5iniciones dirigidas por sinta&is
atri4uidas en una 8nica pasada
Una rutina sem%ntica no de4e utili(ar atri4utos sinteti(ados de un sím4olo gramatical +ue est a la derec9a de ella" G Un atri4uto sinteti(ado para el no terminal de la i(+uierda sólo se puede calcular posteriormente a los atri4utos de los +ue depende" La rutina sem%ntica +ue calcula estos atri4utos se suele colocar al 5inal del lado derec9o de la producción"
La Ta)'a de S%$)o'os Un compilador utili(a una ta4la de sím4olos para lle)ar un registro de la in5ormación so4re %m4ito y el enlace los nom4res" Se5uente" e&amina de sím4olos cada )e(el+ue se encuentra un de nom4re en el te&to Si la seta4la descu4re un nom4re nue)o o nue)a in5ormación so4re un nom4re ya e&istente' se producen cam4ios en la ta4la" Un mecanismo de ta4la de sím4olos de4e permitir a$adir entradas nue)as y encontrar las entradas e&istentes e5icientemente" Los dos mecanismos para ta4las de sím4olos presentadas en esta sección son listas lioeal"es y ta4las de dispersión" Cada es+uema se e)al8a 4as%ndose en el tiempo necesario para a$adir n entradas y reali(ar e consultas" Una lista lineal es lo m%s 5%cil de implantar' pero su rendimiento es po4re cuando e y n s )uel)en m%s grandes" Los es+uemas de dispersión proporcionan un mayor rendimiento con un es5uer(o algo mayor de programación y gasto de espacio" Am4os mecanismos pueden adaptarse r%pidamente para 5uncionar con la regla del anidamiento m%s cercano" Es 8til +ue un compilador pueda aumentar din%micamente' la ta4la de sím4olos durante la compilación" Si la ta4la de sím4olos tiene tama$o 5ijo al escri4ir el compilador' entonces el tama$o de4e ser lo su5icient emente grande como para al4ergar cual+uier programa 5uente" Es muy pro4a4le +ue dic9o tama$o sea demasiado grande para la mayoría de los programas e inadecuado para algunos"
Entradas de 'a ta)'a de s%$)o'os Cada entrada de la ta4la de sím4olos corresponde a la declaración de un nom4re" El 5ormato de las entradas no tiene +ue ser uni5orme por+ue la in5ormaci ón de un nom4re depende del uso de dic9o nom4 re" Cada entrada se puede implantar como un registro +ue conste de una secuencia de pala4ras consecuti)as de memoria" Qara mantener uni5ormes los registros de la ta4la de sím4olos' es con)eniente guardar una parte de la in5ormación de un nom4re 5uera de la entrada de la ta4la' almacenando en el registro sólo un apuntador a esta in5ormación" 7o toda la in5ormación se introduce en la ta4la de sím4olos a la )e(" Las pala4ras cla)e se introducen' si acaso' al inicio" El anali(ador l&ico 4usca secuencias de letras y dígit os en la ta4la de sím4olos para determinar si se 9a encontrado una pala4ra cla)e reser)ada o un 11
nom4re" Con este en5o+ue' las pala4ras cla)e de4en estar en la ta4la de sím4olos antes de +ue comience el an%lisis l&ico" En ocasiones' si el anali(ador l&ico reconoce las pala4ras cla)e reser)adas' entonces no necesitan aparecer en la ta4la de sím4olos" Si el lenguaje no con)ierte en reser)adas las pala4ras cla)e' entonces es indispensa4le +ue las pala4ras cla)e se introdu(can en la ta4la de sím4olos ad)irtiendo su posi4le uso como pala4ras cla)e"
Caracteres dentro de *n no$)re E&iste una distinción entre el componente l&ico id para un identi5icador o nom4re' el le&emadel 5ormado porLas la cadena componen el nom4re' y los atri4utos nom4re" cadenasdedecaracteres caracteres+ue pueden ser di5íciles de manejar' así +ue los compiladores utili(an a menudo alguna representación de longitud 5ija del nom4re en lugar del le&ema" El le&ema es necesario cuando se esta4lece por primera )e( una entrada a la ta4la de sím4olos y cuando se 4usca un le&ema encontrado en los datos de entrada para determinar si es un nom4re +ue ya 9a aparecido" Una representación 9a4itual de un nom4re es un apuntador a una entrada en la ta4la de sím4olos para l" Si 9ay un límite superior pe+ue$o para la longitud de un nom4re' entonces los caracteres del nom4re pueden almacenarse en la entrada de la ta4la de sím4olos' como se muestra en la 5igura
E!e$p'os de 'a actividad dos pacage toens import ja)a"util"B 12
BB B B aut9or In)itado B pu4lic class Toens D static String linea V-2B-V usando delimitadores y regresandolos como toens static StringToeni(er toens- neW StringToeni(erBV' true= static 5inal int 7U3EPX. static 5inal int XQEPA#XP, static String le&emaVV pu4lic static int le&ico<= D i5 V=@@le&ema"e+uals
pu4lic static )oid main
13
B separacion de toens con StringToeni(er usando el espacio por de5ecto como separador de toens StringToeni(er toens neW StringToeni(er
int toenle&ico<= do D System"out"println
14
E!e$p'o 5 15
Código uente: B B To c9ange t9is license 9eader' c9oose License Keaders in Qroject Qroperties" B To c9ange t9is template 5ile' c9oose Tools @ Templates B and open t9e template in t9e editor" B pacage ta4la"de"toens import ja)a"util"B BB B B aut9or In)itado B pu4lic class Ta4la#eToens D pu4lic static class ElementoTs elemento de la ta4la de sim4olos' D String le&ema a+ui de4emos poner todos los atri4utos +ue +ueremos usar en el compilador int longitud*ytes pu4lic ElementoTs
a partir de a+ui ponemos todos los
D t9is"le&emal F pu4lic String getLe&ema<= 16
D return t9is"le&ema F F pu4lic static 5inal int p- el tama$o del arreglo de 9as9
LinedListZElementoTs?J listaLigada
5or
creamos datos de prue4a ElementoTs aneW ElementoTs
calculamos 5uncion de 9as9
5or
Atri4utos a&6ar ts"get
E!e$p'o 8 Código uente: 19
using System; using System.Collections.ene!ic; using System.Com"onent#odel; using System.$ata; using System.$!a%ing; using System.&in'; using System.(e)t; using System.(*!eading.(as+s; using System.(e)t.,egula!-)"!essions; using System.indo%s./o!ms; using System.; names"ace analiado!le)ico "ulic"a!tialclass/o!m1 /o!m "ulic /o!m1 nitialieCom"onent; ,ege)&e)e! cs&e)e! : ne%,ege)&e)e!; ool load; &istst!ing< "ala!as,ese!vadas; "!ivatevoid /o!m1&oado=ect sende!> -ventA!gs e using St!eam,eade! s! : ne%St!eam,eade!?@CBse!s,aul$ocumentsisual Studio 2015D!o=ectsanaliado! le)icoanaliado! le)ico,ege)&e)e!.cs@ EEt)Code.(e)t : s!.,ead(o-nd; cs&e)e!.Add(o+en,ule?@sF@> @-SDAC@> t!ue; cs&e)e!.Add(o+en,ule?@GaHAHIJG%JK@> @$-L(/CA$,@; cs&e)e!.Add(o+en,ule? @@.KM@@> @CA$-LA@; cs&e)e!.Add(o+en,ule @N.NONGPJN@> @CA,AC(-,@; cs&e)e!.Add(o+en,ule@EGP!nJK@> @C#-L(A,1@; cs&e)e!.Add(o+en,ule?@dK.MdF@> @LB#-,@; cs&e)e!.Add(o+en,ule?@GGJ;>J@> @$-&#(A$,@; cs&e)e!.Add(o+en,ule?@G.:FHEKQJ@> @D-,A$,@; cs&e)e!.Add(o+en,ule?@ @C#DA,A$,@; cs&e)e!.Add(o+en,ule?@<:O:O:::O:R@> @-,,,@; "ala!as,ese!vadas : ne%&istst!ing< @ast!act@> @as@> @async@> @a%ait@> @c*ec+ed@> @const@> @continue@> @deault@> @delegate@> @ase@> @!ea+@> @case@> @do@> @else@> @enum@> @event@> @e)"licit@> @e)te!n@> @alse@> @Tnally@> @T)ed@> @o!@> @o!eac*@> @goto@> @i@> @im"licit@> @in@> @inte!ace@> @inte!nal@> @is@> @loc+@> @ne%@> @null@> @o"e!ato!@>@catc*@> @out@> @ove!!ide@> @"a!ams@> @"!ivate@> @"!otected@> @"ulic@> @!eadonly@> @!e@> @!etu!n@> @sealed@> @sieo@> @stac+alloc@> @static@> @s%itc*@> @t*is@> @t*!o%@> @t!ue@> @t!y@> @ty"eo@> @names"ace@> @unc*ec+ed@> @unsae@> @vi!tual@> @void@> @%*ile@> @Uoat@> @int@> @long@> @o=ect@> @get@> @set@> @ne%@> @"a!tial@> @yield@> @add@> @!emove@> @value@> @alias@> @ascending@> @descending@> @!om@> @g!ou"@> @into@> @o!de!y@> @select@> @%*e!e@> @=oin@> @e'uals@> @c*a!@> @decimal@> @doule@> @dynamic@> @syte@> @s*o!t@> @using@>@ool@> @st!ing@> @uint@>@yte@> @ulong@> @us*o!t@> @va!@> @class@> @st!uct@ ; cs&e)e!.Com"ile,ege)"tions.Com"iled ,ege)"tions.-)"licitCa"tu!e;
O
20
,ege)"tions.Singleline
O
load : t!ue; AnalieCode; t)Code./ocus; "!ivatevoid AnalieCode data!idie%1.,o%s.Clea!; EElv(o+en.tems.Clea!; int n : 0> e : 0; o!eac* va! t+1 in cs&e)e!.et(o+enst)Code.(e)t i t+1.Lame :: @-,,,@ eFF; i t+1.Lame :: @$-L(/CA$,@ i "ala!as,ese!vadas.Containst+1.&e)ema t+1.Lame : @,-S-,A$@; data!idie%1.,o%s.Addt+1.Lame>t+1.&e)ema>t+1.&inea>t+1.Columna>t+1.nde); EEst!ing cadena : t+1.Lame F @ @ Ft+1.&e)ema; EElv(o+en.tems.Addcadena; nFF; t*is.(e)t :st!ing./o!mat@Analiado! &e)ico H 0 to+ens 1 e!!o!es@ > n> e; EETn del metodo analiecode "!ivatevoid CodeC*angedo=ect sende!> -ventA!gs e i load AnalieCode;
En esta parte es donde de5inimos las )aria4les +ue guardaran la in5ormación +ue son los toens' le&emas' líneas e índice" using System; using System.Collections.ene!ic; using System.&in'; using System.(e)t; using System.(*!eading.(as+s; names"ace analiado!le)ico class(o+en "ulic (o+enst!ing name> st!ing le)ema> int inde)> int linea> int columna Lame : name; &e)ema : le)ema; nde) : inde); &inea : linea; Columna : columna; "ulicst!ing Lame get; set; "ulicst!ing &e)ema get; "!ivateset; "ulicint nde) get; "!ivateset;
21
"ulicint &inea get; "!ivateset; "ulicint Columna get; "!ivateset; "ulicint &eng*t get !etu!n &e)ema.&engt*;
\ por 8ltimo esta parte es donde e&trae las reglas y pala4ras reser)adas y las anali(ara y se compilara del te&to +ue introdu(ca en la caja de te&to" using System; using System.Collections.ene!ic; using System.&in'; using System.(e)t; using System.(*!eading.(as+s; using System.(e)t.,egula!-)"!essions; names"ace analiado!le)ico class,ege)&e)e! ,ege) !e); St!ingVuilde! "at!on; ool !e'uie!eCom"ila!; &istst!ing< (Lames; intGJ Lume!s; "ulic ,ege)&e)e! !e'uie!eCom"ila! : t!ue; (Lames : ne%&istst!ing<; EEEsumma!y< EEE Ag!ega una nueva !egla "a!a !econoce! to+en EEEEsumma!y< [email protected]@> @C#-L(A,2@ EEE"a!am name:@"atte!n@<"at!Wn en el 'ue dee enca=a!E"a!am< EEE"a!am name:@to+enname@ st!ing to+enname> ool igno!e : alse i st!ing.sLull!*iteS"aceto+enname t*!o%ne%A!gument-)ce"tionst!ing./o!mat@0 no es un nom!e vYlido.@> to+enname; i st!ing.sLull!-m"ty"atte!n t*!o%ne%A!gument-)ce"tionst!ing./o!mat@-l "at!Wn 0 no es vYlido.@> "atte!n; i "at!on :: null "at!on : ne%St!ingVuilde!st!ing./o!mat@M0<1@> to+enname> "atte!n; else "at!on.A""endst!ing./o!mat@OM0<1@> to+enname> "atte!n; i Rigno!e (Lames.Addto+enname; !e'uie!eCom"ila! : t!ue;
22
EEEsumma!y< EEE ,einicia el &e)e! EEEEsumma!y< "ulicvoid ,eset !e) : null; "at!on : null; !e'uie!eCom"ila! : t!ue; (Lames.Clea!; Lume!s : null; EEEsumma!y< EEE Analisa una ent!ada en usca de to+ens validos y e!!o!es EEEEsumma!y< EEE"a!am name:@te)t@ llame al mZtodo Com"ileo"tions.@; #atc* matc* : !e).#atc*te)t; i Rmatc*.Success yield!ea+; int line : 1> sta!t : 0> inde) : 0; %*ile matc*.Success i matc*.nde) < inde) st!ing to+en : te)t.Sust!inginde)> matc*.nde) H inde); yield!etu!nne%(o+en@-,,,@> to+en> inde)> line> inde) H sta!t F 1; line F: CountLe%&inesto+en> inde)> !e sta!t; o! int i : 0; i Lume!s.&engt*; iFF i matc*.!ou"sGLume!sGiJJ.Success st!ing name : !e).!ou"Lame/!omLume!Lume!sGiJ; yield!etu!nne%(o+enname> matc*.alue> matc*.nde)> line> matc*.nde) H sta!t F 1; !ea+; line F: CountLe%&inesmatc*.alue> matc*.nde)> !e sta!t; inde) : matc*.nde) F matc*.&engt*; matc* : matc*.Le)t#atc*; i te)t.&engt* < inde) yield!etu!nne%(o+en@-,,,@> te)t.Sust!inginde)> inde)> line> inde) H sta!t F 1;
23
EEEsumma!y< EEE C!ea el A/L con los "at!ones estalecidos EEEEsumma!y< "ulicvoid Com"ile,ege)"tions o"tions i "at!on :: null t*!o%ne%-)ce"tion@Ag!ege uno o mYs "at!ones> llame al mZtodo Add(o+en,ule"atte!n> to+enname.@; i !e'uie!eCom"ila! t!y !e) : ne%,ege)"at!on.(oSt!ing> o"tions; Lume!s : ne%intG(Lames.CountJ; st!ingGJ gn : !e).et!ou"Lames; o! int i : 0> id) : 0; i gn.&engt*; iFF i (Lames.ContainsgnGiJ Lume!sGid)FFJ : !e).!ou"Lume!/!omLamegnGiJ; !e'uie!eCom"ila! : alse; catc* -)ce"tion e) t*!o% e); EEEsumma!y< EEE Cuenta la cantidad de lineas "!esentes en un to+en> estalece el inicio de linea. EEEEsumma!y< "!ivateint CountLe%&inesst!ing to+en> int inde)> !eTnt linesta!t int line : 0; o! int i : 0; i to+en.&engt*; iFF i to+enGiJ :: NnN lineFF; linesta!t : inde) F i F 1; !etu!n line;
24
Actividad 84 25
Reconocer e' $ane!o de tipos en 'as e9presiones " e' *so de operadores4
“Un operador es un elemento de programa +ue se aplica a uno o )arios operandos en una e&presión o instrucción" Los operadores +ue re+uieren un operando' como el operador de incremento se conocen como operadores unario s" Los operadores +ue re+uieren dos operandos' como los operadores aritmticos <'>'B' = se conocen como operadores 4inarios" Un operador' el operador condicional <]:=' utili(a tres operandos y es el 8nico operador ternario de C” ,J" E&isten 0 tipos de operadores seg8n su 5unción' +ue son aritmticos' relacionales' de asignación' lógicos' de dirección y de manejo de *its" XQEPA#XPES #E ASI!7ACI^7 Este tipo de operadores permiten la asignación de un )alor especí5ico a una )aria4le" En C se encuentran disponi4les los siguientes operadores:
Todos ellos son operadores 4inarios' de los cuales' “” es el 8nico de asignación simple' los dem%s son operadores de asignación compuestos' puesto +ue est%n con5ormados por m%s de un sím4olo' por ejemplo “” se compone del operador “ “y el operador “ “" Los seis primeros aceptan operandos de distinto tipo' mientras +ue los cinco 8ltimos: ZZ' ??' _' ` y @' implican manejo de 4its' por lo +ue sus operandos de4en ser numero int en sus distintas )ariantes" El 5uncionamiento de estos operadores se encuentra descrito en la sección de operadores de 4its" La parte i(+uierda <+ue tiene +ue ser una )aria4le no constante= ad+uiere el )alor se$alado en la e&presión de la derec9a' pero se mantiene el tipo srcinal de la )aria4le de la parte i(+uierda" En caso necesario se 26
reali(a una con)ersión de tipo
Una característica importante del lenguaje C es +ue todos los elementos anteriormente enumerados distinguen entre may8sculas y min8sculas" Constantes: Las constantes +ue se pueden usar en C se clasi5ican en: • • •
enteras reales de car%cter
Cadena de caracteres: Son secuencias de caracteres simples encerradas entre “”" A las cadenas de caracteres el compilador les a$ade un car%cter nulo' aparece despus de las cadenas y se representan b.' y los almacena como una matri( de car%cter" Ej": “KXLA”.Y bK' bX' bL' bA' b.Y donde . es el car%cter de terminación 27
Identi5icadores: Son los nom4re dados a )aria4les' 5unciones' eti+uetas u otros o4jetos de5inidos por el programador" Un identi5icador est% 5ormado por letras
Xperadores' e&presiones' sentencias: Un operador es un sím4olo +ue indica alguna operación so4re uno o )arios o4jetos del lenguaje a los +ue se denominan operandos" 28
Atendiendo al n8mero de operandos so4re los +ue act8a un operador' estos se clasi5ican en: unitarios: cuando act8an so4re un solo operando 4inarios: operandos ternarios: - operandos Atendiendo al tipo de operación +ue reali(an' se clasi5ican en:
• • • • •
aritmticos relacionales lógicos de tratamiento de 4its especiales
Los operadores' junto con los operandos' 5orman e&presion es" En una e&presión' los operandos pueden ser constantes' )aria4les o llamadas a 5unciones +ue de)uel)an )alores" Una e&presión se con)ierte en una sentencia cuando )a seguida de un “”" Cuando un grupo de sentencias se encierran entre lla)es' D F' 5orman un 4lo+ue sint%cticamente e+ui)alente a una sentencia" Pesto de di)isión entera El )alor de)uelto por el operador de di)isión <= depende del tipo de operandos" Si stos son enteros' de)uel)e la parte entera del cociente" Si alguno de ellos es real' de)uel)e el resultado como n8mero real" El operador de resto de di)isión entera <[= e+ui)ale a mod Ej": ;\ siendo int &' y el resultado es 1" ;/ 29
\ Los operadores y > > aumentan o disminuyen respecti)amente en una unidad el operando so4re el +ue act8an" Ej": C es lo mismo +ue CY C , C > > es lo mismo +ue CY C > , Si el operador est% antes de la )aria4le' la operación de incremento o decremento se reali(a antes de usar el )alor de la )aria4le" Si el operador est% despus' primero se usa el )alor de la )aria4le y despus se reali(a la operación de incremento o decremento" > Los operadores relacionales se usan para e&presar condiciones y descri4ir una relación entre dos )alores" *I7APIXS ?' Z' ?' Z' Y' 3ayor +ue' 3enor +ue' 3ayor o igual +ue' 3enor o igual +ue' Igual +ue' #i5erente +ue" I5
El resultado de una e&presión relacional solo puede ser )erdadero o 5also' lo +ue en C se identi5ica con los )alores V. y . respecti)amente" La e&presión a4 se e)aluar% como . si a y 4 son di5erentes y como distinto de . si son iguales" 30
Act8an so4re e&presiones 4ooleanas' es decir' so4re )alores 6 o generados por e&presiones como las del caso anterior" Son los siguientes: U7APIXS Y' 7XT' *I7APIXS' __' A7#' @@' XP' Ej": ;. &y Y <.= \1
&yY 6
O
&
> Xperadores de tratamiento de 4its: C incorpora ciertas operaciones so4re 4its' propias del lenguaje ensam4lador' como despla(amientos o manipulación indi)idual de 4its" Los operadores +ue reali(an estas operaciones son los siguientes: h not *I7APIXS _ and @ or ` or e&clusi)o ?? despla(amiento a la derec9a ZZ despla(amiento a la i(+uierda Los operadores “and”' “or” y “not”' se rigen por la misma ta4la de )erdad +ue go4ierna los operadores lógicos e+ui)alentes" La di5erencia entre unos y otros 31
consiste en +ue estos tres act8an a ni)el de 4its indi)iduales y no so4re )alores completos <__' @@' Y=" Así' las )aria4les a y 4 almacenan respecti)amente los )alores a Y .&A,* * Y .&.. Las siguientes e&presiones se e)al8an de la 5orma: a__4 Y ,<6= a@@4 Y, <6= Ya Y . <= a_4 Y .&A.*. a@4 Y .&,* ha Y .&OE1# Los operadores _' @' h' . y not' son idnticos respecti)amente a las instrucciones del lenguaje ensam4lador and' or y not" Qor lo tanto' el operador and <_= permite poner ciertos 4its a . dejando el resto inalterado' y el operador not
a4ZZ1Y almacena en “a” el contenido de “4” despus de reali(ar un despla(amiento de “4” de 1 4its a la i(+uierda" Al igual +ue en el lenguaje ensam4lador' C distingue entre despla(amientos aritmticos y lógicos" El despla(amiento aritmtico lo 9acen so4re datos enteros y mantienen el signo" El despla(amiento lógico se reali(a so4re datos declarados como “sin signo” Xperadores de asignación: Las asignaciones se reali(an mediante el operador " El uso de este operador tiene ciertos aspectos +ue lo distinguen de otros lenguajes" Son los siguientes: En primer lugar' se puede emplear cual+uier n8mero de )eces en una e&presión' por ejemplo' a4c- &- y&<(0= El operador de asignación com4ina con los siguientes operadores: B' ' [' ' >' ZZ' ??' _' ' `' para operaciones acumulati)as" Ejemplo mBO e+ui)ale a mmBO
33
mO e+ui)ale a mmO my>-
e+ui)ale a mmy>-
m>
e+ui)ale a m m>
m??<B&,=e+ui)ale a mm??<B&,= I7STPUCCIX7ES #E ES > #E SALI#A: La instrucción de salida por e&celencia es QPI7T" 7os permite mostrar por pantalla desde una constante' ya sea una cadena' n8mero' 9asta una )aria4le de cual+uier tipo" ST#IX"K es la li4rería +ue contiene print5" Est%ndar inputoutput" El 5ormato de print5 es el siguiente:
print5<“cadena de control”' lista de )aria4les= Ejemplo: print5<“se 9a cometido un error”= Si +ueremos mostrar el )alor de una )aria4le por pantalla' 9acemos lo siguiente: print5<“El )alor de la )aria4le es: [d”' )ar= Lo +ue imprimiría por pantalla sería'
34
El )alor de la )aria4le es: Qrint5<“Los )alores de las )aria4les son: [d' [d' )ar,' )ar= Los )alores de las )aria4les son: -' O
TIQXS #E I#E7TIICA#XPES [#' [I Y toda )aria4le de5inida como int" Los n8meros enteros" [C Y con ella mostramos una )aria4le de tipo c9ar" [S Y nos permite representar una cadena de caracteres
escala <= y precisión <= ["5 si no me importa el n8mero de parte entera +ue sa+ue" Esto se llama 5las9 C^#I!XS #E CX7TPXL \ CX7STA7TES #E *APPA *APPA I76EPTI#A n Y a partir de este código se produce en la pantalla un salto de línea" nnn #E E7TPA#A: SCA7 tam4in est% en ST#IX"K" 7os sir)e para introducir datos por el teclado' cual+uier tipo de )aria4le" Su 5ormato es:
scan5<“cadena de control”' lista de )aria4les=
36
#entro de esta cadena' lo 8nico +ue nos admite son los identi5icadores <[d' [i' etc=' +ue son los mismos +ue en print5" scan5<[d”' _)aria4le= donde _ es dirección de <)aria4le=" Si no se pone esto' no lo 9ace toma )aria4le como dirección y no lo ejecuta correctamente" scan5”[d”' cadena= cadena . Y a+uí no se pone _' por +ue el nom4re del array de caracteres es un puntero a la posición del array
Un programa utilitario llamado ensam4lador es usado para traducir sentencias del lenguaje ensam4lador al código de m%+uina del computador o4jeti)o" El ensam4lador reali(a una traducción m%s o menos isomor5a
Qantalla de programa de ejemplo ,
38
Codigo del programa' se insertan las li4rerías correspondi entes' se iniciali(an las )aria4les y se muestran en pantalla con la instruccion cout"
39
Actividad :4 Esta)'ecer 'as re-'as para 'a conversi2n de tipos ;castin-< en e9presiones4 En la e)aluación se +uiere o4tener un )alor real' 9ay +ue 9acer un casting
E!e$p'o( Qara cam4iar el tipo de dato de los )alores resultantes de las siguientes e&presiones: O <)alor entero= ) <)alor entero= O". <)alor real= )9 O9 O". O " O"1 ". se puede escri4ir: < 5loat = O < 5loat = ) < int = O". < 5loat = ) 9 < 5loat = O 9 < int = O".
40
O < int = " < int = < O"1 ". = de tal 5orma +ue' los resultados de e)aluar las e&presiones anteriores son: O"...... <)alor real= 0"...... <)alor real= O <)alor entero= "......
•
•
•
Conversiones i$p'%citas: no se re+uiere una sinta&is especial por+ue la con)ersión se reali(a con seguridad de tipos y no se perder%n datos" Entre los ejemplos se incluyen las con)ersiones de tipos enteros de menor a mayor y las con)ersiones de clases deri)adas en clases 4ase" Conversiones e9p'%citas ;conversiones de tipos< : las con)ersiones e&plícitas re+uieren un operador de con)ersión" La con)ersión se re+uiere cuando es posi4le +ue se pierda in5ormación en el proceso o cuando esta puede no reali(arse correctamente por otras ra(ones" Entre los ejemplos 9a4ituales se incluye la con)ersión en un tipo con menor precisión o un inter)alo menor' y la con)ersión de una instancia de clase 4ase en una clase deri)ada" Conversiones de&inidas por e' *s*ario : las con)ersiones de5inidas por el usuario se reali(an a tra)s de mtodos especiale s +ue puede de5inir para 9a4ilitar las con)ersiones e&plícitas e implícitas entre tipos personali(a dos +ue no tienen una relación de clase 4ase>clase deri)ada" Conversiones con c'ases a*9i'iares : para reali(ar con)ersiones entre tipos no compati4les' como los enteros y los o4jetos System"#ateTime' o 4ien cadenas 9e&adecimales y matrices de 4ytes' puede utili(ar la clase System"*itCon)erter' la claseSystem"Con)ert y los mtodos Parse de los tipos numricos integrados' como Int-"Qarse"
41
Conversiones i$p'%citas En los tipos numricos integrados' puede reali(arse una con)ersión implícita cuando el )alor +ue se )a a almacenar puede ajustarse a la )aria4le sin necesidad de truncamiento o redondeo" Qor ejemplo' una )aria4le de tipo long
En los tipos de re5erencia' siempre e&iste una con)ersión implícita desde una clase a cual+uiera de sus inter5aces o clases 4ase' directas o indirectas" 7o se re+uiere una sinta&is especial ' ya +ue una clase deri)ada siempre contiene todos los miem4ros de una clase 4ase" +erived d ) ne* +erived (!; Jase b ) d; "" -l*a$s KL.
Conversiones e9p'%citas Sin em4argo' si no se puede reali(ar una con)ersión sin riesgo de perder in5ormación' el compilador re+uiere +ue se realice una con)ersión e&plícita' denominada conersión de tipo" Una con)ersión de tipo es una manera de in5ormar de puede 5orma e&plícita reali(ar con)ersión +ue est% alalcompilador tanto de +ue producir de se +ue una pretende prdida de datos"la Qara reali(ary una con)ersión de tipo' especi5i+u e entre parntesis el tipo al +ue se )a a aplicar dic9a con)ersión delante del )alor o la )aria4le +ue se )a a con)ertir" El programa siguiente con)ierte un tipo dou4le a un tipo int" El programa no se compilar% sin el operador de con)ersión de tipo" C[ class Mest { static void :ain(! { double x ) 1DC4.F; int a; "" Nast double to int. a ) (int!x; S$stem.Nonsole.Orite,ine(a!; "" Kutput 1DC4
42
En los tipos de re5erencia' se re+uiere una con)ersión e&plícita si de4e con)ertir de un tipo 4ase a un tipo deri)ado: C[ "" Nreate a ne* derived t$pe. iraffe g ) ne* iraffe(!; "" Implicit conversion to base t$pe is safe. -nimal a ) g; "" #xplicit conversion is re>uired to cast back "" to derived t$pe. ote M/is *ill compile but *ill "" t/ro* an exception at run time if t/e rig/t0side "" object is not in fact a iraffe. iraffe gD ) (iraffe! a;
Una operación de con)ersión entre tipos de re5erencia no cam4ia el tipo en tiempo de ejecución del o4jeto su4yacente solo cam4ia el tipo del )alor +ue se utili(a como re5erencia para ese o4jeto"
E9cepciones de 'as conversiones de tipos en tie$po de e!ec*ci2n En algunas con)ersiones de tipos de re5erencia' el compilador no puede determinar si ser% )%lida una con)ersión de tipo" Es posi4le +ue una operación de con)ersión de tipo +ue se compila correctamente pro)o+ue un error en tiempo de ejecución" Como se muestra en el ejemplo siguiente' una con)ersión de tipo +ue origine unIn)alidCastE&ception" error en tiempo de ejecución 9ar% +ue se produ(ca una e&cepción
using S$stem; class -nimal { public void #at(! { Nonsole.Orite,ine(%#ating.%!; public override string MoString(! { return %I am an animal.%; class Qeptile -nimal { class :ammal -nimal { class RnSafeNast {
43
static void :ain(! { Mest(ne* :ammal(!!; "" Leep t/e console *indo* open in debug mode. S$stem.Nonsole.Orite,ine(%Press an$ ke$ to exit.%!; S$stem.Nonsole.QeadLe$(!; static void Mest(-nimal a! { "" Nause InvalidNast#xception at run time "" because :ammal is not convertible to Qeptile. Qeptile r ) (Qeptile!a;
44
Actividad =4 A-re-ar acciones se$#nticas a 'a e str*ct*ra de 'a -ra$#tica4 Un es+uema de traducción es una gram%tica independiente del conte&to en la cual se 9an insertado 5ragmentos de código en las partes derec9as de sus reglas de producción" Los 5ragmentos de código así insertados se denominan acciones sem%nticas" #ic9os 5ragmentos act8an' calculan y modi5ican los atri4utos asociados del %r4ol sint%ctico" El orden en +ue se e)al8an los 5ragmentoscon es ellosdenodos un recorrido primero>pro5undo del %r4ol de an%lisis sint%ctico" X4sr)ese +ue' en general' para poder aplicar un es+uema de traducción 9ay +ue construir el %r4ol sint%ctico y despus aplicar las acciones empotradas en las reglas en el orden de recorrido primero>pro5undo" Qor supuesto' si la gram%tica es am4igua una 5rase podría tener dos %r4oles y la ejecución de las acciones para ellos podría dar lugar a di5erentes resultados" Si se +uiere e)itar la multiplicidad de resultados
La acción se ejecutar% despus de todas las acciones asociadas con el recorrido del su4%r4ol de y antes +ue todas las acciones asociadas con el recorrido del su4%r4ol
"
El siguiente es+uema de traducción reci4e como entrada una e&presión en in5ijo y produce como salida su traducción a post5ijo para e&presiones aritmticas con sólo restas de n8meros:
Las apariciones de )aria4les sint%cticas en una regla de producción se inde&an como se )e en el ejemplo' para distinguir de +ue nodo del %r4ol de an%lisis 45
estamos 9a4lando" Cuando 9a4lemos del atri4uto de un nodo utili(aremos una inde&ación tipo 9as9" A+uí 6AL es un atri4uto de los nodos de tipo denotando su )alor numrico y para accederlo escri4iremos 7U3D6ALF" An%logamente e&prDTPAF denota el atri4uto bbtraducción de los nodos de tipo
.
En este ejemplo' el cómputo del atri4uto e&prD TPAF depende de los atri4utos en los nodos 9ijos' o lo +ue es lo mismo' depende de los atri4utos de los sím4olos en la parte derec9a de la regla de producción" Esto ocurre a menudo y moti)a la siguiente de5inición: Un atri4uto tal +ue su )alor en un nodo puede ser computado en trminos de los atri4utos de los 9ijos del nodo se dice +ue es un atri4uto sinteti(ado" Un ejemplo de atri4uto 9eredado es el tipo de las )aria4les en las declaraciones:
Un atri4uto 9eredado es a+uel cuyo )alor se computa a partir de los )alores de sus 9ermanos y de su padre" Escri4a un es+uema de traducción +ue con)ierta e&presiones en in5ijo con los operadores >B<= y n8meros en e&presiones en post5ijo" E&pli+ue el signi5icado de los atri4utos elegidos"
E!e$p'os de 'a actividad dos pacage toens import ja)a"util"B BB B B aut9or In)itado 46
B pu4lic class Toens D static String linea V-2B-V usando delimitadores y regresandolos como toens static StringToeni(er toens- neW StringToeni(erBV' true= static 5inal int 7U3EPX. static 5inal int XQEPA#XP, static String le&emaVV pu4lic static int le&ico<= D i5 V=@@le&ema"e+uals
pu4lic static )oid main
B separacion de toens con StringToeni(er usando el espacio por de5ecto como separador de toens StringToeni(er toens neW StringToeni(er
W9ile
esultados del programa ejecutado D muestra los toens utilizados en este mismo código.
48
Ejemplo : B B To c9ange t9is license 9eader' c9oose License Keaders in Qroject Qroperties" B To c9ange t9is template 5ile' c9oose Tools @ Templates B and open t9e template in t9e editor" B pacage ta4la"de"toens import ja)a"util"B BB B B aut9or In)itado B pu4lic class Ta4la#eToens D
pu4lic static class ElementoTs elemento de la ta4la de sim4olos' D String le&ema a+ui de4emos poner todos los atri4utos +ue +ueremos usar en el compilador int longitud*ytes pu4lic ElementoTs
a partir de a+ui ponemos todos los
D t9is"le&emal 49
F pu4lic String getLe&ema<= D return t9is"le&ema F F pu4lic static 5inal int p- el tama$o del arreglo de 9as9
LinedListZElementoTs?J listaLigada
listaLigadaiJ neW LinedListZElementoTs?<= B iniciali(amos el arreglo de listas ligadasB creamos datos de prue4a ElementoTs aneW ElementoTs
calculamos 5uncion de 9as9
5or
ts"put
Ejecución de una acción sem%ntica del programa que busca y analiza Toens en su código %uente
Ejemplo -: using System; using System.Collections.ene!ic; using System.&in'; using System.(e)t; using System.(*!eading.(as+s; using System.(e)t.,egula!-)"!essions; names"ace analiado!le)ico class,ege)&e)e! ,ege) !e); St!ingVuilde! "at!on; ool !e'uie!eCom"ila!; &istst!ing< (Lames; intGJ Lume!s; "ulic ,ege)&e)e!
52
!e'uie!eCom"ila! : t!ue; (Lames : ne%&istst!ing<; EEEsumma!y< EEE Ag!ega una nueva !egla "a!a !econoce! to+en EEEEsumma!y< [email protected]@> @C#-L(A,2@ EEE"a!am name:@"atte!n@<"at!Wn en el 'ue dee enca=a!E"a!am< EEE"a!am name:@to+enname@ st!ing to+enname> ool igno!e : alse i st!ing.sLull!*iteS"aceto+enname t*!o%ne%A!gument-)ce"tionst!ing./o!mat@0 no es un nom!e vYlido.@> to+enname; i st!ing.sLull!-m"ty"atte!n t*!o%ne%A!gument-)ce"tionst!ing./o!mat@-l "at!Wn 0 no es vYlido.@> "atte!n; i "at!on :: null "at!on : ne%St!ingVuilde!st!ing./o!mat@M0<1@> to+enname> "atte!n; else "at!on.A""endst!ing./o!mat@OM0<1@> to+enname> "atte!n; i Rigno!e (Lames.Addto+enname; !e'uie!eCom"ila! : t!ue; EEEsumma!y< EEE ,einicia el &e)e! EEEEsumma!y< "ulicvoid ,eset !e) : null; "at!on : null; !e'uie!eCom"ila! : t!ue; (Lames.Clea!; Lume!s : null; EEEsumma!y< EEE Analisa una ent!ada en usca de to+ens validos y e!!o!es EEEEsumma!y< EEE"a!am name:@te)t@ llame al mZtodo Com"ileo"tions.@; #atc* matc* : !e).#atc*te)t; i Rmatc*.Success yield!ea+; int line : 1> sta!t : 0> inde) : 0; %*ile matc*.Success
53
i matc*.nde) < inde) st!ing to+en : te)t.Sust!inginde)> matc*.nde) H inde); yield!etu!nne%(o+en@-,,,@> to+en> inde)> line> inde) H sta!t F 1; line F: CountLe%&inesto+en> inde)> !e sta!t; o! int i : 0; i Lume!s.&engt*; iFF i matc*.!ou"sGLume!sGiJJ.Success st!ing name : !e).!ou"Lame/!omLume!Lume!sGiJ; yield!etu!nne%(o+enname> matc*.alue> matc*.nde)> line> matc*.nde) H sta!t F 1; !ea+; line F: CountLe%&inesmatc*.alue> matc*.nde)> !e sta!t; inde) : matc*.nde) F matc*.&engt*; matc* : matc*.Le)t#atc*; i te)t.&engt* < inde) yield!etu!nne%(o+en@-,,,@> te)t.Sust!inginde)> inde)> line> inde) H sta!t F 1; EEEsumma!y< EEE C!ea el A/L con los "at!ones estalecidos EEEEsumma!y< "ulicvoid Com"ile,ege)"tions o"tions i "at!on :: null t*!o%ne%-)ce"tion@Ag!ege uno o mYs "at!ones> llame al mZtodo Add(o+en,ule"atte!n> to+enname.@; i !e'uie!eCom"ila! t!y !e) : ne%,ege)"at!on.(oSt!ing> o"tions; Lume!s : ne%intG(Lames.CountJ; st!ingGJ gn : !e).et!ou"Lames; o! int i : 0> id) : 0; i gn.&engt*; iFF i (Lames.ContainsgnGiJ Lume!sGid)FFJ : !e).!ou"Lume!/!omLamegnGiJ;
54
!e'uie!eCom"ila! : alse; catc* -)ce"tion e) t*!o% e); EEEsumma!y< EEE Cuenta la cantidad de lineas "!esentes en un to+en> estalece el inicio de linea. EEEEsumma!y< "!ivateint CountLe%&inesst!ing to+en> int inde)> !eTnt linesta!t int line : 0; o! int i : 0; i to+en.&engt*; iFF i to+enGiJ :: NnN lineFF; linesta!t : inde) F i F 1; !etu!n line;
Se muestra el compilador donde introducimos un código y nos muestra los toens y le&emas" X4ser)amos +ue en la parte superior Compilador G el n8mero de toen > el n8mero de error" Qodemos o4ser)ar +ue nos marca un error y es de4ido a +ue declaramos una )aria4le pero empe(ando con un n8mero
55
Actividad >4 Manip*'ar 'a ta)'a de conversi2n de s%$)o'os " de errores " direcciones4 Se le llama ta4la de nom4res o ta4la de identi5icadores y tiene dos 5unciones principales: > E5ectuar c9e+ueos sem%nticos" > !eneración de código" Qermanece sólo en tiempo de compilación' no de ejecución' e&cepto en a+uellos casos en +ue se compila con opciones de depuración" La ta4la almacena la in5ormación +ue en cada momento se necesita so4re las )aria4les del programa' in5ormación tal como: nom4re' tipo' dirección de locali(ación' tama$o' etc" La gestión de la ta4la de sím4olos es muy importante' ya +ue consume gran parte del tiempo de compilación" #e a9í +ue su e5iciencia sea crítica" Aun+ue tam4in sir)e para guarda in5ormación re5erente a los tipos creados por el usuario' tipos enumerados y' en general' a cual+uier identi5icador creado por el usuario' nos )amos a centrar principalmente en las )aria4les de usuario" Pespecto a cada una de ellas podemos guardar: Glmacenamiento del nombre. Se puede 9acer con o sin límite" Si lo 9acemos con límite' emplearemos una longitud 5ija para cada )aria4le' lo cual aumenta la )elocidad de creación' pero limita la longitud en unos casos' y desperdicia espacio en la guardar mayoría"elXtro mtodo es 9a4ilitar la memoria +ue necesitemos en cada caso para nom4re" En C esto es 5%cil con los c9ar B" Si 9acemos el compilador en 3X#ULA>' por ejemplo' 9a4ría +ue usar el tipo A##PESS" El tipo tam4in se almacena en la ta4la' como )eremos en un apartado dedicado a ello" Airección de memoria en que se guardará" Esta dirección es necesaria' por+ue las instrucciones +ue re5erencian a una )aria4le de4en sa4er dónde encontrar el )alor de esa )aria4le en tiempo de ejecución' tam4in cuando se trata de )aria4les glo4ales" En lenguajes +ue no permiten recursi)idad' las direcciones se )an asignando secuencialmente a medida +ue se 9acen las declaraciones" En lenguajes con estructuras de 4lo+ues' la dirección se da con respecto al comien(o del 4lo+ue de datos de ese 4lo+ue' <5unción o procedimiento= en concreto" El n*mero de dimensiones de una ariable array# o el de parámetros de una %unción o procedimiento junto con el tipo de cada uno de ellos es 8til para el
56
c9e+ueo sem%ntico" Aun+ue esta in5ormación puede e&traerse de la estructura de tipos' para un control m%s e5iciente' se puede indicar e&plícitamente" Tam4in podemos guardar in5ormación de los n*meros de l&nea en los que se 'a usado un identi%icador# y de la l&nea en que se declaró "
Consideraciones sobre la Tabla de Símbolos.
&a tala de s\molos "uede inicia!se con cie!ta ino!maciWn Xtil> tal como H Constantes D> -> etc. H /unciones de li!e!\a -]D> &> etc. H Dala!as !ese!vadas. Esto 5acilita el tra4ajo al le&icogr%5ico' +ue tras reconocer un identi5icador lo 4usca en la ta4la de sím4olos' y si es pala4ra reser)ada de)uel)e un toen asociado" *ien estructurado ser una alternati)a m%s e5iciente al le& tal y como lo 9emos )isto <9as9 puede per5ecto=" Con5orme )an apareciendo nue)as declaraciones de identi5icadores' el anali(ador l&ico' o el anali(ador sint%ctico seg8n la estrategia +ue sigamos' insertar% nue)as entradas en la ta4la de sím4olos' e)itando siempre la e&istencia de entradas repetidas" El anali(ador sem%ntico e5ect8a las compro4aciones sensi4les al conte&to gracias a la ta4la de sím4olos' y el generador de código intermedio usa las direcciones de memoria asociada a cada identi5icador en la ta4la de sím4olos' al igual +ue el generador de código" El código no necesita 9acer uso del optimi(ador"
57
6amos a 9acer un intrprete" Pecordar +ue en un intrprete la entrada es un programa y la salida es la ejecución de ese programa"
Su"onemos 'ue 'ue!emos *ace! las siguientes o"e!aciones a:7K3 :3Ka En la segunda instrucción necesitamos sa4er cu%nto )ale ka es decir el )alor de ka de4e estar guardado en alg8n sitio" Qara ello utili(aremos una lista de pares:
de 5orma +ue cuando nos encontremos con la instrucción a N B -' miremos en la ta4la' si no est% ka en la ta4la' creamos un nodo para introducirla"
A continuación' nos encontramos con 4 - B a" u es ka] *usco en la ta4la de sím4olos y )emos +ue el )alor de ka es ," 4 - B a A9ora 4uscamos 4 en la ta4la de sím4olos y como no est% lo creamos"
58
Si ejecut%ramos a9ora la instrucción: a a 4 Tendríamos a ka y k4 en la ta4la de sím4olos con lo cual solo tendríamos +ue modi5icar el )alor de ka"
Como 9emos dic9o una ta4la de sím4olos es una estructura +ue almacena in5ormación relati)a a los identi5icadores de usuario" Qero' u in5ormación e&actamente]' seg8n el propósito +ue tengamos" En nuestro caso el propósito es 9acer un intrprete y nos interesa mantener in5ormación' entre otras cosas' del )alor de cada )aria4le"
Ejemplo ,: pacage ta4lasim4olos import ja)a"util"B pu4lic class Ta4laSim4olos D pu4lic static class ElementoTs elemento de la ta4la de sim4olos' D String le&ema a+ui de4emos poner todos los atri4utos +ue +ueremos usar en el compilador int longitud*ytes pu4lic ElementoTs
pu4lic static int 9
Ingresamos datos
60
System"out"println
En este ejemplo se muestra como el ejemplo , pide una le&ema y esta es procesada e indica +ue est% en la lista de le&emas aceptadas"
Ejemplo : pacage ta4lasim4olos import ja)a"util"B pu4lic class Ta4laSim4olos D pu4lic static class ElementoTs elemento de la ta4la de sim4olos' D String le&ema a+ui de4emos poner todos los atri4utos +ue +ueremos usar en el compilador int longitud*ytes pu4lic ElementoTs
a partir de a+ui ponemos todos los
61
D t9is"le&emal F pu4lic String getLe&ema<= D return t9is"le&ema F F pu4lic static 5inal int p- el tama$o del arreglo de 9as9
Ingresamos datos
A9ora una 4us+ueda String le&ema.,le&ema le&ema a 4uscar int 4uscar9
En este ejemplo se muestra como el ejemplo , pide una le&ema y esta es procesada e indica +ue no est% en la lista de le&emas aceptadas"
Ejemplo -: pacage ta4lasim4olos import ja)a"util"B pu4lic class Ta4laSim4olos D pu4lic static class ElementoTs elemento de la ta4la de sim4olos' D
63
String le&ema a+ui de4emos poner todos los atri4utos +ue +ueremos usar en el compilador int longitud*ytes pu4lic ElementoTs
le&emaEntrada"ne&tLine<=
Ingresamos datos
Se muestra un determinado le&ema cargada por de5ecto y su procesamiento indica la lista donde se encontró"
65
Actividad ?4 Inte-rar e@*ipos de tra)a!o para 'a constr*cci2n de *n ana'iador se$#ntico4 Se reali(ar% la construcción de un anali(ador sem%ntico' para lo cual se utili(ar% un e+uipo integrado por 0 personas" Qara reali(ar este tra4ajo utili(aremos el mtodo de la in)estigación Cientí5ica el cual consiste en: La serie de pasos +ue conducen a la 48s+ueda de conocimientos mediante la aplicación de mtodos y tcnicas" Son las in)estigaciones +ue pretenden darnos una )isión general de tipo apro&imati)o respecto a una determinada realidad" Este tipo de in)estigación se reali(a especialmente cuando el tema elegido 9a sido poco e&plorado y reconocido' y cuando a8n' so4re l es di5ícil 5ormular 9ipótesis precisas o de cierta generalidad" Suelen surgir tam4in cuando aparece un nue)o 5enómeno' +ue precisamente por su no)edad' no admite toda)ía una descripción sistem%tica' o cuando los recursos +ue dispone el in)estigador resultan insu5icientes como para emprender un tra4ajo m%s pro5undo" #e esta 5orma y organi(%ndonos' asignando a cada uno del e+uipo' lle)ar a ca4o el proyecto y terminarlo con una resolución optima y +ue satis5aga las necesidades +ue se 4uscan"
66
Actividad 4 Prop*esta de pro"ecto para e' ana'iador 'B9ico " sint#ctico4 Re-'as de' co$pi'ador( •
•
Crear un primer compilador +ue sólo recono(ca una orden muy simple' a)ise en caso de error" Ampliar nue)amente para +ue 5uerce a una estructura de programa concreta
•
• •
•
•
•
•
A$adir la posi4ilidad de declarar y usar )aria4les" A$adir )aria4les de m%s de un tipo de la mate!ia lengua=es y autWmatas > es el !ealia! un com"ilado!> el cual toma!a una se!ie de comandos o alaetos "a!a !ealia! una unciWn ya "!e estalecido y log!a! nuest!o o=etivo> el cual es 'ue se log!e sin ningXn inconveniente. -ste "!oyecto se !ealia!Y "a!a 'ue de una o!ma Ycil y sencilla se lean las cadenas de los alaetos y lleva! a cao la com"ilaciWn de estos. Los ins"i!amos en la necesidad de !ealia! un com"ilado! de alaetos y !ealia! lo 'ue nosot!os le *allamos "uesto> Da!a "ode! log!a! nuest!o o=etivo "!ime!o se *a!Y una investigaciWn "!ounda de 'ue es o de 'ue t!ata un com"ilado! y como ayuda en nuest!a mate!ia. Los dividi!emos el t!aa=o "a!a avana! de o!ma a"!esu!ada y con !esultados W"timos 'ue se medi!Yn de acue!do a valo!es 'ue nosot!os le "ond!emos> "a!a sae! el avance del "!oyecto.
Objetivos:
_Estudiar el funcionamiento de los compiladores. _Diseñar un compilador e implementarlo. Intérpretes y Compiladores:
El presente proyecto como su nombre lo indica pretende estudiar a los Interpretes y Compiladores. Sin embargo, estas palabras " Interpretes y Compiladores ", dicen mucho y a la ve no dicen nada. !odos nosotros alguna ve estuvimos en contacto con ellos, y en algn momento nos preguntamos c#mo funcionan. $ero
67
muy pocos nos sentamos a tratar de entender su mec%nica, su funcionamiento y ver los conceptos &ue est%n ocultos detr%s de ellos. Digo ocultos por&ue es de mi conocimiento, &ue estos conceptos son tales, &ue no se me hubieran ocurrido &ue forman parte de la teor'a &ue engloba a los Interpretes y Compiladores. (os principios y t)cnicas de escritura de Interpretes y Compiladores comprende los conceptos de* los lengua+es de programaci#n, la ar&uitectura de computadores, la teor'a de lengua+es, los algoritmos, la ingenier'a de Softare, como as' tambi)n tener pleno conocimiento de las distintas plataformas e-istentes, de las t)cnicas de programaci#n lineales, estructuradas, orientadas a ob+etos, a eventos y paralelas /, y de los distintos 0ardare, tanto desde el punto de vista de un programador como al nivel en &ue interactan sus componentes internos, para poder obtener de ellos la mayores prestaciones posibles. 1dem%s, el tener conocimiento de lo &ue es una ma&uina abstracta, su relaci#n con la gram%tica y muchos otros conceptos. 0ay &ue destacar &ue el estudio te#rico &ue a&u' se realiara, es una importante base para la investigaci#n y desarrollo de aplicaciones en las cuales el an%lisis de patrones este muy vinculadas con ellas, como por e+emplo 2ases de Datos, Desarrollo de herramientas 3rientadas a 3b+etos, 4raficadores, $rocesadores de !e-to, 5ormatos de 1rchivos, !raductores, 1naliadores ()-icos, 1naliadores Sint%cticos, por supuesto Interpretes y Compiladores y muchas otras aplicaciones. 1dem%s, haciendo uso de los conceptos de la !eor'a 4eneral de Sistemas y los de una ma&uina abstracta, en particular las denominada 1ut#matas !raductores, se puede llegar a la implementaci#n de un sistema como un aut#mata, &ue ante la lectura de patrones entrada de datos/ reacciona con una traducci#n salida de datos/. Es por todo esto y por una curiosidad propia &ue he decido realiar este proyecto.
P'ani&icaci2n de Actividades( O)!etivos( Pri$era etapa( fEstudiar el concepto de !ram%ticas Pegular" fEstudiar el 5uncionamiento de un Autómata inito" 68
fX4ser)ar la dualidad y correspondencia entre una !ram%ticas Pegular y un Autómata inito" f#esarrollar los algoritmos de un Autómata inito" fEstudiar el concepto de un Anali(ador L&ico"
Se-*nda etapa( fEstudiar los conceptos de !ram%ticas de Conte&to Li4re" fEstudiar el 5uncionamiento de un Autómata a Qila" fX4ser)ar la dualidad y correspondencia entre una !ram%ticas de Conte&to Li4re y un Autómata a Qila" f#esarrollar los algoritmos de un Autómata a Qila" fEstudiar el concepto de un Anali(ador Sint%ctico"
Tercera etapa( fEstudiar el concepto y el 5uncionamiento de un Anali(ador Sem%ntico" fEstudiar el concepto y el 5uncionamiento de un !enerador de Código Intermedio" f#esarrollar los algoritmos para la implementación de un Anali(ador Sem%ntico y un !enerador de Código"
C*arta etapa( fEstudiar el concepto y el 5uncionamiento de un Xptimi(ador de Código Intermedio" fEstudiar el concepto y el 5uncionamiento de un !enerador de Código" f#esarrollar los algoritmos para la implementación de un Xptimi(ador de Código intermedio y un !enerador de Código" f#esarrollar los algoritmos para la implementación de un Intrprete" 69
*inta etapa( fEstudiar el concepto y el 5uncionamiento de un Compilador" fEstudiar el concepto y el 5uncionamiento de un Compilador en el an%lisis de un proyecto como un Traductor Interacti)o" f#esarrollar los algoritmos para la implementación de un Compilador" f#esarrollar los algoritmos para la implementación de un entorno integrado E#I de un compilador"
70
Conc'*siones En conclusión con estas acti)idades dimos la introducción a Autómatas' conocimos sus conceptos principales los cuales son al5a4eto' cadenas y lenguaje donde e&plica cómo se con5orma cada uno de estos' para la creación de un compilador primero tendremos +ue crear ciertas 5ases del compilador ya +ue cada una de estas tiene una determina tarea y se tiene +ue ejecutar correctamente' es decir' +ue no 9aya un error y prosiga con la siguiente 5ase 9asta llegar a la 8ltima 5ase para completar una compilación correcta" \ con la propuesta del proyecto' se o4ser)ó las características y reglas +ue se de4en cumplir" Como resultado de las acti)idades reali(adas es posi4le concluir +ue en el %rea de la programación las e&presiones regulares son un mtodo por medio del cual se pueden reali(ar 48s+uedas dentro de cadenas de caracteres" Sin importar la amplitud de la 48s+ueda re+uerida de un patrón de5inido de caracteres' las e&presiones regulares proporcionan una solución pr%ctica al pro4lema" Qara poder crear EP es necesario conocer la estructura de las mismas"
71
Viliog!a\a Ceballos, F. J. (2007). Enciclopédia de Microsoft Visual C#. 2da Edicion. Espaa! "aM$. %opcroft, J. E. (2007). &eoria de auto'atas, enua*es + Co'putacion . Madrid, Espaa! E"-/ . ttp!11.ra'aticas.net120321041e*e'plosdeanalisisse'antico.t'l ttp!11cideca'e.uae.edu.'51lcc1'apa1"6EC&1libro21autocontenido1autoc on18499errores9se'nticos.t'l ttp!11cideca'e.uae.edu.'51lcc1'apa1"6EC&1libro21autocontenido1autoc on1339'ane*o9de9los9errores9sintcticos.t'l
C,S(AL B&&-,# A,C^A. 2012. "e!ado!es. 2014> de Bnive!sidad $ist!ital !ancisco _osZ de Caldas Sitio %e *tt"EE"!oeso!es.TH .unam.m)Eca!losElc"iE"09ED-,A$,-SQ20-LQ20Q20CFF."d _esXs egas. 2012. dentiTcado!es> "e!ado!es y -)"!esiones. 2015> de $"to. no!mYtica Bnive!sidad de alladolid Sitio %e *tt"EE%%%.ino!.uva.esE`=vegasEcu!sosE"!ogEtema3.*tml icente Ven=umea y #anuel ,oldYn. 2016. /undamentos de D!og!amaciWn con el &engua=e de D!og!amaciWn CFF. 2016> de BL-,S$A$ $- #&AA $"to. &engua=es y CC. Com"utaciWn -.(.S.. no!mYtica Sitio %e *tt"EE%%%.lcc.uma.esE`vicenteEdocenciaEc""docE"!og!amacionc))."d ilde! B!ae. 2005. Constantes> va!iales y e)"!esiones. 2016> de desa!!ollo %e Sitio %e *tt"EE%%%.desa!!ollo%e.comEa!ticulosE2164."*"
72
