[Haskell] Compilador de Pseudocodigo Pascal,C++,Java

en: Julio 23, 2011, 07:19:34 pm

Hola gente como estan ya de vuelta ahora les traigo este compilador de Pseudocodigo que desarrolle hace tiempo andaba con este proyecto Rna le dije pero nunca lograba terminarlo por problemas de la universidad Contratiempos.. o por ultimo mi vaganza jejeje ademas mi falta de empeño hoy me puse a revisar los errores y compilar hasta que me dio por ahora hice de Pascal Java y C++, espero ir aumentado de apoco..

Que es Haskell

Haskell es un lenguaje de programación puramente funcional de propósito general y fuertemente tipado. Su nombre proviene del lógico Haskell Curry.

En los años 1980 se constituyó un comité cuyo objetivo era crear un lenguaje funcional que reuniera las características de los múltiples lenguajes funcionales de la época, el más notable Miranda, y resolviera la confusión creada por la proliferación de los mismos. El lenguaje evoluciona rápidamente con y (ver más abajo) como los representantes actuales del estándar de facto. El último estándar semi-oficial es Haskell 98, con la intención de especificar una versión mínima y compatible del lenguaje como base para futuras extensiones y para su enseñanza.

Bueno sin mas que decir comienzo posteando

Primero la Gramatica Utilizada

Código: [Seleccionar]



Prog -->  "programa" Ident ";" FP  Cuerpo  



FP -->  Funcion  FP  

      | Procedimiento  FP  

      | Vacio



Cuerpo -->  "inicio"  Decl1  Inst   "fin"



Funcion -->   "funcion"  Ident   '('  Pr   ')' ':'  Tipo  Cuerpo 

        

Procedimiento -->   "procedimiento"  Ident   '('  Pr   ')'  pCuerpo 



Pr -->  Decl  Decls



Decls --> ','  Pr

      | Vacio



Decl -->  Tipo  Ident



Decl1 -->  Tipo  Ident  Dec   ';'  Decl1

       | Vacio



Dec -->   ','  Ident  Dec

      | Vacio



Inst -->  Instr  Coma  Inst

      | Vacio



Coma -->   ';'

      | Vacio



Instr --> "si"  Expresion   "entonces"  Inst  OtroCaso  "fin_si"

      |   "mientras"  Expresion   "hacer"  Inst   "fin_mientras"

      |   "repetir"  Inst   "hasta"  Expresion   "fin_repetir"

      |   "para"  Asig   "hasta"  Expresion  MasF  "fin_para"

      |    pAsig

      |   "leer"  Va 

      |   "mostrar"  Va 

      |    Va 

      |   "devolver"  Expresion 

      

MasF -->  "hacer" Inst 

      |  "paso"  Expresion  Inst 

       

Va --> Ident  Z 

     |   "''" Ident   "''"



Z -->  Va2

   |   '[' Ident   ']'

   |   '(' Ident  Va2   ')'



Va2 -->   ','  Ident  Va2 

     |  Vacio



OtroCaso -->   "sino"  Inst 

         | OtroVacio



Asig -->  Ident  pQ



Q -->    "<-"  Expresion 

  |   '[' Ident ']'  "<-"  Expresion   



Expresion --> Relacion  A



A -->  OpLog  Expresion

  |  AVacio

 

Relacion -->  Terminos  B



B -->  SimOps  Relacion 

  |  Vacio



Terminos -->  Fr  C

C --> SimOpm Terminos 

  |  Vacio        



Fr -->  '('  Expresion   ')'

     | Va  

     | Entero



OpLog --> "<"

       |  "<="

       |  ">"

       |  ">=" 

       |  "!="

       |  "="



SimOps --> "+"

        |  "-"



SimOpm --> "*"

        |  "/"



Tipo -->   "int"  Par

      |   "real" Par

      |   "bool" Par

      |   "char" Par

      |   "string" Par





Par -->   '[' ']'

     | ParVacio

GRA.HS (Aqui se encuentra toda la gramatica)

Código: Haskell

-- do not edit; automatically generated by UU_AG
 
module Gra where
 
import Auxiliar
 
type List = [String]
 
type Doble = [(String,String)]
 
type Classs = [(String,String)]
 
controlar a b | a == [] && b /= [] = b
 
               | a /= [] && b /= [] = b
 
               | otherwise = a 
 
-- A -----------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pFor                 : String
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for A.A:
 
-}
 
{-
 
   local variables for A.AVacio:
 
-}
 
data A = A_A (OpLog) (Expresion)
 
       | A_AVacio 
 
-- semantic domain
 
type T_A = ((String),(String),(List),(String),(String),(List),(List))
 
-- cata
 
sem_A :: (A) ->
 
         (T_A)
 
sem_A ((A_A (_opLog) (_expresion))) =
 
    (sem_A_A ((sem_OpLog (_opLog))) ((sem_Expresion (_expresion))))
 
sem_A ((A_AVacio )) =
 
    (sem_A_AVacio )
 
sem_A_A :: (T_OpLog) ->
 
           (T_Expresion) ->
 
           (T_A)
 
