Type ACC = RECORD

CASE(esHoja: Bool) OF
True = es: Lista(Entero) // Valores o Record de pares de valores.
False = nh: RECORD
cat: String // Categoria
hijos: Lista (
RECORD
v: String
h: ACC
END
)
END
ENDCASE
END

///////////////////////////////////////////////////
//
Proc crearACCH(es: Lista(Entero), ref (out) a: ACC)
//
///////////////////////////////////////////////////
COM
a.esHoja <- True
a.es <- es
END

///////////////////////////////////////////////////
//
Proc crearACCNH(cat: String, vs: Lista(String), hs: Lista(ACC), ref(out) a: ACC)
//
///////////////////////////////////////////////////
VAR
// devolver SubArbol en "a: ACC"
// SubArbol a ser incluído en a: como hijo
hj : RECORD // Registro de cada Hijo
v: String // Etiqueta del Hijo
h: ACC // SubArbol
END
v: String // Rótulo del Subárbol
h: ACC // Cada uno de los subárboles en hs
COM

a.esHoja <- False

a.cat <- cat
Mientras no(esVaciaL(vs)) hacer
cabeza(vs, v) // Extraer un rótulo y transferir a v
cabeza(hs, h) // Extraer un subárbol y transferir a h

hj.v <- v
hj.h <- h
agL(a.hijos, hj)

resto(vs)
resto(hs)
FMientras
END
///////////////////////////////////////////////////
// Proyector
//
fun esHoja(a:ACC): Bool
//
///////////////////////////////////////////////////
return (a:esHoja)

///////////////////////////////////////////////////
// Obtener la lista de valores asociados al nodo hoja.
//
proc obtEs(a: ACC, ref (out) es: Lista(Entero))
//
///////////////////////////////////////////////////
es <- a.es
return

///////////////////////////////////////////////////
// Obtener la Categoría asociada al nodo
//
Fun obtCat(a:ACC) : String
//
///////////////////////////////////////////////////
return (a.cat)

///////////////////////////////////////////////////
//
// Obtener los rótulos asociados los Sub Arboles
proc obtRots(a:ACC, ref (out) rots: Lista(String))
//
///////////////////////////////////////////////////
VAR
hs : Lista(ACC) // Lista de árboles
hj : RECORD // Registro de cada Hijo
v: String // Etiqueta del Hijo
h: ACC // SubArbol
END
rotAux : Lista(String) // Lista de etiquetas p/navegar
v : String // Etiqueta invididual de un subarbol
COM
hs <- a.nh.hijos // Lista de hijos
MIENTRAS NO(esListaVacia(hs)) HACER
cabeza(hs, hj) // obtener primer hijo en hj
v <- hj.v // obtener etiqueta del hijo
agL(rots, v) // agregar etiqueta a lista
resto(hs)
FMIENTRAS
FProc

///////////////////////////////////////////////////
//
// Obtener SubArboles con Corte de Control
proc obtSACCs(a:ACC, ref (out) hs: Lista(ACC))
//
///////////////////////////////////////////////////
VAR
COM
hs <- a.nh.hijos // Lista de hijos
FProc
//////////////////////////////////////////////////////
//
Proc Imprimir_Reporte(a: ACC, ref t: TOTAL)
//
/////////////////////////////////////////////////////
VAR
es : Lista(Entero)
rot : String
sa : ACC
rots : Lista(String)
sas : Lista(ACC)
rotsaux : Lista(String)
sasaux : Lista(ACC)
totsa : Float
COM
SI esHoja(a) ENTONCES
obtES(a, es)
genTOT(es, t) // Escribir este procedimiento
Imprimir_Total(t) // Escribir este procedimiento
SINO
Imprimir_String(obtCat(a)) // Escribir este procedimiento
obtRots(a, rots)
obtSACC(a, sas )
rotsaux <- rots
sasaux <- sas
crearTotVacio(t) // Escribir este procedimiento
MIENTRAS (NOT(esVaciaLista(rotsaux))) HACER
cabeza(rotsaux, rot)
cabeza(sasaux , sa )
Imprimir_String( rot )
Imprimir_Reporte(sa, totsa )
acumularTotal(t, totsa) // Escribir este procedimiento
resto(rotsaux)
resto(sasaux)
FMIENTRAS
Imprimir_Total(t)
FSI
Fproc