Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Laboratorio de Sintaxis y Semántica de los Lenguajes

No description
by

Javier delgado

on 22 October 2012

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Laboratorio de Sintaxis y Semántica de los Lenguajes

Funciones de validación Universidad Tecnológica Nacional
Facultad Regional Tucumán Sintaxis y Semántica de los Lenguajes ACTIVIDAD DE LABORATORIO Nº 1 2012 Comisión 2K1 - Profesor Ing. Jorge Buabud ACTIVIDADES A DESARROLLAR Operaciones con lenguajes finitos Sistema Canónico de Donovan Unión, Diferencia, Intersección, Complemento, Concatenación,
Potencia, Estrella de Kleene, Estrella Positiva, Inversa Operaciones con lenguajes finitos Para las sentencias “goto” 1) 2) Operaciones sobre palabras Funciones sin validación usadas
para operaciones internas Operaciones disponibles sobre lenguajes
(con la validación de datos solicitada) ESTRUCTURA
DEL
PROGRAMA Operaciones sobre palabras concatenarPalabras :: String -> String -> String concatenarPalabras x y = x ++ y invertirPalabra :: String -> String
invertirPalabra [] = []
invertirPalabra (x:xs) = invertirPalabra xs ++ [x] longitud :: String -> Int
longitud [] = 0
longitud (x:xs) = 1 + longitud xs Funciones de Validación eliminarRepetidos :: [String] -> [String]
eliminarRepetidos x = nub x validarPalabra [] = True
validarPalabra (x:xs) = ( elem x ['a'..'z'] )
&& ( validarPalabra xs ) Comprueba que la palabra está sobre el alfabeto ∑={a,b,c,...,z} validarPalabra :: String -> Bool Funciones de Validación validarLenguaje :: [String] -> Bool





validarLenguaje [] = True
validarLenguaje (x:xs)
| length ( eliminarRepetidos((x:xs)) ) <= 20 = (validarPalabra x ) && ( validarLenguaje xs )
| otherwise = False Comprueba que la cantidad de palabras distintas de un lenguaje sea menor o igual a 20, y valida cada palabra del mismo (∑={a,b,c,...,z}) Funciones sobre Lenguajes concatenarLenguajes :: [String] -> [String] -> [String]
concatenarLenguajes x y | validarLenguaje x && validarLenguaje y =
concatenarLenguajesSV x y
| otherwise = ["Lenguaje/s No Valido/s"] Se comprueba que ambos lenguajes sean correctos.
La función Concatenar Lenguajes sin Validación concatena todas las palabras del lenguaje x con todas las palabras del lenguaje y. concatenarLenguajesSV :: [String] -> [String] -> [String] concatenarLenguajesSV x y =
eliminarRepetidos ( [concatenarPalabras c d| c<-x , d<-y ] ) Funciones de Validación validarAlfabeto :: [String] -> Bool






validarAlfabeto [] = True
validarAlfabeto (x:xs)
| length x == 1 = ( validarPalabra x )
&& ( validarAlfabeto xs )
| otherwise = False Comprueba que los símbolos del alfabeto sean de longitud 1 y mediante la función validarPalabra comprueba que sean letras del alfabeto (a,b,..,z). Funciones sobre Lenguajes Se comprueba que el lenguaje sea correcto.
La función invertir Lenguaje sin validación utiliza invertirPalabra, que toma la primera letra de la palabra y la lleva al final de la misma, así para cada letra. invertirLenguaje :: [String] -> [String]
invertirLenguaje x | validarLenguaje x = invertirLenguajeSV x
| otherwise = ["Lenguaje No Valido"] invertirLenguajeSV :: [String] -> [String]
invertirLenguajeSV x = eliminarRepetidos ( [ invertirPalabra y | y <- x ] ) 1) Operaciones con lenguajes Requerimientos de operaciones Para el alfabeto suponga como rango válido las letras del alfabeto inglés.
Para validar los lenguajes debe considerar el alfabeto leído, con una cantidad máxima de palabras igual a 20. Considerar como casos particulares el lenguaje vacío y el lenguaje que contiene solo la palabra vacía. invertirPalabra :: String -> String
invertirPalabra [] = []
invertirPalabra (x:xs) = invertirPalabra xs ++ [x] Funciones sobre Lenguajes Se comprueba que ambos lenguajes sean correctos.
La función Unión de lenguajes sin validación utiliza el operador "++" para realizar la unión de los lenguajes. Luego se eliminan los repetidos unionLenguajes :: [String] -> [String] -> [String]
unionLenguajes x y | validarLenguaje x && validarLenguaje y
= unionLenguajesSV x y
| otherwise = ["Lenguaje/s No Valido/s"] Unión, Diferencia, Intersección, Complemento, Concatenación, Potencia, Estrella de Kleene, Estrella Positiva, Inversa Requerimientos de validación Requerimientos de resultados unionLenguajesSV :: [String] -> [String] -> [String]
unionLenguajesSV x y = eliminarRepetidos ( x ++ y ) Para aquellas operaciones que pueden arrojar resultados infinitos, introducir la cantidad X de palabras, ordenadas por longitud, que se desea obtener.Suponer rango válido para X el intervalo [1..20]. eliminarRepetidos :: [String] -> [String]
eliminarRepetidos x = nub x Lenguaje escogido:
Haskell Funciones sobre Lenguajes Se comprueba que ambos lenguajes sean correctos.
La función intersección sin validación "incluye" una palabra en el lenguaje generado si esta pertenece al lenguaje x, y también al lenguaje y. Funciones de Validación validarPalabraAlfabeto :: String -> [String] -> Bool