sem_A_A (_opLog) (_expresion) =
 
    let ( _opLog_cod,_opLog_jav,_opLog_nom,_opLog_pas,_opLog_uso,_opLog_va) =
 
            (_opLog )
 
        ( _expresion_cod,_expresion_jav,_expresion_nom,_expresion_pFor,_expresion_pas,_expresion_uso,_expresion_va) =
 
            (_expresion )
 
    in  (_opLog_cod ++ _expresion_cod,_opLog_jav ++ _expresion_jav,[],_expresion_pFor,_opLog_pas ++ _expresion_pas,_opLog_uso ++ _expresion_uso,[])
 
sem_A_AVacio :: (T_A)
 
sem_A_AVacio  =
 
    let 
 
    in  ([],[],[],[],[],[],[])
 
-- Asig --------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      for                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Asig.Asig:
 
-}
 
data Asig = Asig_Asig (String) (Q)
 
-- semantic domain
 
type T_Asig = ((String),(String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Asig :: (Asig) ->
 
            (T_Asig)
 
sem_Asig ((Asig_Asig (_string) (_q))) =
 
    (sem_Asig_Asig (_string) ((sem_Q (_q))))
 
sem_Asig_Asig :: (String) ->
 
                 (T_Q) ->
 
                 (T_Asig)
 
sem_Asig_Asig (_string) (_q) =
 
    let ( _q_cod,_q_jav,_q_nom,_q_pas,_q_uso,_q_va) =
 
            (_q )
 
    in  (_string ++ " "  ++ _q_cod,_string,_string ++ " "  ++ _q_jav,_q_nom,_string ++ " "  ++ _q_pas,_string : _q_uso,_q_va)
 
-- B -----------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pFor                 : String
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for B.B:
 
-}
 
{-
 
   local variables for B.BVacio:
 
-}
 
data B = B_B (SimOps) (Relacion)
 
       | B_BVacio 
 
-- semantic domain
 
type T_B = ((String),(String),(List),(String),(String),(List),(List))
 
-- cata
 
sem_B :: (B) ->
 
         (T_B)
 
sem_B ((B_B (_simOps) (_relacion))) =
 
    (sem_B_B ((sem_SimOps (_simOps))) ((sem_Relacion (_relacion))))
 
sem_B ((B_BVacio )) =
 
    (sem_B_BVacio )
 
sem_B_B :: (T_SimOps) ->
 
           (T_Relacion) ->
 
           (T_B)
 
sem_B_B (_simOps) (_relacion) =
 
    let ( _simOps_cod,_simOps_jav,_simOps_nom,_simOps_pas,_simOps_uso,_simOps_va) =
 
            (_simOps )
 
        ( _relacion_cod,_relacion_jav,_relacion_nom,_relacion_pFor,_relacion_pas,_relacion_uso,_relacion_va) =
 
            (_relacion )
 
    in  (_simOps_cod ++ _relacion_cod,_simOps_jav ++ _relacion_jav,[],_relacion_pFor,_simOps_pas ++ _relacion_pas,_simOps_uso ++ _relacion_uso,[])
 
sem_B_BVacio :: (T_B)
 
sem_B_BVacio  =
 
    let 
 
    in  ([],[],[],[],[],[],[])
 
-- C -----------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pFor                 : String
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for C.C:
 
-}
 
{-
 
   local variables for C.CVacio:
 
-}
 
data C = C_C (SimOpm) (Terminos)
 
       | C_CVacio 
 
-- semantic domain
 
type T_C = ((String),(String),(List),(String),(String),(List),(List))
 
-- cata
 
sem_C :: (C) ->
 
         (T_C)
 
sem_C ((C_C (_simOpm) (_terminos))) =
 
    (sem_C_C ((sem_SimOpm (_simOpm))) ((sem_Terminos (_terminos))))
 
sem_C ((C_CVacio )) =
 
    (sem_C_CVacio )
 
sem_C_C :: (T_SimOpm) ->
 
           (T_Terminos) ->
 
           (T_C)
 
sem_C_C (_simOpm) (_terminos) =
 
    let ( _simOpm_cod,_simOpm_jav,_simOpm_nom,_simOpm_pas,_simOpm_uso,_simOpm_va) =
 
            (_simOpm )
 
        ( _terminos_cod,_terminos_jav,_terminos_nom,_terminos_pFor,_terminos_pas,_terminos_uso,_terminos_va) =
 
            (_terminos )
 
    in  (_simOpm_cod ++ _terminos_cod,_simOpm_jav ++ _terminos_jav,[],_terminos_pFor,_simOpm_pas ++ _terminos_pas,_simOpm_uso ++ _terminos_uso,[])
 
sem_C_CVacio :: (T_C)
 
sem_C_CVacio  =
 
    let 
 
    in  ([],[],[],[],[],[],[])
 
-- Coma --------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Coma.C1:
 
-}
 
{-
 
   local variables for Coma.C2:
 
-}
 
data Coma = Coma_C1 
 
          | Coma_C2 
 
-- semantic domain
 
type T_Coma = ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Coma :: (Coma) ->
 
            (T_Coma)
 
sem_Coma ((Coma_C1 )) =
 
    (sem_Coma_C1 )
 
sem_Coma ((Coma_C2 )) =
 
    (sem_Coma_C2 )
 
sem_Coma_C1 :: (T_Coma)
 
sem_Coma_C1  =
 
    let 
 
    in  (";",";",[],";",[],[])
 
sem_Coma_C2 :: (T_Coma)
 
sem_Coma_C2  =
 
    let 
 
    in  ([],[],[],[],[],[])
 
-- Const1 ------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Const1.Const1:
 
-}
 
data Const1 = Const1_Const1 (Tipo) (String) (Const2)
 
-- semantic domain
 
type T_Const1 = ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Const1 :: (Const1) ->
 
              (T_Const1)
 
sem_Const1 ((Const1_Const1 (_tipo) (_string) (_const2))) =
 
    (sem_Const1_Const1 ((sem_Tipo (_tipo))) (_string) ((sem_Const2 (_const2))))
 
sem_Const1_Const1 :: (T_Tipo) ->
 
                     (String) ->
 
                     (T_Const2) ->
 
                     (T_Const1)
 
sem_Const1_Const1 (_tipo) (_string) (_const2) =
 
    let ( _tipo_cod,_tipo_jav,_tipo_nom,_tipo_pas,_tipo_uso,_tipo_va) =
 
            (_tipo )
 
        ( _const2_cod,_const2_jav,_const2_nom,_const2_pas,_const2_uso,_const2_va) =
 
            (_const2 )
 
    in  (_tipo_cod ++ " " ++ _string  ++ " " ++ "= " ++  _const2_cod,_tipo_jav ++ " " ++ _string ++ " " ++ "= " ++ _const2_jav,[],"const " ++ " " ++ _string ++ " " ++ "= " ++ _const2_pas,[],_string:[])
 
-- Const2 ------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Const2.Const21:
 
-}
 
{-
 
   local variables for Const2.Const22:
 
-}
 
data Const2 = Const2_Const21 (Va)
 
            | Const2_Const22 (Int) (Reall)
 
-- semantic domain
 
type T_Const2 = ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Const2 :: (Const2) ->
 
              (T_Const2)
 
sem_Const2 ((Const2_Const21 (_va))) =
 
    (sem_Const2_Const21 ((sem_Va (_va))))
 
sem_Const2 ((Const2_Const22 (_int) (_reall))) =
 
    (sem_Const2_Const22 (_int) ((sem_Reall (_reall))))
 
sem_Const2_Const21 :: (T_Va) ->
 
                      (T_Const2)
 
sem_Const2_Const21 (_va) =
 
    let ( _va_cod,_va_jav,_va_nom,_va_pFor,_va_pas,_va_uso,_va_va) =
 
            (_va )
 
    in  (_va_cod,_va_jav,_va_nom,_va_pas,_va_uso,_va_va)
 
sem_Const2_Const22 :: (Int) ->
 
                      (T_Reall) ->
 
                      (T_Const2)
 
sem_Const2_Const22 (_int) (_reall) =
 
    let ( _reall_cod,_reall_jav,_reall_nom,_reall_pas,_reall_uso,_reall_va) =
 
            (_reall )
 
    in  (show _int ++ _reall_cod,show _int ++ _reall_jav,[],show _int ++ _reall_pas,[],[])
 
-- Cuerpo ------------------------------------------------------
 
{-
 
   inherited attributes:
 
      nomb                 : String
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Cuerpo.Cuerpo:
 
-}
 
data Cuerpo = Cuerpo_Cuerpo (DeclConst) (Inst)
 
-- semantic domain
 
type T_Cuerpo = (String) ->
 
                ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Cuerpo :: (Cuerpo) ->
 
              (T_Cuerpo)
 
sem_Cuerpo ((Cuerpo_Cuerpo (_declConst) (_inst))) =
 
    (sem_Cuerpo_Cuerpo ((sem_DeclConst (_declConst))) ((sem_Inst (_inst))))
 
sem_Cuerpo_Cuerpo :: (T_DeclConst) ->
 
                     (T_Inst) ->
 
                     (T_Cuerpo)
 
sem_Cuerpo_Cuerpo (_declConst) (_inst) (_lhs_nomb) =
 
    let ( _declConst_cod,_declConst_jav,_declConst_nom,_declConst_pas,_declConst_uso,_declConst_va) =
 
            (_declConst )
 
        ( _inst_cod,_inst_jav,_inst_nom,_inst_pas,_inst_uso,_inst_va) =
 
            (_inst (_lhs_nomb))
 
    in  ("{" ++ "\n" ++ _declConst_cod ++ "\n" ++ _inst_cod ++"\n" ++ "}" ++ "\n","{" ++ "\n" ++ _declConst_jav ++  "\n" ++ _inst_jav ++"\n" ++ "}" ++ "\n",_declConst_nom ++ _inst_nom,_declConst_pas ++ "\n" ++ "begin" ++ "\n" ++  _inst_pas ++"\n" ++ "end;",_inst_uso,_declConst_va ++ _inst_va)
 
-- CuerpoP -----------------------------------------------------
 
{-
 
   inherited attributes:
 
      nomb                 : String
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for CuerpoP.CuerpoP:
 
-}
 
data CuerpoP = CuerpoP_CuerpoP (DeclConst) (Inst)
 
-- semantic domain
 
type T_CuerpoP = (String) ->
 
                 ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_CuerpoP :: (CuerpoP) ->
 
               (T_CuerpoP)
 
sem_CuerpoP ((CuerpoP_CuerpoP (_declConst) (_inst))) =
 
    (sem_CuerpoP_CuerpoP ((sem_DeclConst (_declConst))) ((sem_Inst (_inst))))
 