validarPalabraAlfabeto [] a = True

validarPalabraAlfabeto (x:xs) a =
(elem [x] a) && (validarPalabraAlfabeto xs a)
Dada una palabra comprueba que la misma esté definida sobre el alfabeto ingresado interseccionLenguajes :: [String] -> [String] -> [String]
interseccionLenguajes x y | validarLenguaje x &&
validarLenguaje y = interseccionSV x y
| otherwise = ["Lenguaje/s No Valido/s"] interseccionSV :: [String] -> [String] -> [String]
interseccionSV x y =
eliminarRepetidos ( [ z | z <- x, pertenece z x , pertenece z y ] ) Funciones sobre Lenguajes Se comprueba que ambos lenguajes sean correctos.
La función diferencia sin validación incluye en el lenguaje generado todas las palabras que pertenecen a x, pero no pertenecen a y. diferenciaLenguajes :: [String] -> [String] -> [String]
diferenciaLenguajes x y | validarLenguaje x &&
validarLenguaje y = diferenciaSV x y
| otherwise = ["Lenguaje/s No Valido/s"] Funciones de Validación validarLenguajeAlfabeto :: [String] -> [String] -> Bool





validarLenguajeAlfabeto [] a = True

validarLenguajeAlfabeto (x:xs) a =
(validarPalabraAlfabeto x a)
&& (validarLenguajeAlfabeto xs a)
Valida cada palabra del lenguaje con el alfabeto dato mediante la función validarPalabraAlfabeto diferenciaSV :: [String] -> [String] -> [String]
diferenciaSV x y = eliminarRepetidos ( [ z | z <- x, not ( pertenece z y ) ] ) Funciones sobre Lenguajes Se comprueba que el lenguaje sea correcto.
La función potencia sin validación eleva el lenguaje x a una n Funciones de Validación pertenece :: String -> [String] -> Bool





pertenece x [] = False

pertenece x (y:ys) | x == y = True
| otherwise = pertenece x ys
Determina si una palabra pertenece a un lenguaje. potenciaLenguaje :: [String] -> Int -> [String]
potenciaLenguaje x n | validarLenguaje x = potenciaSV x n | otherwise = ["Lenguaje No Valido"] potenciaSV :: [String] -> Int -> [String]
potenciaSV x 0 = [""]
potenciaSV x 1 = x
potenciaSV x n = eliminarRepetidos ( concatenarLenguajesSV x (potenciaSV x (n-1)) ) Funciones sobre Lenguajes Se comprueba que el lenguaje sea correcto y que n sea menor a 20.
La función estrella positiva devuelve las primeras n palabras de la función potencia infinita del lenguaje. Esta ultima realiza la unión de las potencias generadas para n=1, n=2, n=3 etc., sobre el lenguaje x. estrellaPositiva :: [String] -> Int -> [String]
estrellaPositiva [""] n = [""]
estrellaPositiva [] n = []
estrellaPositiva x n | validarLenguaje x && n<=20 = take n $ potenciaInf x 1
| otherwise = ["Lenguaje No Valido o n>20"] potenciaInf :: [String] -> Int -> [String]
potenciaInf x n = unionLenguajesSV (potenciaSV x n) ( potenciaInf x (n+1) ) Funciones sobre Lenguajes Se comprueba que el lenguaje sea correcto y que n sea menor a 20.
La función estrella de Kleene devuelve las primeras n palabras de la función potencia infinita del lenguaje. Esta ultima realiza la unión de las potencias generadas para n=0, n=1, n=2, etc., sobre el lenguaje x. potenciaInf :: [String] -> Int -> [String]
potenciaInf x n = unionLenguajesSV (potenciaSV x n) ( potenciaInf x (n+1) ) estrellaKleene :: [String] -> Int -> [String]
estrellaKleene [""] n = [""]
estrellaKleene [] n = [""]
estrellaKleene x n | validarLenguaje x && n<=20 = take n $ potenciaInf x 0
| otherwise = ["Lenguaje No Valido o n>20"] Funciones sobre Lenguajes Se comprueba que el lenguaje y el alfabeto sean correctos y que el lenguaje se corresponda con el alfabeto.
La función complemento realiza la diferencia entre el lenguaje universal y el lenguaje l. complemento :: [String] -> [String] -> Int -> [String]
complemento a l n | validarLenguajeAlfabeto l a &&
validarAlfabeto a && validarLenguaje l &&
n<=20 = take n $ diferenciaSV (lenguajeUniversal a) l
| otherwise = ["Lenguaje No Valido o Alfabeto No valido o n>20"] lenguajeUniversal :: [String] -> [String]
lenguajeUniversal x = potenciaInf x 0 Funciones de validación 2) Sistema Canónico Dimensión Sintáctica y Semántica.
Se debe tomar como entrada un programa con sentencias goto con rótulo de enunciado y rótulo de referencia.
Los rótulos serán cadenas sobre el alfabeto { A, B, C, D }. Diseñar un programa con un lenguaje de alto nivel de su conocimiento, que simule el Sistema Canónico de Donovan para las sentencias “goto”, visto en clase de teoría. Preferentemente se de-berá utilizar el paradigma lógico. Requerimientos Sistemas Canónicos para lenguaje hipotético "goto" Dimensión Sintáctica
(1er Sistema Canónico) ESTRUCTURA
DEL
PROGRAMA Lenguaje escogido:
Prolog Dimensión Sintáctica y Semántica
(2do Sistema Canónico) Lenguaje "sentencias goto" Consiste únicamente en sentencias goto que contienen un rótulo de enunciado y un rótulo de referencia:
A goto B
B goto C
C goto A Estructura de las sentencias Rótulo de ENUNCIADO
(posición) Rótulo de REFERENCIA
(posición de otra sentencia del programa donde se debe dirigir el flujo de control)
A goto B
B goto C
C goto A Dimensión sintáctica Sistema Canónico: Se comprueba que cada sentencia del programa cumpla con la sintaxis: Rotulo_enunciado goto Rotulo_referencia Además se verifica que los rótulos sean identificadores válidos: Es este ejemplo cadenas sobre {A,B,..,Z}
En la implementación del laboratorio cadenas sobre {A,B,C,D} Dimensión sintáctica Definiciones básicas: % Hechos para identificadores