sem_CuerpoP_CuerpoP :: (T_DeclConst) ->
 
                       (T_Inst) ->
 
                       (T_CuerpoP)
 
sem_CuerpoP_CuerpoP (_declConst) (_inst) (_lhs_nomb) =
 
    let ( _declConst_cod,_declConst_jav,_declConst_nom,_declConst_pas,_declConst_uso,_declConst_va) =
 
            (_declConst )
 
        ( _inst_cod,_inst_jav,_inst_nom,_inst_pas,_inst_uso,_inst_va) =
 
            (_inst (_lhs_nomb))
 
    in  ("{" ++ "\n" ++ _declConst_cod ++ "\n" ++ _inst_cod ++"\n" ++ "return (0);" ++ "\n" ++ "}" ++"\n","{" ++ "\n" ++ _declConst_jav ++ "\n" ++ " Scanner teclado=new Scanner(System.in); " ++ "\n" ++ _inst_jav ++"\n" ++ "}" ++"\n",_declConst_nom ++ _inst_nom,_declConst_pas ++ "\n" ++ "begin" ++ "\n" ++ _inst_pas ++"\n" ++ "end.",_inst_uso,_declConst_va ++ _inst_va)
 
-- Dec ---------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Dec.Dec1:
 
-}
 
{-
 
   local variables for Dec.DecVacio:
 
-}
 
data Dec = Dec_Dec1 (String) (Dec)
 
         | Dec_DecVacio 
 
-- semantic domain
 
type T_Dec = ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Dec :: (Dec) ->
 
           (T_Dec)
 
sem_Dec ((Dec_Dec1 (_string) (_dec))) =
 
    (sem_Dec_Dec1 (_string) ((sem_Dec (_dec))))
 
sem_Dec ((Dec_DecVacio )) =
 
    (sem_Dec_DecVacio )
 
sem_Dec_Dec1 :: (String) ->
 
                (T_Dec) ->
 
                (T_Dec)
 
sem_Dec_Dec1 (_string) (_dec) =
 
    let ( _dec_cod,_dec_jav,_dec_nom,_dec_pas,_dec_uso,_dec_va) =
 
            (_dec )
 
    in  (", " ++ _string ++ " " ++ _dec_cod,", " ++ _string ++ " " ++ _dec_jav,[],", " ++ _string ++ " " ++ _dec_pas,[],_string : _dec_va)
 
sem_Dec_DecVacio :: (T_Dec)
 
sem_Dec_DecVacio  =
 
    let 
 
    in  ([],[],[],[],[],[])
 
-- Decl --------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Decl.Decl:
 
-}
 
data Decl = Decl_Decl (Tipo) (String)
 
-- semantic domain
 
type T_Decl = ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Decl :: (Decl) ->
 
            (T_Decl)
 
sem_Decl ((Decl_Decl (_tipo) (_string))) =
 
    (sem_Decl_Decl ((sem_Tipo (_tipo))) (_string))
 
sem_Decl_Decl :: (T_Tipo) ->
 
                 (String) ->
 
                 (T_Decl)
 
sem_Decl_Decl (_tipo) (_string) =
 
    let ( _tipo_cod,_tipo_jav,_tipo_nom,_tipo_pas,_tipo_uso,_tipo_va) =
 
            (_tipo )
 
    in  (_tipo_cod ++ _string,_tipo_jav ++ " " ++ _string,_tipo_nom:[],_string ++ ": " ++ _tipo_pas,[],_string : [])
 
-- Decl1 -------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Decl1.Decl1:
 
-}
 
data Decl1 = Decl1_Decl1 (Tipo) (String) (Dec)
 
-- semantic domain
 
type T_Decl1 = ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Decl1 :: (Decl1) ->
 
             (T_Decl1)
 
sem_Decl1 ((Decl1_Decl1 (_tipo) (_string) (_dec))) =
 
    (sem_Decl1_Decl1 ((sem_Tipo (_tipo))) (_string) ((sem_Dec (_dec))))
 
sem_Decl1_Decl1 :: (T_Tipo) ->
 
                   (String) ->
 
                   (T_Dec) ->
 
                   (T_Decl1)
 
sem_Decl1_Decl1 (_tipo) (_string) (_dec) =
 
    let ( _tipo_cod,_tipo_jav,_tipo_nom,_tipo_pas,_tipo_uso,_tipo_va) =
 
            (_tipo )
 
        ( _dec_cod,_dec_jav,_dec_nom,_dec_pas,_dec_uso,_dec_va) =
 
            (_dec )
 
    in  (_tipo_cod ++ " " ++ _string ++ " " ++ _dec_cod,_tipo_jav ++ " " ++ _string ++ " " ++ _dec_jav,_dec_nom,"var " ++ _string ++ _dec_pas  ++ ": " ++ _tipo_pas,[],_string : _dec_va)
 
-- DeclConst ---------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for DeclConst.DeclConst:
 
-}
 
{-
 
   local variables for DeclConst.DeclConst1:
 
-}
 
{-
 
   local variables for DeclConst.DeclConst2:
 
-}
 
data DeclConst = DeclConst_DeclConst (Decl1) (DeclConst)
 
               | DeclConst_DeclConst1 (Const1) (DeclConst)
 
               | DeclConst_DeclConst2 
 
-- semantic domain
 
type T_DeclConst = ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_DeclConst :: (DeclConst) ->
 
                 (T_DeclConst)
 
sem_DeclConst ((DeclConst_DeclConst (_decl1) (_declConst))) =
 
    (sem_DeclConst_DeclConst ((sem_Decl1 (_decl1))) ((sem_DeclConst (_declConst))))
 
sem_DeclConst ((DeclConst_DeclConst1 (_const1) (_declConst))) =
 
    (sem_DeclConst_DeclConst1 ((sem_Const1 (_const1))) ((sem_DeclConst (_declConst))))
 
sem_DeclConst ((DeclConst_DeclConst2 )) =
 
    (sem_DeclConst_DeclConst2 )
 
sem_DeclConst_DeclConst :: (T_Decl1) ->
 
                           (T_DeclConst) ->
 
                           (T_DeclConst)
 
sem_DeclConst_DeclConst (_decl1) (_declConst) =
 
    let ( _decl1_cod,_decl1_jav,_decl1_nom,_decl1_pas,_decl1_uso,_decl1_va) =
 
            (_decl1 )
 
        ( _declConst_cod,_declConst_jav,_declConst_nom,_declConst_pas,_declConst_uso,_declConst_va) =
 
            (_declConst )
 
    in  (_decl1_cod ++ " ;" ++ "\n" ++ _declConst_cod,_decl1_jav ++ " ;" ++ "\n" ++ _declConst_jav,[],_decl1_pas ++ " ;" ++ "\n" ++ _declConst_pas,[],_decl1_va ++ _declConst_va)
 
sem_DeclConst_DeclConst1 :: (T_Const1) ->
 
                            (T_DeclConst) ->
 
                            (T_DeclConst)
 
sem_DeclConst_DeclConst1 (_const1) (_declConst) =
 
    let ( _const1_cod,_const1_jav,_const1_nom,_const1_pas,_const1_uso,_const1_va) =
 
            (_const1 )
 
        ( _declConst_cod,_declConst_jav,_declConst_nom,_declConst_pas,_declConst_uso,_declConst_va) =
 
            (_declConst )
 
    in  (_const1_cod ++ " ;" ++ "\n" ++ _declConst_cod,_const1_jav ++ " ;" ++ "\n" ++ _declConst_jav,[],_const1_pas ++ " ;" ++ "\n" ++ _declConst_pas,[],_const1_va ++ _declConst_va)
 
sem_DeclConst_DeclConst2 :: (T_DeclConst)
 
sem_DeclConst_DeclConst2  =
 
    let 
 
    in  ([],[],[],[],[],[])
 
-- Decls -------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Decls.Decls:
 
-}
 
{-
 
   local variables for Decls.DeclsVacio:
 
-}
 
data Decls = Decls_Decls (Pr)
 
           | Decls_DeclsVacio 
 
-- semantic domain
 
type T_Decls = ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Decls :: (Decls) ->
 
             (T_Decls)
 
sem_Decls ((Decls_Decls (_pr))) =
 
    (sem_Decls_Decls ((sem_Pr (_pr))))
 
sem_Decls ((Decls_DeclsVacio )) =
 
    (sem_Decls_DeclsVacio )
 
sem_Decls_Decls :: (T_Pr) ->
 
                   (T_Decls)
 
sem_Decls_Decls (_pr) =
 
    let ( _pr_cod,_pr_jav,_pr_nom,_pr_pas,_pr_uso,_pr_va) =
 
            (_pr )
 
    in  ("," ++ " " ++ _pr_cod,"," ++ " " ++ _pr_jav,_pr_nom,";" ++ " " ++ _pr_pas,_pr_uso,_pr_va)
 
sem_Decls_DeclsVacio :: (T_Decls)
 
sem_Decls_DeclsVacio  =
 
    let 
 
    in  ([],[],[],[],[],[])
 
-- EnCaso ------------------------------------------------------
 
{-
 
   inherited attributes:
 
      nomb                 : String
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for EnCaso.EnCaso:
 
-}
 
{-
 
   local variables for EnCaso.EnCaso1:
 
-}
 
data EnCaso = EnCaso_EnCaso (Expresion) (Inst) (EnCaso)
 
            | EnCaso_EnCaso1 
 
-- semantic domain
 
type T_EnCaso = (String) ->
 
                ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_EnCaso :: (EnCaso) ->
 
              (T_EnCaso)
 
sem_EnCaso ((EnCaso_EnCaso (_expresion) (_inst) (_enCaso))) =
 
    (sem_EnCaso_EnCaso ((sem_Expresion (_expresion))) ((sem_Inst (_inst))) ((sem_EnCaso (_enCaso))))
 
sem_EnCaso ((EnCaso_EnCaso1 )) =
 
    (sem_EnCaso_EnCaso1 )
 
sem_EnCaso_EnCaso :: (T_Expresion) ->
 
                     (T_Inst) ->
 
                     (T_EnCaso) ->
 
                     (T_EnCaso)
 