letra("A").
letra("B").
letra("C").
letra("D").

% Definicion para identificador

identificador([X]) :- letra([X]).
identificador([X|R]) :- letra([X]) , identificador(R). Dimensión sintáctica Enunciado "goto": % Definición de enunciado goto
enunciado_goto(["goto", X]) :- identificador(X). Ejemplo de enunciado "goto": goto BA
goto C ["goto","BA"]
["goto","C"] Dimensión sintáctica Programa: % Definición de programa
programa([E,Y]) :- identificador(E) , enunciado_goto(Y). Ejemplo de programa A goto BA ["A",["goto","BA"]] Dimensión sintáctica Programa: % Recursiva
programa([]).
programa([[E,X]|P]) :-
identificador(E) , enunciado_goto(X) , programa(P). Ejemplo de programa B goto C
D goto A [ ["B",["goto","C"]] , ["D",["goto","A"]] ] Dimensión sintáctica y semántica Sistema Canónico: Comprobaciones: Rotulos: identificadores sobre {A,B,C,D}

Sintaxis de las sentencias:
Rotulo_enunciado goto Rotulo_referencia Sintácticas Verificación de que la lista de Rótulos de Referencia esté contenida en la lista de Rótulos de Enunciado Semánticas Dimensión sintáctica y semántica Enunciado goto con rótulo de referencia % Definición de enunciado goto con rotulo de referencia
enunciado_goto_con_rotulo_referencia(["goto", Y],Y) :- identificador(Y). Ejemplo goto C ( ["goto","C"] , "C" ) Dimensión sintáctica y semántica enunciado goto rotulo de referencia correspondiente el enunciado Programa con rótulos de enunciado y referencia programa_con_rotulo_enunciado_y_rotulo_referencia
([E,X],[E],[R]) :-
identificador(E),
enunciado_goto_con_rotulo_referencia(X,R). Ejemplo A goto C ["A",["goto","C"]] , ["A"] , ["C"] Dimensión sintáctica y semántica sentencia enunciado referencia Programa con rótulos de enunciado y referencia programa_con_rotulo_enunciado_y_rotulo_referencia([],[],[]).

programa_con_rotulo_enunciado_y_rotulo_referencia
([X|Y],[E|F],[R|G]) :- programa_con_rotulo_enunciado_y_rotulo_referencia(X,[E],[R]), programa_con_rotulo_enunciado_y_rotulo_referencia(Y,F,G). Ejemplo A goto C
C goto A [["A",["goto","C"]],["C",["goto","A"]]] , ["A","C"] , ["C","A"] Dimensión sintáctica y semántica Relación de pertenencia % Definicion de verificación de la relación de pertenencia

verifica_relacion_pertenencia(R,E) :- subset(R,E). Comprueba que la lista R está incluida en la lista E Dimensión sintáctica y semántica Lista de rótulos de referencia contenida en la lista de rótulos de enunciado Programa válido programa_valido(P) :- programa_con_rotulo_enunciado_y_rotulo_referencia(P,E,R),
verifica_relacion_pertenencia(R,E). Ejemplo A goto C
C goto A [ ["A",["goto","C"]] , ["C",["goto","A"]] ] Dimensión sintáctica y semántica E = ["A","C"]
R = ["C","A"] Rotulos de enunciado Rotulos de referencia verifica relación
de pertenencia Integrantes:
- Javier A. Delgado
-Gastón Sobrevilla
-Carlos Maximiliano Bravo
-Juan Agustín Veliz Comisión 2k1
Full transcript