sem_EnCaso_EnCaso (_expresion) (_inst) (_enCaso) (_lhs_nomb) =
 
    let ( _expresion_cod,_expresion_jav,_expresion_nom,_expresion_pFor,_expresion_pas,_expresion_uso,_expresion_va) =
 
            (_expresion )
 
        ( _inst_cod,_inst_jav,_inst_nom,_inst_pas,_inst_uso,_inst_va) =
 
            (_inst (_lhs_nomb))
 
        ( _enCaso_cod,_enCaso_jav,_enCaso_nom,_enCaso_pas,_enCaso_uso,_enCaso_va) =
 
            (_enCaso (_lhs_nomb))
 
    in  ("case " ++ _expresion_cod ++ " : " ++ _inst_cod ++  " ;" ++ "\n" ++ " break ; " ++ "\n" ++ _enCaso_cod,"case " ++ _expresion_jav ++ " : " ++ _inst_jav ++  " ;" ++ "\n" ++ " break ; " ++ "\n" ++ _enCaso_jav,_expresion_nom,_expresion_pas ++ " : " ++ "begin " ++ "\n" ++ _inst_pas ++ "end;" ++ "\n" ++ _enCaso_pas,_expresion_uso ++ _inst_uso ++ _enCaso_uso,_expresion_va)
 
sem_EnCaso_EnCaso1 :: (T_EnCaso)
 
sem_EnCaso_EnCaso1 (_lhs_nomb) =
 
    let 
 
    in  ([],[],[],[],[],[])
 
-- Expresion ---------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pFor                 : String
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Expresion.Expresion:
 
-}
 
data Expresion = Expresion_Expresion (Relacion) (A)
 
-- semantic domain
 
type T_Expresion = ((String),(String),(List),(String),(String),(List),(List))
 
-- cata
 
sem_Expresion :: (Expresion) ->
 
                 (T_Expresion)
 
sem_Expresion ((Expresion_Expresion (_relacion) (_a))) =
 
    (sem_Expresion_Expresion ((sem_Relacion (_relacion))) ((sem_A (_a))))
 
sem_Expresion_Expresion :: (T_Relacion) ->
 
                           (T_A) ->
 
                           (T_Expresion)
 
sem_Expresion_Expresion (_relacion) (_a) =
 
    let ( _relacion_cod,_relacion_jav,_relacion_nom,_relacion_pFor,_relacion_pas,_relacion_uso,_relacion_va) =
 
            (_relacion )
 
        ( _a_cod,_a_jav,_a_nom,_a_pFor,_a_pas,_a_uso,_a_va) =
 
            (_a )
 
    in  (_relacion_cod ++ _a_cod,_relacion_jav ++ _a_jav,[],controlar _relacion_pFor _a_pFor,_relacion_pas ++ _a_pas,_relacion_uso ++ _a_uso,[])
 
-- FP ----------------------------------------------------------
 
{-
 
   inherited attributes:
 
      nomb                 : String
 
   chained attributes:
 
   synthesised attributes:
 
      cap                  : String
 
      claser               : Classs
 
      cod                  : String
 
      dod                  : Doble
 
      jav                  : String
 
      nom                  : List
 
      npf                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for FP.FP:
 
-}
 
{-
 
   local variables for FP.FP1:
 
-}
 
{-
 
   local variables for FP.FPVacio:
 
-}
 
data FP = FP_FP (Funcion) (FP)
 
        | FP_FP1 (Procedimiento) (FP)
 
        | FP_FPVacio 
 
-- semantic domain
 
type T_FP = (String) ->
 
            ((String),(Classs),(String),(Doble),(String),(List),(List),(String),(List),(List))
 
-- cata
 
sem_FP :: (FP) ->
 
          (T_FP)
 
sem_FP ((FP_FP (_funcion) (_fP))) =
 
    (sem_FP_FP ((sem_Funcion (_funcion))) ((sem_FP (_fP))))
 
sem_FP ((FP_FP1 (_procedimiento) (_fP))) =
 
    (sem_FP_FP1 ((sem_Procedimiento (_procedimiento))) ((sem_FP (_fP))))
 
sem_FP ((FP_FPVacio )) =
 
    (sem_FP_FPVacio )
 
sem_FP_FP :: (T_Funcion) ->
 
             (T_FP) ->
 
             (T_FP)
 
sem_FP_FP (_funcion) (_fP) (_lhs_nomb) =
 
    let ( _funcion_cap,_funcion_claser,_funcion_cod,_funcion_dod,_funcion_jav,_funcion_nom,_funcion_npf,_funcion_pas,_funcion_uso,_funcion_va) =
 
            (_funcion (_lhs_nomb))
 
        ( _fP_cap,_fP_claser,_fP_cod,_fP_dod,_fP_jav,_fP_nom,_fP_npf,_fP_pas,_fP_uso,_fP_va) =
 
            (_fP (_lhs_nomb))
 
    in  (_funcion_cap,_funcion_claser ++ _fP_claser,_funcion_cod ++ "\n" ++ _fP_cod ++ "\n",_funcion_dod ++ _fP_dod,_funcion_jav ++ "\n" ++ _fP_jav ++ "\n",_funcion_nom ++ _fP_nom,_funcion_npf ++ _fP_npf,_funcion_pas ++ "\n" ++ _fP_pas ++ "\n",_funcion_uso ++ _fP_uso,_funcion_va ++ _fP_va)
 
sem_FP_FP1 :: (T_Procedimiento) ->
 
              (T_FP) ->
 
              (T_FP)
 
sem_FP_FP1 (_procedimiento) (_fP) (_lhs_nomb) =
 
    let ( _procedimiento_cap,_procedimiento_claser,_procedimiento_cod,_procedimiento_dod,_procedimiento_jav,_procedimiento_nom,_procedimiento_npf,_procedimiento_pas,_procedimiento_uso,_procedimiento_va) =
 
            (_procedimiento (_lhs_nomb))
 
        ( _fP_cap,_fP_claser,_fP_cod,_fP_dod,_fP_jav,_fP_nom,_fP_npf,_fP_pas,_fP_uso,_fP_va) =
 
            (_fP (_lhs_nomb))
 
    in  (_procedimiento_cap,_fP_claser,_procedimiento_cod ++ "\n" ++ _fP_cod ++ "\n",_procedimiento_dod ++ _fP_dod,_procedimiento_jav ++ "\n" ++ _fP_jav ++ "\n",_procedimiento_nom ++ _fP_nom,_procedimiento_npf ++ _fP_npf,_procedimiento_pas ++ "\n" ++ _fP_pas ++ "\n",_procedimiento_uso ++ _fP_uso,_procedimiento_va ++ _fP_va)
 
sem_FP_FPVacio :: (T_FP)
 
sem_FP_FPVacio (_lhs_nomb) =
 
    let 
 
    in  ("",[],[],[],[],[],[],[],[],[])
 
-- Fr ----------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pFor                 : String
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Fr.Fr:
 
-}
 
{-
 
   local variables for Fr.Fr1:
 
-}
 
{-
 
   local variables for Fr.Fr2:
 
-}
 
data Fr = Fr_Fr (Expresion)
 
        | Fr_Fr1 (Va)
 
        | Fr_Fr2 (Int) (Reall)
 
-- semantic domain
 
type T_Fr = ((String),(String),(List),(String),(String),(List),(List))
 
-- cata
 
sem_Fr :: (Fr) ->
 
          (T_Fr)
 
sem_Fr ((Fr_Fr (_expresion))) =
 
    (sem_Fr_Fr ((sem_Expresion (_expresion))))
 
sem_Fr ((Fr_Fr1 (_va))) =
 
    (sem_Fr_Fr1 ((sem_Va (_va))))
 
sem_Fr ((Fr_Fr2 (_int) (_reall))) =
 
    (sem_Fr_Fr2 (_int) ((sem_Reall (_reall))))
 
sem_Fr_Fr :: (T_Expresion) ->
 
             (T_Fr)
 
sem_Fr_Fr (_expresion) =
 
    let ( _expresion_cod,_expresion_jav,_expresion_nom,_expresion_pFor,_expresion_pas,_expresion_uso,_expresion_va) =
 
            (_expresion )
 
    in  ("(" ++ _expresion_cod ++ ")","(" ++ _expresion_jav ++ ")",[],"(" ++ _expresion_pFor ++ ")","(" ++ _expresion_pas ++ ")",_expresion_uso,[])
 
sem_Fr_Fr1 :: (T_Va) ->
 
              (T_Fr)
 
sem_Fr_Fr1 (_va) =
 
    let ( _va_cod,_va_jav,_va_nom,_va_pFor,_va_pas,_va_uso,_va_va) =
 
            (_va )
 
    in  (_va_cod,_va_jav,[],_va_pFor,_va_pas,_va_uso,[])
 
sem_Fr_Fr2 :: (Int) ->
 
              (T_Reall) ->
 
              (T_Fr)
 
sem_Fr_Fr2 (_int) (_reall) =
 
    let ( _reall_cod,_reall_jav,_reall_nom,_reall_pas,_reall_uso,_reall_va) =
 
            (_reall )
 
    in  (show _int ++ _reall_cod,show _int ++ _reall_jav,[],show _int,show _int ++ _reall_pas,[],[])
 
-- Funcion -----------------------------------------------------
 
{-
 
   inherited attributes:
 
      nomb                 : String
 
   chained attributes:
 
   synthesised attributes:
 
      cap                  : String
 
      claser               : Classs
 
      cod                  : String
 
      dod                  : Doble
 
      jav                  : String
 
      nom                  : List
 
      npf                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Funcion.Fu:
 
-}
 
data Funcion = Funcion_Fu (String) (Pr) (Tipo) (Cuerpo)
 
-- semantic domain
 
type T_Funcion = (String) ->
 
                 ((String),(Classs),(String),(Doble),(String),(List),(List),(String),(List),(List))
 
-- cata
 
sem_Funcion :: (Funcion) ->
 
               (T_Funcion)
 
sem_Funcion ((Funcion_Fu (_string) (_pr) (_tipo) (_cuerpo))) =
 
    (sem_Funcion_Fu (_string) ((sem_Pr (_pr))) ((sem_Tipo (_tipo))) ((sem_Cuerpo (_cuerpo))))
 
sem_Funcion_Fu :: (String) ->
 
                  (T_Pr) ->
 
                  (T_Tipo) ->
 
                  (T_Cuerpo) ->
 
                  (T_Funcion)
 
sem_Funcion_Fu (_string) (_pr) (_tipo) (_cuerpo) (_lhs_nomb) =
 
    let ( _pr_cod,_pr_jav,_pr_nom,_pr_pas,_pr_uso,_pr_va) =
 
            (_pr )
 
        ( _tipo_cod,_tipo_jav,_tipo_nom,_tipo_pas,_tipo_uso,_tipo_va) =
 
            (_tipo )
 
        ( _cuerpo_cod,_cuerpo_jav,_cuerpo_nom,_cuerpo_pas,_cuerpo_uso,_cuerpo_va) =
 
            (_cuerpo (_string))
 
    in  (_string,(_tipo_nom,_string):[],_tipo_cod ++ " " ++ _string ++"( "++ _pr_cod ++" )" ++ "\n" ++ _cuerpo_cod,repNfp _string (_pr_va ++ _cuerpo_va),"public " ++ _tipo_jav ++ " " ++ _string ++ "( " ++ _pr_jav ++ " )" ++ "\n" ++ _cuerpo_jav,_pr_nom ++ _cuerpo_nom,_string:[],"function "++ " " ++ _string ++ "( " ++ _pr_pas ++ " )" ++ ":" ++ _tipo_pas ++ ";" ++ "\n" ++ _cuerpo_pas,_cuerpo_uso,_string : [] ++ _pr_va ++ _cuerpo_va)
 
-- Ids ---------------------------------------------------------
 
{-
 
   inherited attributes:
 
   chained attributes:
 
   synthesised attributes:
 
      cod                  : String
 
      jav                  : String
 
      nom                  : List
 
      pas                  : String
 
      uso                  : List
 
      va                   : List
 
-}
 
{-
 
   local variables for Ids.Ids:
 
-}
 
{-
 
   local variables for Ids.Ids0:
 
-}
 
{-
 
   local variables for Ids.Ids1:
 
-}
 
{-
 
   local variables for Ids.Ids2:
 
-}
 
{-
 
   local variables for Ids.Ids3:
 
-}
 
{-
 
   local variables for Ids.Ids4:
 
-}
 
{-
 
   local variables for Ids.Ids5:
 
-}
 
data Ids = Ids_Ids (String) (Ids)
 
         | Ids_Ids0 (Ids)
 
         | Ids_Ids1 (Int) (Ids)
 
         | Ids_Ids2 (Ids)
 
         | Ids_Ids3 (Ids)
 
         | Ids_Ids4 (Ids)
 
         | Ids_Ids5 
 
-- semantic domain
 
type T_Ids = ((String),(String),(List),(String),(List),(List))
 
-- cata
 
sem_Ids :: (Ids) ->
 
           (T_Ids)
 
sem_Ids ((Ids_Ids (_string) (_ids))) =
 
    (sem_Ids_Ids (_string) ((sem_Ids (_ids))))
 
sem_Ids ((Ids_Ids0 (_ids))) =
 
    (sem_Ids_Ids0 ((sem_Ids (_ids))))
 
sem_Ids ((Ids_Ids1 (_int) (_ids))) =
 
    (sem_Ids_Ids1 (_int) ((sem_Ids (_ids))))
 
sem_Ids ((Ids_Ids2 (_ids))) =
 
    (sem_Ids_Ids2 ((sem_Ids (_ids))))
 
sem_Ids ((Ids_Ids3 (_ids))) =
 
    (sem_Ids_Ids3 ((sem_Ids (_ids))))
 
sem_Ids ((Ids_Ids4 (_ids))) =
 
    (sem_Ids_Ids4 ((sem_Ids (_ids))))
 
sem_Ids ((Ids_Ids5 )) =
 
    (sem_Ids_Ids5 )
 
sem_Ids_Ids :: (String) ->
 
               (T_Ids) ->
 
               (T_Ids)
 
sem_Ids_Ids (_string) (_ids) =
 
    let ( _ids_cod,_ids_jav,_ids_nom,_ids_pas,_ids_uso,_ids_va) =
 
            (_ids )
 
    in  (_string ++ " " ++ _ids_cod,_string ++ " " ++ _ids_jav,[],_string ++ " " ++ _ids_pas,_string:[] ++ _ids_uso,[])
sem_Ids_Ids0 :: (T_Ids) ->
                (T_Ids)
sem_Ids_Ids0 (_ids) =
    let ( _ids_cod,_ids_jav,_ids_nom,_ids_pas,_ids_uso,_ids_va) =
            (_ids )
    in  ("\"" ++ _ids_cod ++ "\"\"%d" ++ "\"","\" " ++ _ids_jav ++ "\"",[],"' " ++ _ids_pas ++ " '",[],_ids_va)
sem_Ids_Ids1 :: (Int) ->
                (T_Ids) ->

Jython: Mezclando Java y Python Iniciado por Expermicid	Respuestas: 3 Vistas: 11873	Enero 17, 2018, 09:09:59 pm por gugadev
GUI para Compilador Cramel Iniciado por Riojas	Respuestas: 4 Vistas: 3228	Febrero 24, 2017, 11:25:58 pm por xyz
[Pascal] Calculadora de numero primos. Iniciado por chivo	Respuestas: 1 Vistas: 5927	Agosto 18, 2013, 01:27:13 am por UpecBlack
[Pascal] Generador de clave. Iniciado por chivo	Respuestas: 5 Vistas: 4690	Enero 13, 2014, 01:20:44 am por chivo
[Descarga] Dev Pascal 1.9.2 Iniciado por ANTRAX	Respuestas: 0 Vistas: 4555	Febrero 24, 2010, 03:50:39 pm por ANTRAX

Underc0de - Hacking y seguridad informática

[Haskell] Compilador de Pseudocodigo Pascal,C++,Java

Snifer

[Haskell] Compilador de Pseudocodigo Pascal,C++,Java

Similar topics (5)