//  CAFE2011.EXE is licensed under the terms of the CC-LGPL.
//  (CC-LGPL Version 3, 29 junio 2007 y CAFE2011 version 2011)
//  El objetivo es el libre uso comercial y no comercial del software.
//  Una copia de dicho documento se incluye en esta distribucion.
//  CWSDPMI.EXE, STREAMCO.PAS, el procedimiento TextOut
//  se tomaron de la distribucion FreePascal 2.4.2. con patente similar.
//        StreamCo.PAS es una contraccion conveniente a ocho letras del
//        nombre StreamColl.PAS en la distribucion FreePascal
  {$MODE                OBJFPC          }
  {$INCLUDEPATH         ..\INCLUDE      }
  {$INCLUDE             CAFE_INC.INC    }
  {$DEFINE              SILENCIAR       }
  {$INTERFACES          CORBA           }
UNIT CAFE_Ej5;

INTERFACE

USES
  SysUtils, Classes , Math    , CAFE_Ej1, CAFE_Ej2, CAFE_Ej3, CAFE_Ej4,
  CAFE_Tu1, TypInfo , CustApp , StreamCo          , Types   , StreamIO;

CONST
  CAFE_DefaultMaximoConteoErroresLoad           = 3;
{
  CAFE_DefaultMaximoConteoErroresLoad           :
        Establece un maximo para los errores de los procesos Load.
        No incluye errores sintacticos de casilla.
        Se otorga cierta tolerancia, prevista para que el usuario
        defina sus propios archivos Load, o por compatibilidad
        de version.  Es admisible un cero.
        ( Ver CAFE_MaximoConteoErroresLoad )
}

VAR
  CAFE_ModoQuimico              : Boolean       = TRUE;
{
  CAFE_ModoQuimico              : Declara variables y funciones
        a gusto del programador de CAFE.EXE en unidades propias,
        que utiliza tambien en otros proyectos.
        La opcion FALSE las desactiva.
}

  CAFE_TamanoFilaDefault        : LongInt       = 99;
{
  CAFE_TamanoFilaDefault        : Este es el tamano en filas a asignar a
        la HojaDefault del manejador Temporal.
}

  CAFE_TamanoColumnaDefault     : LongInt       =
                        CAFE_TotalLetras*( CAFE_TotalLetras+1 );
{
  CAFE_TamanoColumnaDefault     : Este es el tamano en columnas a asignar
        a la HojaDefault en manejador Temporal.
}

  CAFE_NombreManejadorTemporal  : ShortString   = '$TEMPORAL';
{
  CAFE_NombreManejadorTemporal  : Nombre con que se identifica el
        manejador Temporal siempre definido una vez activado
        el sistema principal CAFE.EXE.
        * Sirve como pivote de copias, y de calculos complicados.
        * Tambien puede usarse como calculador
        de renglon en ejecuciones al estilo de comando.
        * El programa recurre a Temporal como manejador por defecto,
        en diferentes situaciones especiales.  Como al iniciar
        un proceso Load, para evitar afectar los datos actuales no
        temporales.
}

  CAFE_NombreGrupoTemporal      : ShortString   = '$TEMPORAL';
{
  CAFE_NombreGrupoTemporal      : Nombre que recibe el grupo Save,
        del manejador temporal.
}

  CAFE_ManejadorTemporal        : CAFE_Manejador0;
{
  CAFE_ManejadorTemporal        : Manejador que se encarga de ejecutar
        Temporal.
}

  CAFE_ClaveManejadorTemporal   : LongInt;
{
  CAFE_ClaveManejadorTemporal   : Numero clave que identifica al manejador
        temporal.
}

  CAFE_TipoCollectionSave       : TCollectionItemClass;
{
  CAFE_TipoCollectionSave       : Los grupos Save se agrupan en
        este tipo de colecciones.  Esto identifica el tipo de grupo
        Save principal de la aplicacion.
}

  CAFE_MaximoConteoErroresLoad  : LongInt       =
                                CAFE_DefaultMaximoConteoErroresLoad;
{
  CAFE_MaximoConteoErroresLoad          : Permite la modificaciones
        del maximo establecido por Default para conteos de errores
        en procesos Load.
}

VAR
  CAFE_MaximoFilaCrearHoja      : LongInt       = 10000;
{
  CAFE_MaximoFilaCrearHoja              : Establece un maximo de fila
        a considerar error al intentar crear una hoja en la pipa.
}

  CAFE_MaximoColumnaCrearHoja   : LongInt       = 10000;
{
  CAFE_MaximoColumnaCrearHoja           : Establece un maximo de columna
        a considerar error al intentar crear una hoja en la pipa.
}

CONST
  CAFE_OrdenSalida              = 'SALIDA';
{
  CAFE_OrdenSalida              :
        Para interrumpir y salir del programa
}

  CAFE_OrdenLeerCasillas        = 'LEERCASILLAS()';
{
  CAFE_OrdenLeerCasillas        :
        LEERCASILLAS( range )
        LEERCASILLAS( range, DEFAULT )
        Intenta una lectura pasiva del calculo, sin realizarlo.
        Si quiere una lectura activa utilice simplemente
        Utiliza las mismas reglas de despliegue que RANGE
        DEFAULT impone el despligue numerico, y String para macros
        RANGE
}

  CAFE_OrdenCasillasAArchivo    = 'CASILLASAARCHIVO()';
{
  CAFE_OrdenCasillasAArchivo
        CASILLASAARCHIVO( range, 'NombreArchivo' )
        Intenta una lectura pasiva del calculo, sin realizarlo.
        Y guarda el resultado como una lista TXT, separada por
        cambios de renglon
}

  CAFE_OrdenCrearHojaTrabajo    = 'CREARHOJATRABAJO()';
{
  CAFE_OrdenCrearHojaTrabajo    =
        CrearHojaTrabajo( Fila, Columna, 'DisplayNombre' [, AISLADO ] )
        En ResultREPO se devuelve clave de control
        y NombreREPO el grupo SAVE
        si no es proceso LOAD
        Se intenta agregar al grupoSave actual,
        con muchas excepciones, i.e. TEMPORAL o AISLADO previo o actual
        ACTUALGRUPOSAVE
        devuelve en ResultREPO el grupo Save actual
        CAFE_NombreManejadorTemporal no puede usarse como nuevo nombre
}

  CAFE_OrdenDestruirHojaTrabajo = 'DESTRUIRHOJATRABAJO()';
{
  CAFE_DestruirHojaTrabajo      =
        Elimina la hoja de trabajo y su manejador de memoria
        DestruirHojaTrabajo( 'DisplayNombre', ClaveHoja )
        Prohibido en proceso Load
}

  CAFE_OrdenDestruirGrupoSave   = 'DESTRUIRGRUPOGUARDAR()';
{
  CAFE_CerrarGrupoSave          =
        Elimina el grupo save, y sus componentes
        DESTRUIRGRUPOSAVE( 'NombreGrupo' )
        El grupo temporal no se puede eliminar
}

  CAFE_OrdenActivarHojaTrabajo  = 'ACTIVARHOJATRABAJO()';
{
  CAFE_OrdenActivarHojaTrabajo  =
        ActivarHojaTrabajo( 'DisplayNombre' [, Clave ] )
        Sin clave simplemente accesa al ultimo nombre que encuentre.
        Inmediatamente se accesa el grupo Save respectivo.
        Si no tiene GrupoSave asignado no se activa
        y se genera un error.  Esto es posible;
        debido a acumulacion de errores.
        Si al activar la hoja de trabajo; se encuentra que el
        primer manejador declarado del grupo es de tipo aislado, se activa
        BanderaMantenerGrupoSave = FALSE
        Parametro Clave no se permite en proceso Load.
        En procesos Load unicamente se permite activar
        Temporal y hojas creadas en dicho proceso
  'DisplayNombre'       : El nombre con el que se reconoce la hoja
  Clave                 : Sirve en caso de duplicacion de nombres.
        De no especificarse se elige la ultima alternativa valida.
}

  CAFE_OrdenActivarGrupoSave    = 'ACTIVARGRUPOGUARDAR()';
{
  CAFE_OrdenActivarGrupoSave    :
        Unicamente activa el grupo save para futuras adiciones,
        pero el manejador actual se conserva.
        BanderaMantenerGrupoSave intenta aplicar las reglas usuales
        ACTIVARGRUPOSAVE( 'NOMBREGRUPO' )
}

  CAFE_OrdenDescribirHoja       = 'DESCRIBIRHOJA()';
{
  CAFE_OrdenDescribirHoja       :
        Agrega caracteristicas al Manejador actual con la
        condicion que sea una Hoja de Trabajo
        DescribirHoja( NumeroEntero )
  Numero                       : Un numero, probablemente en hexadecimal,
        para agregar caracteristicas a la hoja activa
}

  CAFE_OrdenSaveHojaTrabajo     = 'GUARDARHOJA()';
{
  CAFE_OrdenSaveHojaTrabajo     =
        Para que una Hoja de Trabajo puede aplicar un SAVE
        requiere pertenecer a un grupo save, que bien podria
        tener un solo elemento
        SaveGrupo( 'Archivo', 'GrupoSave' )
        Para aplicar el Save, CAFE.EXE simplemente aplica
        SYSTEM.Asign y Rewrite
        y finalmente aplica el Close
        Se generan mensajes de BEGINSAVE y siguientes...
}

  CAFE_OrdenLoadHojaTrabajo     = 'ABRIRHOJA()';
{
  CAFE_OrdenLoadHojaTrabajo     =
        LoadHoja( 'Archivo' )
        En NombreREPO GrupoSave como String a uno nuevo
        Si desea agregarlo a otro grupo, deberia aplicar otros
        procesos posteriores.
        Probablemente el GrupoSave quede como activo,
        y las consecuentes hojas se agregaran en default alli.
        Aplican las reglas de los procesos LOAD ver
        ListaManejadoresLoad abajo.
        Los errores generados por el proceso LOAD
        tratan de convertirse en ErrorLoadREPO y MensajeLoadREPO,
        para facilitar que el usuario los ignore si asi
        lo desea;  aunque con probable perdida
        de informacion.  Si desea mas informacion
        utilice un proceso TXT.
        De no generarse ningun error se sugiere generar PerfectoLoadREPO.
        E informar el descarte con DescarteLoadREPO
}

  CAFE_OrdenNuevoGrupoSave      = 'NUEVOGRUPOGUARDAR';
{
  CAFE_OrdenNuevoGrupoSave      :
        Genera un NuevoGrupoSave el cual se devueve en result
        quedara como el grupo activo, al cual se le agregan
        las nuevas hojas de trabajo creadas
        Devuelve en NombreREPO el nombre creado,
        que se encontrara vacio
}

  CAFE_OrdenActualGrupoSave     = 'ACTUALGRUPOGUARDAR';
{
  CAFE_OrdenActualGrupoSave     :
        Devuelve en NombreREPO el nombre del grupo Save actual
}

  CAFE_OrdenListaGruposSave     = 'LISTAGRUPOSGUARDAR';
{
  CAFE_OrdenListaGruposSave     :
        Devuelve como una secuencia de NombreREPO, una lista
        de los Grupos Save definidos actuales
}

  CAFE_OrdenListaManejadores    = 'LISTAMANEJADORES()';
{
  CAFE_OrdenListaManejadores    :
        Devuelve la lista de manejadores para un grupo Save
        ListaManejadores( 'NombreGrupo' )
        Se devuelve como una secuencia
        NombreREPO 'NombreManejador'
        ResultREPO 'ClaveManejador' IntToStr
}

  CAFE_OrdenListaManejadoresTotal               = 'LISTAMANEJADORESTOTAL';
{
  CAFE_OrdenListaManejadoresTotal               :
        Devuelve la lista de todos los manejadores definidos
        Se devuelve como una secuencia
        NombreREPO 'NombreManejador'
        ResultREPO 'ClaveManejador' IntToStr
}

  CAFE_OrdenActualManejador     = 'ACTUALMANEJADOR';
{
  CAFE_OrdenActualManejador     :
        Devuelve en NombreREPO el nombre del actual manejador
        y en ResultREPO la Clave
}

  CAFE_OrdenActualDescriptorHoja                = 'ACTUALDESCRIPTORHOJA';
{
  CAFE_OrdenActualDescriptorHoja                :
        Informa en Result como numero hexadecimal el descriptor
        actual de la hoja de calculo
}

  CAFE_OrdenAgregarHojaGrupoSave                = 'AGREGARHOJA()';
{
  CAFE_AgregarHojaGrupoSave     =
        Permite agregar un interprete a un grupo SAVE
        AgregarHoja( 'NombreHoja' [, ClaveHoja] [, 'NombreGrupo'] )
        CAFE.EXE permite repetir nombreHoja pero no 'NombreGrupo'
        No cambia estado de activacion
  'NombreHoja'  : Nombre del manejador
  'NombreGrupo' : De no indicar se intentara el ultimo grupo
        generado por NuevoGrupoSave()...
        no se recomienda pero facilita la programacion TXT
  ClaveHoja     : Util para evitar confusion por hojas
        con el mismo nombre.  De no indicar se tomara
        la ultima que concuerde.
        AgregarHojaGrupoSave procede a hacer las
        siguientes suposiciones
  A. El usuario desea olvidar los vinculos anteriores de la hoja.
        Es decir sus comunicaciones generadas entre interpretes.
  B. El usuario desea conectar el nuevo interprete en su totalidad
        con el nuevo grupo al que ingresa.
  C. Todos los anteriores elementos del grupo y los futuros
        adquiriran cuando lo soliciten conectivadad con la hoja
        asi agregada.
        En lo sucesivo CAFE.EXE aplicara las
        reglas A,B y C con los nuevos elementos Vincular, salvo con
        las manejadores declarados aislados.
  D. Casillas y elementos podrian tener inconsistencias no corregidas,
        para evitarlo realice la vinculacion en las etapas iniciales
        de produccion de los datos
}

  CAFE_OrdenVerFuncional        = 'VERFUNCIONAL';
{
  CAFE_OrdenVerFuncional        :
        Aplicable como NOT, en la hoja actual;  activa
        la bandera VerFuncionalCVDH en DescriptoresHoja;
        genera un error si no aplica.
        Esto afecta el despligue de las ordenes de renglon
        de invocacion de casilla y rango
        A1
        A1:B3
}

  CAFE_OrdenVerValorPrueba      = 'VERVALORPRUEBA';
{
  CAFE_OrdenVerValorPrueba      :
        Aplicable como NOT, en la hoja actual;  activa
        la bandera VerValorPruebaCVDH en DescriptoresHoja;
        genera un error si no aplica.
        Esto afecta el despligue de las ordenes de renglon
        de invocacion de casilla y rango
        A1
        A1:B3
}

  CAFE_OrdenTodoCicloProhibido  = 'TODOCICLOPROHIBIDO';
{
  CAFE_OrdenTodoCicloProhibido  :
        Aplicable como NOT, en la hoja actual;  activa
        la bandera TodoCicloProhibidoCVDH en DescriptoresHoja
}

  CAFE_OrdenHojaAislada         = 'HOJAAISLADA';
{
  CAFE_OrdenHojaAislada         :
        Para solicitar una Hoja de Calculo aislada.  Esto intentara,
        mantener incomunicada la hoja accesando sus casillas
        internas desde otras hojas y a la inversa.
        El sistema es debil, si la HojaAislada se encuentra
        en un Grupo Save y probablemente otras
        hojas ignoren la condicion.
        Mejor si es el unico elemento en un grupo.
        El grupo Save, intentara crear nuevas hojas en otros grupos.
        Permitido como NOT.
}

  CAFE_OrdenPeticionCalculoObligatorio          =
                        'PETICIONCALCULOOBLIGATORIO';
{
  CAFE_OrdenPeticionCalculoObligatorio          :
        En una hoja de calculo activa una bandera de control.
        En esta condicion al evaluar si no aparece TRUE
        en BanderaPeticionCalculo de una funcion o macro;
        probablemente solo se tome el valor.  Esto ahorrara velocidad.
        Permitido como NOT.
}

  CAFE_OrdenForzarRecalculoTotal                = 'FORZARCALCULOPROPAGADO';
{
  CAFE_OrdenForzarRecalculoTotal                :
        En una hoja de calculo activa una bandera de control.
        Su objetivo es forzar el recalculo propagado, sobre otras
        banderas como la orden anterior.  La idea es activar, esta
        bandera antes de un RECALC, sin necesidad de reescribir
        otras banderas menos prioritarias, y luego desactivarlo.
        Permitido como NOT
}

  CAFE_OrdenBloquearCasillas    = 'BLOQUEARCASILLAS';
{
  CAFE_OrdenBloquearCasillas                    :
        Esta orden impide la escritura de casillas.
        Permitido como NOT.
}

  CAFE_OrdenCopiarCasillas      = 'COPIARCASILLAS()';
{
  CAFE_OrdenCopiasCasillas      :
        CopiarCasillas( A1:B3, C4 )
        Tolera rangos y casillas.  La regla es que deben de ser de
        tamano multiplo, o bien una casilla unica.  En caso de
        superposicion, deben de concordar en alguna esquina.
}

  CAFE_OrdenMoverCasillas       = 'MOVERCASILLAS()';
{
  CAFE_OrdenMoverCasillas       :
        MoverCasillas( A1:B4, D7 )
        MoverCasillas( rango o casilla, casilla )
        Copia, borrando el original.  No tiene los impedimentos de
        CopiarCasillas, pero se exige zona accesible a escritura.
        Borra el origen y genera la copia respectiva.
}

  CAFE_OrdenHojaReinicio        = 'HOJAREINICIO';
{
  CAFE_OrdenHojaReinicio        :
        La orden Hoja Reinicio intenta llevar el manejador actual a
        condiciones iniciales.  El tamano no cambiara.
}

  CAFE_OrdenFilaNull            = 'FILANULL()';
{
  CAFE_OrdenFilaNull            :
        Anula una fila sin eliminar el espacio disponible y
        probablemente el formato quede intacto
        FilaNull( C4 )
        FilaNull( casilla )
        La fila se indica con una casilla, se borra la fila respectiva.
}

  CAFE_OrdenEliminarFila        = 'ELIMINARFILA()';
{
  CAFE_OrdenEliminarFila        :
        Anula y elimina una fila, las casillas desplazadas
        inducen una operacion de movimiento.
        En esta version probablemente exista conflicto con casillas
        bloquedas, generando un error si son afectadas.
        EliminarFila( C3 )
        EliminarFila( casilla )
        se elimina la fila referida por la casilla
}

  CAFE_OrdenInsertarFila        = 'INSERTARFILA()';
{
  CAFE_OrdenInsertarFila        :
        Se agrega una fila Null en la zona de interes, desplazando
        las casillas requeridas con un MOVE inducido.
        En esta version probablemente exista conflicto con
        casillas bloquedas.
        InsertarFila( F3 )
        InsertarFila( casilla )
        Se inserta la fila en la fila pertinente
}

  CAFE_OrdenColumnaNull         = 'COLUMNANULL()';
{
  CAFE_OrdenColumnaNull         :
        Anula una columna sin eliminar el espacio disponible y
        probablemente el formato quede intacto
        ColumnaNull( C4 )
        ColumnaNull( casilla )
        La columna se indica con una casilla, se borra la columna respectiva.
}

  CAFE_OrdenEliminarColumna     = 'ELIMINARCOLUMNA()';
{
  CAFE_OrdenEliminarColumna     :
        Anula y elimina una columna, las casillas desplazadas
        inducen una operacion MOVE.
        En esta version probablemente exista conflicto con casillas
        bloquedas, generando un error si son afectadas.
        EliminarColumna( C3 )
        EliminarColumna( casilla )
        se elimina la columna referida por la casilla
}

  CAFE_OrdenInsertarColumna     = 'INSERTARCOLUMNA()';
{
  CAFE_OrdenInsertarColumna     :
        Se agrega una columna Null en la zona de interes, desplazando
        las casillas requeridas con un MOVE inducido.
        En esta version probablemente exista conflicto con
        casillas bloquedas.
        InsertarColumna( F3 )
        InsertarColumna( casilla )
        Se inserta la columna en la columna pertinente
}

  CAFE_OrdenHaciaTemporal       = 'HACIA$TEMPORAL()';
{
  CAFE_OrdenHaciaTemporal       :
        Una de las funciones de $Temporal es servir de pivote, para
        el copiado entre hojas de calculo.
        Hacia$Temporal( rango )
        Hacia$Temporal( D4:G45 )
        Copia la zona indicada en temporal, comenzando en A1 sin
        cambio de desplazamiento.  Probablemente surjan algunos
        errores sintacticos en hojas complejas, pero la copia
        se realizara.
}

  CAFE_OrdenDesdeTemporal       = 'DESDE$TEMPORAL()';
{
  CAFE_OrdenDesdeTemporal       :
        Una de las funciones de $Temporal es servir de pivote, para
        el copiado entre hojas de calculo.
        Desde$Temporal( rango )
        Desde$Temporal( C3:H5 )
        Copia desde A1 y siguentes en temporal a la hoja actual en el
        rango especificado.
}

  CAFE_OrdenUndoSeguridad       = 'GEMELORAPIDO';
{
  CAFE_OrdenUndoSeguridad       :
        Intenta crear una copia de seguridad de corta existencia
        de la hoja actual,
        en CAFE.EXE no se generan copias de seguridad automaticamente,
        el programa principal deberia aplicar a conveniencia esta orden.
        En esta version unicamente esta implementado el Undo de casillas
        de hoja de calculo
}

  CAFE_OrdenUndo                = 'DESHACER()';
{
  CAFE_OrdenUndo                :
        Solicita reestablecer una antigua copia de seguridad de corta
        existencia.
        UNDO( Numero )
        Se aplica Numero MOD ( Total de copias de seguridad )
        Iniciando por cero como la ultima copia
        Si no existen copias de seguridad no hace nada, sin error.
        Sin embargo, si generaria error si el sistema undo
        estuviera de alguna forma inactivo.
  Numero                        : Solicitud de reestablecer como
        Hoja actual una antigua copia de seguridad.
        NOTA: El sistema Undo se borra rapidamente, es probable que
        existan comportamientos imprevistos despues de varias ordenes
        de aplicado la orden UNDOSEGURIDAD.
        Las ordenes que aplican Clear al sistema undo son en general,
        las que crean grupos, hojas de calculo o las borran.  O las
        de activacion.  Tambien los procesos load y save.
        Inclusive en casos donde no seria realmente necesario.  Se
        considera que esta practica puede evitar incoherencias,
        debido a que el sistema undo posee un debil mecanismo
        de control de incoherencias.
}

  CAFE_OrdenNivelesUndo         = 'NIVELESDESHACER()';
{
  CAFE_OrdenNivelesUndo         :
        Establece el total de niveles undo a crear.  El nivel inicial
        es de CAFE_MaximoNivelUndoHojaCalculo en cualquier hoja.
        Esto solo modifica el valor de
        la hoja actual, no afecta hojas subsecuentes.
        CAFE_NivelesUndo( Numero )
        Es admisible un cero, pero esto 'desactiva' el sistema Undo,
        pudiendo reactivarse en llamadas siguientes.
        El sistema undo desactivado generara mensajes de error al
        intentar utilizarse.
  Numero         : Total de niveles undo a utilizar.  Admisible un cero
        para desactivar.
}

  CAFE_OrdenTotalNivelesUndo    = 'TOTALNIVELESDESHACER';
{
  CAFE_TotalNivelesUndo         :
        Por medio de dos ResultREPO si no es proceso LOAD
        indica el primero el Total Maximo de Niveles Undo actual,
        corregible con NIVELESUNDO(),
        y el segundo indica el total efectivamente utilizado
        O sea .Count de la clase Collection respectiva
}

  CAFE_OrdenRecalculo           = 'RECALCULO';
{
  CAFE_OrdenRecalculo           :
        Intenta recalcular toda la hoja.  Pero intenta evitar reporte
        de errores en lo posible.  Excepto interrupciones graves de
        proceso.
}

  CAFE_OrdenModoSimularCalculo  = 'MODOSIMULARCALCULO';
{
  CAFE_OrdenModoSimularCalculo  :
        Si la hoja se vuelve muy lenta, este modo podria dar mayor
        velocidad de rendimiento, pues trata de evitar propagaciones
        de calculo.  Aplicable como NOT.
}

  CAFE_OrdenHabilitarUnCiclo    = 'HABILITARUNCICLO';
{
  CAFE_OrdenHabilitarUnCiclo                    :
        Para usuarios con experiencia, Habilitar un Ciclo impone
        la condicion de ciclico por tomar variante a la siguiente
        asignacion de casilla que haga i.e.
        HABILITARUNCICLO
        A2:=A3
        HABILITARUNCICLO
        A3:=A2
        Normalmente daria un error que se corregiria al activar
        el mecanismo ciclico sin reescribir la casilla,
        La orden HabilitarUnCiclo evita el mensaje de error, aunque
        el ejemplo parece poco util.
        Solo funciona con una asignacion simple, no sirve para varias
        casillas a la vez.
        No es aplicable como NOT.
}

  CAFE_OrdenRaizPreliminar      = 'PUNTOSRAIZPRELIMINAR()';
{
  CAFE_OrdenRaizPreliminar                      :
        Varios metodos Solve, utilizan una busqueda preliminar simple
        secuencial de puntos.  Para intentar iniciar la busqueda
        en una zona conveniente.  Con esta orden se controla,
        el total de puntos de busqueda inicial.  Default es 10.
}

  CAFE_OrdenMaximoCiclosIntegral                = 'MAXIMOCICLOSINTEGRAL()';
{
  CAFE_OrdenMaximoCiclosIntegral                :
        La integral ForInt(), aumenta segun la potencia de dos
        el total de datos a evaluar por iteracion.  Default es 10
        como maximo, para intentar alcanzar la tolerancia solicitada.
        MAXIMOCICLOSINTEGRAL( Numero )
  Numero                        : Numero maximo de iteraciones
        para intentar alcanzar la tolerancia solicitada
}

  CAFE_OrdenMaximoCiclosIntegralInterna         =
                                'MAXIMOCICLOSINTEGRALINTERNA()';
{
  CAFE_OrdenMaximoCiclosIntegralInterna         :
        Numero de veces maximo en que se intenta evaluar la integral
        de una funcional especial predefinida como Laplace o
        ChiSquare.  Podria ser necesario, si intenta una
        exactitud de "muchos decimales".  No aplica
        a funciones de usuario, use MAXIMOCICLOSINTEGRAL().
        Cada nivel sigue una potencia de dos.
}

  CAFE_OrdenEpsilonZero         = 'EPSILONCERO()';
{
  CAFE_OrdenEpsilonZero         :
        Para dar un valor que el programa podria tomar como cero, pero
        solo se le aproxima;  su fin principal es evitar
        falsos mensajes de error debido al redondeo.
        Es util para evitar raices negativas gratuitas, que en realidad
        son cero;  y fines similares.  CAFE.EXE intenta evitar redondeos
        a cero inconvenientes, como es probable en aplicaciones
        cientificas;  aun asi es posible efectos indeseables.  Utilizar
        con cuidado.  Default es 1E-4 (mismo de FreePascal para Single).
}

  CAFE_OrdenEpsilonZeroDeterminante     = 'EPSILONDETERMINATECERO()';
{
  CAFE_OrdenEpsilonZeroDeterminante     :
        Valor para determinar si una matriz tiene determinante cero.
        Su valor default es 1E-8
        EpsilonDeterminanteCero( Numero )
  Numero                         : Valor a asignar a la tolerancia
        al determinante cero
}

  CAFE_OrdenVariableGeneral     = 'VARIABLEGENERAL()';
{
  CAFE_OrdenVariableGeneral     :
        Permite asignar valores a variables de caracter general
        en hojas de calculo y controles
        VARIABLEGENERAL( 'NameVariable', Variante )
  'NameVariable'                : Nombre de la variable general
        a asignar valor
  Variante                      : Valor a asignar a la variable,
        de tipo diverso pero obviamente compatible con 'NameVariable'
}

  CAFE_OrdenActualVariableGeneral               = 'ACTUALVARIABLEGENERAL()';
{
  CAFE_OrdenActualVariableGeneral               :
        Indica en RESULT el valor de la variable
        ACTUALVARIABLEGENERAL('NameVariable')
  'NameVariable'                : Nombre de la variable general
        a asignar valor
}

  CAFE_OrdenRecalculoConErrores = 'RECALCULOCONERRORES()';
{
  CAFE_OrdenRecalculo           :
        Intenta recalcular toda la hoja.  Ademas agrega reporte de errores,
        y devuelve como RESULT lista de resultados en orden
        CAFE_OrdenRecalculoConErrores( A1:B3 );
  Rango                         : Establece la zona a recalcular para
        luego enviar Result con el dato y eventualmente errores si encuentra
}

  CAFE_OrdenCasillaCiclica      = 'CASILLACICLICA()';
{
  CAFE_OrdenCasillaCiclica      :
        Activa o desactiva NOT() la caracteristica ciclica de las casillas,
        CASILLACICLICA( A1:B3
                [,VALOR/RECURSIVA/EVALUAR/RECURSIVAERROR/CUALQUIERTIPO]
                        [,Numero])
  Rango                 : Hay que especificar la zona o casilla del cambio
  [VALOR/RECURSIVA/EVALUAR/RECURSIVAERROR/CUALQUIERTIPO] : para especificar
        el tipo de ciclo.  Si no se especifica, se conserva
        el que ya tiene.  Si no tiene ninguno se asigna VALOR.
        CUALQUIERTIPO asigna Valor.
  Numero                : Ajusta el maximo de conteo de ciclos recursivos
        si aplica.  No afecta el tipo de ciclo.  Se asume que
        se puede modificar su valor, sin activar ciclos.
  NOT()                 : Desactiva los ciclos, si indica el tipo
        desactiva el tipo solicitado o todos si CualquierTipo
        Si indica Numero se ignora.
}

  CAFE_OrdenCasillaIniciativa   = 'CASILLAINICIATIVA()';
{
  CAFE_OrdenCasillaIniciativa   :
        Esta orden marca como casillas que requieren iniciativa
        el rango indicado.
        Este tipo de casillas, intentan impedir la propagacion indirecta
        del calculo.  Es aplicable como NOT.
        CASILLAINICIATIVA( A1:B3 )
  Rango                         : Rango de casillas al que se
        le establece/desactiva la iniciativa
}

  CAFE_OrdenCasillaNull         = 'CASILLANULL()';
{
  CAFE_OrdenCasillaNull         :
        Esta orden asigna Null a las casillas del rango especificado,
        no borra formato.
}

  CAFE_OrdenFormatoCasilla      = 'FORMATOCASILLA()';
{
  CAFE_OrdenFormatoCasilla      :
        No hace nada en esta version y simplemente se ignora,
        necesita mas de un parametro,
        y el primero tiene que ser un rango valido
}

  CAFE_OrdenCasillaATexto       = 'CASILLAATEXTO()';
{
  CAFE_OrdenCasillaATexto       :
        CasillaATexto( A1 )
        Solicita que la casilla indicada, se despliege en Result
        como String de archivo.  Usa el sistema simplificado.
}

TYPE
  CAFE_InterpreteSintacticoString               =
                                  PACKED CLASS ( CAFE_Interprete2Sintactico )
{
  Clase evolucionada de CAFE_Interprete2Sintactico
  cuyo objetivo principal es agregarle traducciones a ciertas ordenes
  de pipa.  Para que el usuario disponga de opcion en Espanos e Ingles.
  Podria facilmente incorporarse otros idiomas.
}

CONSTRUCTOR Create; override;
{
  Constructor fundamental de la clase
}

CONSTRUCTOR Create
  ( CONST Nombre                : ShortString;
          NuevoValor            : Variant                       ); override;
{
  Simplemente una nueva version del constructor para lo mismo
}

PROCEDURE   DefaultPredefinidos
  (       Manejador             : CAFE_InterfaceBasico;
          Quimico               : Boolean;
          Graficador            : Boolean       = FALSE         ); override;
{
  PROCEDURE DefaultPredefinidos
        Sobre su version anterior, agrega traducciones a las ordenes
        de la pipa.
  Manejador                     : la version actual utiliza el manejador
        para accesar a las traducciones y errores.
  Quimico                       : TRUE activa lista de identificadores
        utiles a gusto del autor del programa.  Utiliza reglas
        que no corresponde con el Standard.
  Graficador                    : TRUE desactiva algunos procesos
        para ahorra velocidad, probablemente no muy utiles
        en la programacion del graficador de EJES.EXE
}

PROCEDURE   ReinicioPaquetePredefinido; virtual;
{
  PROCEDURE ReinicioPaquetePredefinido;
        Recorre el paquete de variables, y desactiva cualquier variable
        que no sea predefinida ni ManejadorPrincipalNITI,
        No muy eficiente, pues
        el espacio en memoria se conserva en esta version.
}

DESTRUCTOR  Destroy; override;
{
  Destructor principal de la clase
}

                                  END;
                                  { CLASS CAFE_InterpreteSintacticoString }

TYPE
  CAFE_NudoSintacticoString     = PACKED CLASS ( CAFE_Nudo2Sintactico )
{
  Esta clase incorpora sintaxis e interpretacion simple
  de algunas ordenes de pipa.  Como la sintaxis es tan simple,
  las ordenes se nudillan y la interpretacion es directa, muchas
  en Self.
}

CONSTRUCTOR Create; override;
{
  Constructor de clase basico, genera un identificador unico interno
}

CONSTRUCTOR Create
  (     Ide                     : LongInt                       ); override;
{
  Constructor de clase basico, permite obligar el identificador Ide.
        Esto es util, por ejemplo, en procesos de copia
}

CONSTRUCTOR Create
  (     Ide                     : LongInt;
        NuevoDato               : Variant                       ); override;
{
  Constructor de clase basico, version evolucionada para lo mismo
  que la anterior version.
}

  Public
PROCEDURE   EjecutarOrdenHoja
  ( CONST OrdenPipe             : ShortString;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico          ); virtual;
{
  PROCEDURE EjecutarOrdenHoja
        Este PROCEDURE es el objetivo de esta herencia.
        La orden se recibe Nudillada y en OrdenPipe.  Actua
        como distribuidor, aunque procesa tambien muchas casi por si
        mismo.  Esta disenado para acoplar futuras herencias,
        mediante el concepto
        BEGIN
          Procesamiento de nuevas ordenes
          ELSE Inherited
        END
        Esta version genera RAISE de no decidir la orden.
  OrdenPipe                     : Es la orden recibida por la pipa,
        aunque tambien deberia estar nudillada en Self.
        OrdenPipe probablemente sea util en asignaciones.
        Esto lo vuelve algo ineficiente, pues hay un doble proceso
        de nudillado.
  NumeroRenglon                 : Util en mensajes de error y similar.
        Indica el renglon de pipa de procesamiento.
  CodigoAcumulado               : Util para la generacion de mensajes
        de error.  Pues incluye la repeticion de cada tipo
        de mensaje, que es parte de su estructura.
  Manejador                     : interprete de ordenes asociados
        al ManejadorBasico actual.  En esta version, probablemente
        contenga una hoja de calculo.  Aunque no todas las ordenes
        lo requieren.
}

  Private
PROCEDURE   EjecutarOrdenSave
  ( CONST ArchivoString         : ShortString;
    CONST GrupoString           : ShortString;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico          ); virtual;

  Private
PROCEDURE   EjecutarOrdenLoad
  ( CONST ArchivoString         : ShortString;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico          ); virtual;

  Private
PROCEDURE   EjecutarOrdenIdentificadorHoja
  ( CONST OrdenPipe             : ShortString;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico;
          BanderaNOT            : Boolean       = FALSE         ); virtual;

  Private
FUNCTION    EjecutarOrdenEvaluarCasilla
  (       Fila, Columna         : LongInt;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico;
          BanderaWritePipe      : Boolean       = TRUE;
          BanderaWriteErrors    : Boolean       = FALSE
                                                ) : ShortString; virtual;

  Private
PROCEDURE   EjecutarOrdenCopiaCasillaTemporal
  (       Fila, Columna, FilaTemporal, ColumnaTemporal  : LongInt;
          HaciaDesdeTemporal    : Boolean;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico          ); virtual;

FUNCTION    LeerStObligatorio
  (       BanderaProhibirNull   : Boolean       = FALSE ) : ShortString;
{
  FUNCTION LeerStObligatorio
        En la interpretacion de ordenes de pipa, lee en Self obligado
        un ShortString.  Es conveniente, pues el proceso de gramatica
        convierte los String y Char en ordenes Basicas.  Esta FUNCTION
        invierte el proceso devolviendo el ShortString.
  BanderaPorhibirNull           : Algunas ordenes toleran un NullString
        como '', otras no lo toleran.  Con TRUE, genera un RAISE si
        encuentra un NullString.
  FUNCTION LeerStObligatorio                    : devuelve el ShortString
        solicitado.  RAISE si no encuentra el String.
}

FUNCTION    LeerStIdentificadorObligatorio                : ShortString;
{
  FUNCTION LeerStIdentificadorObligatorio       :
        Lee DatoElemento, buscando un identificador valido introducido
        como String (por eso se llama StIdentificador).
        Si lo encuentra, lo devuelve en FUNCTION, si no RAISE.
  FUNCTION LeerStIdentificadorObligatorio       : si lo encuentra,
        devuelve el identificador solicitado.
}

FUNCTION    LeerLongIntObligatorio
  (       Manejador             : CAFE_InterfaceBasico  = NIL;
          EquivalenteString     : TStringDynArray       = NIL;
          EquivalenteValor      : TIntegerDynArray      = NIL   ) : LongInt;
{
  FUNCTION LeerLongIntObligatorio
        Su objetivo es leer un LongInt en Self.  Sin embargo,
        opcionalmente permite pasar valores LongInt como palabras clave
        contenidas en Self.  Manejador se utiliza por si es necesario
        traducir previamente la palabra clave.
  Manejador                     : Util por si es necesario traducir
        palabras clave.
  EquivalenteString             : Lista de palabras clave que seran
        reconocidas como LongInt.
  EquivalenteValor              : Valores asociadaso a las palabras clave.
  FUNCTION LeerLongIntObligatorio               : devuelve el valor
        LongInt encontrado.
}

FUNCTION    LeerFloatObligatorio
  (       Manejador             : CAFE_InterfaceBasico  = NIL;
          EquivalenteString     : TStringDynArray       = NIL;
          EquivalenteValor      : TDoubleDynArray       = NIL   ) : Double;
{
  FUNCTION LeerFloatObligatorio
        Su objetivo es leer un float en Self.  Sin embargo,
        opcionalmente permite pasar valores float como palabras clave
        contenidas en Self.  Manejador se utiliza por si es necesario
        traducir previamente la palabra clave.
  Manejador                     : Util por si es necesario traducir
        palabras clave.
  EquivalenteString             : Lista de palabras clave que seran
        reconocidas como Float.
  EquivalenteValor              : Valores asociadaso a las palabras clave.
  FUNCTION LeerFloatObligatorio                 : devuelve el valor
        float encontrado.
}

FUNCTION    LeerSelectorAlternativaObligatorio
  (       Manejador             : CAFE_InterfaceBasico;
          EquivalenteString     : TStringDynArray               ) : LongInt;
{
  FUNCTION LeerSelectorAlternativaObligatorio
        Su objetivo es leer una alternativa escrita en Self.DatoElemento
        Su posicion en EquivalenteString se devuelve en FUNCTION,
        o RAISE si no lo encuentra
  Manejador                     : Util por si es necesario traducir
        palabras clave.
  EquivalenteString             : Lista de palabras clave que seran
        reconocidas.
  FUNCTION LeerSelectorAlternativaObligatorio   : devuelve la
        posicion de la alternativa encontrada obligatoria.
}

PROCEDURE   LeerCasillaObligatorio
  ( OUT   Fila, Columna         : LongInt;
          Manejador             : CAFE_InterfaceBasico                  );
{
  PROCEDURE LeerCasillaObligatorio
        Su objetivo es leer en Self.DatoElemento un nombre de casilla
        valido segun Manejador que debe contener una Hoja de Calculo
        bien definida.  Se revisa que se encuentra en el rango valido.
        Los fallos se indican con RAISE
  Fila                          : Devuelve el numero de Fila indicado
        a partir de cero.
  Columna                       : Devuelve le numero de Columna indicado
        a partir de cero.
  Manejador                     : Necesario para conocer la hoja
        de calculo y su tamano.
}

PROCEDURE   LeerRangoCasillaObligatorio
  ( OUT   FilaI, ColumnaI       : LongInt;
    OUT   FilaF, ColumnaF       : LongInt;
          Manejador             : CAFE_InterfaceBasico                  );
{
  PROCEDURE LeerRangoCasillaObligatorio
        Su objetivo es leer un rango de casillas.  Self.DatoElemento
        seria previamente un nombre de casilla, o bien un
        operador de rango con dos nombres de casillas descendientes,
        como es usual en el nudillado de estructuras como A1:B3,
        la casilla se traducira a rango.
        NOTA : el rango se reporta ordenado usual de Menor:Mayor,
        el orden inverso se invierte y se reporta ordenado.
  FilaI                         : Devuelve el numero de Fila menor a partir
        de cero.
  ColumnaI                      : Devuelve el numero de Columna menor a
        partir de cero.
  FilaF                         : Devuelve el numero de Fila mayor a partir
        de cero.
  ColumnaF                      : Devuelve el numero de Columna mayor a
        partir de cero.
  Manejador                     : Necesario para conocer la hoja
        de calculo y su tamano.
}

FUNCTION    InProcesoLoad                                       : Boolean;
{
  FUNCTION InProcesoLoad
        Se determina si la orden actual se ejecuta en el interior
        de un proceso Load.  Esto afecta a muchas instrucciones.
        CUIDADO: Resultados inesperados fuera de una secuencia de pipa.
  FUNCTION InProcesoLoad        : TRUE indica que se encuentra actualmente
        en un proceso Load de pipa.  FALSE La ejecucion de pipa no es Load.
}

FUNCTION    InProcesoVerbose                                    : Boolean;
{
  FUNCTION InProcesoVerbose
        Se determina si la orden actual requiere un amplio verbose o no.
        Por ejemplo, los procesos Load desactivan el Verbose, entre otras
        cosas para evitar falsas inconsistencias sintacticas, generadas
        en el orden de carga.
  FUNCTION InProcesoVerbose     : TRUE indica que el proceso actual no
        limita el verbose, FALSE si lo limita.
}

  Public
CONSTRUCTOR Create
  (     Modelo                  : CAFE_NudoSintactico           ); override;
{
  Constructor de clase, que utiliza un modelo para adquirir datos,
        incluyendo el numero identificador.
}

DESTRUCTOR  Destroy; override;
{
  Destructor usual de clase
}

                                  END;  { CLASS CAFE_NudoSintacticoString }

  CAFE_DatoNudilladoString      = PACKED CLASS ( CAFE_DatoNudillado )
{
  Clase cuyo objetivo es la traduccion a String o inversa de
  de CAFE_DatoNudilladoString que contiene informacion importante
  de control de funciones en casillas de Hoja de Calculo
  Genera el parentesis de las casillas como
        A1(X,2.1):=3*B3
  Self seria responsable de manejar el "(X,2.1)"
        ($0000,XX,VAR1,0.0,VAR2,0.0,VAR3,0.0)
        $0000   : hexadecimal optativo describe las funcion, su uso principal
                  es agregarle caracteristicas recursivas.
                  No es necesario declarar el numero de variables aqui.
        XX      : optativo CicloConteo como entero.  Si aparece
                  CicloConteo es obligatorio $0000
        El resto UNICAMENTE util en macros
        VAR1    : nombre primer identificador obligatorio en macros
        VAR2    : nombre segundo identificador para macros 2D o 3D
        VAR3    : nombre tercer identificador para macros 3D
        0.0     : valor default de prueba, necesario si se solicita
                  otro valor de prueba
  Clave hexadecimal es
    ActivoHCGM                  = $0001; // obligatoria
    BasicoStandardHCGM          = $0002; // obligatoria en esta version
    ActivarCicloHCGM            = $0010; // obligatoria si ciclico
    CicloTomarVariantHCGM       = $0020; //   elegir una de
    CicloEvaluarHCGM            = $0004; //   las tres
    CicloConteoHCGM             = $0040; //   obligado si ciclico
    FinConteoErrorHCGM          = $0008;
    CasillaIniciativaHCGM       = $0080;
}

CONSTRUCTOR Create; override;
{
  Constructor de clase fundamental
}

FUNCTION    ToString                            : AnsiString; override;
{
  FUNCTION ToString
        Convierte a String Self, como parentesis con informacion
        descriptora de funciones y macro.  Intenta evitar informacion
        redundante a partir del default.
  FUNCTION ToString                             : devuelve el String
        que representa a Self en una definicion de casillas,
        como parentesis.
}

FUNCTION    PeticionSimilarBaseString
  ( CONST BaseString                    : AnsiString                    )
                                        : CAFE_DatoNudilladoString; virtual;
{
  FUNCTION PeticionSimilarBaseString
        A partir de Self genera una copia similar, y utiliza BaseString
        para realizar modificaciones.  Utiliza valores default
        cuando no se indicar.  BaseString es un parentesis con
        datos descriptores segun reglas usuales.
  BaseString                                    : String de parentesis
        con descripcion para la FUNCTION
  FUNCTION PeticionSimilarBaseString            : Devuelve el dato
        CAFE_DatoNudilladoString solicitado.
}

DESTRUCTOR  Destroy; override;
{
  Destructor basico de clase
}

                                  END;  { CAFE_DatoNudilladoString }

  CAFE_HojaCalculoString        = PACKED CLASS ( CAFE_HojaCalculoBase )
{
  Clase para agregarle a la hoja de calculo, crear listas de Strings
  que describan a si misma
}

  Public
CONSTRUCTOR Create
  (       ACollection           : TCollection                   ); override;
{
  CONSTRUCTOR Mejor eliminar su uso
        y programar una nueva version del TStreamCollection.ADD con
        parametros
        TStreamCollection.Add( Filas, Columnas )
}

  Public
CONSTRUCTOR Create
  (       ACollection           : TStreamCollection;
          Filas, Columnas       : LongInt                       ); override;
{
  Constructor basico de clase
}

DESTRUCTOR  Destroy; override;
{
  Destructor basico de clase
}

FUNCTION    CasillaToString
  (       Fila, Columna         : LongInt                       ) : String;
{
  FUNCTION CasillaToString
        Examina Fila y Columan y genera un String descriptor.
        Ignora errores sintacticos; pero podria surgir RAISE
        por fuera de rango o dato corrompido.
  Fila                          : Fila a partir de cero
        de la casilla a convertir a String.
  Columna                       : Columna a partir de cero
        de la casilla a convertir a String.
  FUNCTION CasillaToString      : devuelve la casilla indicada como String.
}

PROCEDURE   StringToCasilla
  (       Manejador             : CAFE_InterfaceBasico;
    CONST MyString              : String                                );
{
  PROCEDURE StringToCasilla
        Recibe MyString que debe detener el formato de
        asignacion de casilla. i.e.: A1():=sum(Z1:Z2)
        y aplica null y luego agrega el dato.
        Unicamente entiende este tipo de asignaciones simples.
  Manejador                     : necesario para la correcta
        interpertacion del dato
  MyString                      : contiene el String de la asignacion
  NOTA: los errores de poca importancia, probablemente generen
        RAISE CAFE_PipeCasillaException;  el dato
        probablemente se generara pero es probable que tenga
        defectos.
}

FUNCTION    IsCasillaBloqueada
  (       Fila, Columna         : LongInt                       ) : Boolean;
{
  FUNCTION IsCasillaBloqueada
        Su objetivo es determinar si Fila, Columna contiene una
        casilla bloqueada.  En esta version probablemente sea
        poco util, pues solo se puede bloquear la hoja completa.
  Fila                          : numero de fila a partir de cero,
        de la casilla a la que se le quiere determinar condicion de bloqueo.
  Columna                       : numero de columna a partir de cero,
        de la casilla a la que se le quiere determinar condicion de bloqueo.
  FUNCTION IsCasillaBloqueada   : TRUE indica bloque, FALSE no bloqueo.
}

FUNCTION    IsZonaCasillaBloqueada
  (       FilaI, ColumnaI, FilaF, ColumnaF
                                        : LongInt       ) : Boolean; virtual;
{
  FUNCTION IsZonaCasillaBloqueada
        Su objetivo es determinar si en la zona rectangular indicada
        existe alguna casilla con bloqueo de escritura.  En esta version
        probablemente sea poco util, pues solo se puede bloquear
        la hoja completa.
        Puede invertirse el orden.
  FilaI                         : numero de fila a partir de cero,
        de la esquina superior izquierda de la zona de casillas
        a determinar condicion de bloqueo.
  ColumnaI                      : numero de columna a partir de cero,
        de la esquina superior izquierda de la zona de casillas
        a determinar condicion de bloqueo.
  FilaF                         : numero de fia a partir de cero,
        de la esquina inferior derecha de la zona de casillas
        a determinar condicion de bloqueo.
  ColumnaF                      : numero de columna a partir de cero,
        de la esquina inferior derecha de la zona de casillas
        a determinar condicion de bloqueo.
  FUNCTION IsZonaCasillaBloqueada               : TRUE si alguna
        casilla de la zona esta bloqueada, FALSE si todas
        las casillas de la zona estan libres de bloqueo.
}

PROCEDURE   VariantHojaToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL           );
{
  PROCEDURE VariantHojaToTStringList
        El objetivo de PROCEDURE es agregarle a MyList una lista
        de String con la informacion suficiente para generar
        las casillas de la hoja de calculo.  La lista agregada
        contiene unicamente asignaciones.
  MyList                        : Lista de Strings a la que se le agregara
        la informacion resultante.  Una hoja vacia no agregaria nada.
        La lista puede ya estar comenzada.
  NumeroRenglon                 : Numero de renglon de pipa de ejecucion,
        util en el procesamiento de pipa, para los mensajes generados.
  CodigoAcumulado               : Repeticion por cada tipo de mensaje
        en un renglon de pipa.
  ErrorList                     : Agrega errores a la lista que
        no necesita estar vacia.  Si es NIL,
        los errores probablemente produzcan errores graves que
        terminen el programa.
}

PROCEDURE   HojaCalculoToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL           );
{
  PROCEDURE HojaCalculoToToTStringList
        El objetivo de PROCEDURE es agregarle a MyList una lista
        de String con la informacion suficiente para rellenar
        la hoja de calculo.  Note que es rellenar, no inicializa la hoja,
        de eso se encarga el Manejador respectivo.
  MyList                        : Lista de Strings a la que se le agregara
        la informacion resultante.
  NumeroRenglon                 : Numero de renglon de pipa de ejecucion,
        util en el procesamiento de pipa, para los mensajes generados.
  CodigoAcumulado               : Repeticion por cada tipo de mensaje
        en un renglon de pipa.
  ErrorList                     : Agrega errores a la lista que
        no necesita estar vacia.  Si es NIL,
        los errores probablemente produzcan errores graves que
        terminen el programa.
}

PROCEDURE   FormatoHojaToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL   ); virtual;
{
  PROCEDURE FormatoHojaToToTStringList
        El objetivo de PROCEDURE es agregarle a MyList una lista
        de String con la informacion suficiente para generar el formato
        de la hoja de calculo.  El formato actual es bastante pobre.
        Cumple la funcion de preparar futuras versiones.
  MyList                        : Lista de Strings a la que se le agregara
        la informacion resultante.
  NumeroRenglon                 : Numero de renglon de pipa de ejecucion,
        util en el procesamiento de pipa, para los mensajes generados.
  CodigoAcumulado               : Repeticion por cada tipo de mensaje
        en un renglon de pipa.
  ErrorList                     : Agrega errores a la lista que
        no necesita estar vacia.  Si es NIL,
        los errores probablemente produzcan errores graves que
        terminen el programa.
}

PROCEDURE   HojaReinicio; virtual;
{
  PROCEDURE HojaReinicio
        Su objetivo es volver la hoja a condiciones iniciales
        sin cambio de dimensiones,
        ignora las condiciones bloqueadas borrando la informacion,
        pero genera RAISE sin afectar la hoja
        si esta activa el descriptor general de bloqueo
}

                                  END;  { CAFE_HojaCalculoString }

  CAFE_ManejadorBasicoString    = PACKED CLASS ( CAFE_ManejadorBasico )
{
  Clase cuyo objetivo es agregarle a CAFE_ManejadorBasico la capacidad
  de generar una lista de Strings descriptores de su estado.
  En su mayoria relegara esta funcion a sus clases controladas.
}

CONSTRUCTOR Create
  (       ACollection           : TCollection                   ); override;
{
  Constructor basico de la unidad.  Los manejadores probablemente
  se generen a travez de alguna TCollection y no directamente.
}

PROCEDURE   ManejadorToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL   ); virtual;
{
  PROCEDURE ManejadorToTStringList
        El objetivo de PROCEDURE es agregarle a MyList una lista
        de String con la informacion suficiente para generar el Manejador
  MyList                        : Lista de Strings a la que se le agregara
        la informacion resultante.
  NumeroRenglon                 : Numero de renglon de pipa de ejecucion,
        util en el procesamiento de pipa, para los mensajes generados.
  CodigoAcumulado               : Repeticion por cada tipo de mensaje
        en un renglon de pipa.
  ErrorList                     : Agrega errores a la lista que
        no necesita estar vacia.  Si es NIL,
        los errores probablemente produzcan errores graves que
        terminen el programa.
}

PROCEDURE   VariableGeneralToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL   ); virtual;
{
  PROCEDURE VariableGeneralToTStringList
        El objetivo de PROCEDURE es agregarle a MyList una lista
        de String con la informacion suficiente para generar ciertas
        variables generales del Manejador.  Es probable que no
        se genere ningun mensaje si todos los valores son default.
  MyList                        : Lista de Strings a la que se le agregara
        la informacion resultante.
  NumeroRenglon                 : Numero de renglon de pipa de ejecucion,
        util en el procesamiento de pipa, para los mensajes generados.
  CodigoAcumulado               : Repeticion por cada tipo de mensaje
        en un renglon de pipa.
  ErrorList                     : Agrega errores a la lista que
        no necesita estar vacia.  Si es NIL,
        los errores probablemente produzcan errores graves que
        terminen el programa.
}


PROCEDURE   DesvincularTodoPaquete;
{
  PROCEDURE DesvincularTodoPaquete
        Desactiva todos los identificadores de paquetes vinculados
        con Self.  Los paquetes vinculados, son aquellos cuyas
        variables pueden llamarse desde Self como campos
        del identificador de paquete.
        Por supuesto, Self y su propio nombre no son afectados.
}

PROCEDURE   ReinicioHojaManejadorBasico; virtual;
{
  PROCEDURE ReinicioHojaManejadorBasico
        Llama al Reinicio de hoja, y reestablece valores Default de
        varias variables.  No afecta definiciones de Paquetes de
        variables y traducciones, ni enlaces
}

  Public
DESTRUCTOR  Destroy; override;
{
  Destructor principal de clase
}

                                  END;  { CAFE_ManejadorString }

  CAFE_TCollectionItemSave      = CLASS ( TCollectionItem )
{
  Clase cuyo objetivo es controlar un grupo Save.
  Un Grupo Save es el que se guardara en Disco con una unica llamada
  a proceso Save tipico.  Probablemente sus manejadores se intercomuniquen
  con acceso simple a sus variables como campos de registro;  aunque
  no es necesario.  Probablemente generen un unico archivo;  aunque no
  es necesario tampoco.
  La idea no obligatoria es que los grupos Save sean casi independientes y
  completamente funcionales y con amplia comunicacion como grupo.
}

  Public
    NombreItemSave              : ShortString;
{
  NombreItemSave                : El grupo Save tiene un nombre, no
        se supone un DisplayNombre ni nombre de archivo,
        es mas bien un selector de grupo que varia con cada ejecucion.
        Es obligatorio que sea unico en la ejecucion.
        NOTA: los nombres de manejadores no necesitan ser unicos,
        pero deben ser unicos en un grupo Save;
        esta unicidad de nombre de manejador es responsabilidad
        del usuario.
}

    ListaManejadoresSave        : TFPList;
{
  ListaManejadoresSave          : contiene una lista de manejadores,
        note que es TFPList, previendo alta versatilidad.
        En esta version unicamente se entienden CAFE_ManejadorBasicoString,
        de lo contrario se generara error en muchos procesos.
        NOTA: la destruccion FreeAndNil( ListaManejadoresSave ) no
        destruye los manejadores.
}

  Public
CONSTRUCTOR Create
  (       ACollection           : TCollection                   ); override;
{
  Herencias de TStreamCollectionItem nunca deberian crearse en forma
  independiente (ver Manual Classes)
}

FUNCTION    IsPrimerAislado
  (       Manejador             : CAFE_InterfaceBasico  ) : Boolean; virtual;
{
  FUNCTION IsPrimerAislado
        Su objetivo es determinar si el primer manejador en lista
        es aislado o no.  Ningun manejador es FALSE.  La condicion
        TRUE tiene la propiedad de intentar no agregar mas manejadores
        a la lista.  La idea, es que la generacion de una nueva hoja de
        calculo u objeto manejador;
        inmediatamente desactiva el grupo save actual.
}

FUNCTION    ContieneNombresDuplicados
  ( OUT   NombreDuplicado       : ShortString           ) : Boolean; virtual;
{
  FUNCTION ContieneNombresDuplicados
        Verifica que el grupo contiene o no nombres de ManejadorBasico
        duplicados, esto es util en algunos procesos donde se encuentra
        prohibido como Load y Save
  NombreDuplicado               : En caso TRUE devuelve un nombre duplicado
        que encuentre, por supuesto;  no necesariamente el unico
}

DESTRUCTOR  Destroy; override;
{
  Destructor de clase de la unidad
}

                                          END;
                                          { CLASS CAFE_TCollectionItemSave }

  CAFE_TCollectionSave                  = CLASS ( TOwnedCollection )
{
  Clase Collection referida a CAFE_TCollectionItemSave
  Se supone contendra los grupos Save del programa
  (grupos abiertos que se guardan en disco como grupo en una
  operacion Save)
}

  Public
CONSTRUCTOR Create
  (       AOwner                : TPersistent                   ); virtual;
{
  Constructor fundamental de clase
}

FUNCTION    GrupoVacio
  ( CONST NombreGrupo           : ShortString                   ) : Boolean;
{
  FUNCTION GrupoVacio
        Determina si NombreGrupo hace referencia a un grupo Save vacio.
        Un nombre inexistente se considera TRUE sin error.
        La condicion vacio se refiere a
        CAFE_TCollectionItemSave.ListaManejadoresSave
  NombreGrupo                   : Se refiere al nombre de grupo,
        que se buscara concordancia para establecer si vacio o no.
        Se refiere al campo CAFE_TCollectionItemSave.NombreItemSave.
  FUNCTION NombreGrupo          : TRUE indica que el grupo aludido
        efectivamente esta vacio.  FALSE indica que ya existen
        manejadores previos.
}

FUNCTION    BuscarNombreGrupoSave
  ( CONST NombreGrupo           : ShortString   ) : CAFE_TCollectionItemSave;
{
  FUNCTION BuscarNombreGrupoSave
        Revisa los elementos CAFE_TCollectionItemSave.NombreItemSave
        buscando una concordancia de NombreGrupo.
        El primer item encontrado (deberia ser unico sin error),
        se devuelve en FUNCTION o NIL si no encuentra.
  NombreGrupo                   : Se refiere al NombreItemSave a buscar
        en lista de CAFE_TCollectionItemSave.
  FUNCTION BuscarNombreGrupoSave                : El item devuelve es
        el primero que cumpla el criterio o NIL si no encuentra.
}

FUNCTION    BuscarGrupoSaveManejador
  (       MyManejadorBasico     : CAFE_ManejadorBasico
                                                ) : CAFE_TCollectionItemSave;
{
  FUNCTION BuscarGrupoSaveManejador
        Busca en la lista de CAFE_TCollectionItemSave el primer item
        que encuentre que contenga MyManejadorBasico es
        CAFE_TCollectionItemSave.ListaManejadoresSave o NIL si no encuentra.
  MyManejadorBasico             : Tipo de CAFE_ManejadorBasico o descendiente
        a buscar en las listas de grupo Save.
  FUNCTION BuscarGrupoSaveManejador             : Retorna el primer
        CAFE_TCollectionItemSave que encuentre y cumpla el criterio.
        NIL si no lo encuentra.
}

FUNCTION    GenerarNuevoNombreGrupo                             : ShortString;
{
  FUNCTION GenerarNuevoNombreGrupo
        El objetivo de FUNCTION es generar un nombre de GrupoSave
        con la seguridad de que es unico, en el momento de generado.
        Los nombres de GrupoSave sirven como controles, no
        se suponen que sean utiles al usuario.  Ademas
        probablemente cambien de ejecucion en ejecucion de CAFE.EXE
  FUNCTION GenerarNuevoGrupoSave        : devuelve el nuevo nombre de grupo
        Save, con la seguridad de que es unico.
}

PROCEDURE   AgregarManejadorBasicoGrupoSave
  ( CONST NombreGrupo           : ShortString;
          MyManejadorBasico     : CAFE_ManejadorBasico                  );
{
  PROCEDURE AgregarManejadorBasicoGrupoSave
        Busca el GrupoSave representado por NombreGrupo, y agrega
        MyManejadorBasico a la lista de manejadores del grupo.
        Este PROCEDURE no se preocupa por vinculaciones, ni
        las consulta.
        Antes de agregar MyManejadorBasico fuerza eliminar
        de MyManejadorBasico en todo grupo.  Sin embargo,
        las referencias internas, podrian mantenerse activas.
  NombreGrupo                   : Nombre de Grupo Save al que se
        anadira MyManejadorBasico.
  MyManejadorBasico             : Manejador a agregar a NombreGrupo.
        Se fuerza desaparecerlo de todo grupo antes.  Se conservarian
        las referencias internas.
}

PROCEDURE   AgregarManejadorBasicoGrupoSaveVinculado
  ( CONST NombreGrupo           : ShortString;
          MyManejadorBasico     : CAFE_ManejadorBasico                  );
{
  PROCEDURE AgregarManejadorBasicoGrupoSaveVinculado
        Misma funcion que AgregarManejadorBasicoGrupoSaveVinculado,
        pero con las funciones adicionales de
        Antes de anexar...
        A. desactivarse como variable;
        en todos los grupos en que se encontraba previamente presente.
        B. Desactiva todos los manejadores que
        identifique como variable en el interior de MyManejadorBasico.
        Despues de anexar...
        C. Se activa como variable reconocida en todos los manejadores
        pertinentes en NombreGrupo (no hace caso a tipo aislado)
        D. Activa todos los interpretes en NombreGrupo, como variables
        internas en MyManejadorBasico
        CUIDADO:
        Manejadores fuera de la zona afectada, no seran modificados
        del todo.  Y si tenian a MyManejadorBasico como variable
        de acceso, lo seguiran accesando.  Es decir, solo
        afecta GruposSave nuevo y viejo.
        Probablemente surjan inconsistencias en casillas de hoja
        de calculo y otras definiciones que hayan utilizado
        a MyManejadorBasico como variable.  Pues estos usos se conservan.
  NombreGrupo                   : Nombre de Grupo Save al que se
        anadira MyManejadorBasico.
  MyManejadorBasico             : Interprete que se asociara y
        vinculara segun el proceso anterior.
}

PROCEDURE   EliminarManejadorBasicoTodoGrupoSave
  (       MyManejadorBasico     : CAFE_ManejadorBasico                  );
{
  PROCEDURE EliminarManejadorBasicoTodoGrupoSave
        Procede a buscar MyManejadorBasico en todas las
        listas de ManejadoresSave en la colleccion, y realiza su eliminacion
        simple;  sin otros cuidados adicionales.
  MyManejadorBasico             : Manejador a buscar en las
        listas.
}

PROCEDURE   EliminarManejadorBasicoTodoGrupoSaveVinculado
  (       MyManejadorBasico     : CAFE_ManejadorBasico                  );
{
  PROCEDURE EliminarManejadorBasicoTodoGrupoSaveVinculado
        Misma funcion que EliminarManejadorBasicoTodoGrupoSave,
        pero procede a:
        A. desactivarse como variable;
        en todos los grupos en que se encontraba previamente presente.
        B. Desactiva todos los manejadores que
        identifique como variable en el interior de MyManejadorBasico.
  MyManejadorBasico             : Manejador a buscar en las
        listas.
}

DESTRUCTOR  Destroy; override;
{
  Destructor basico de la clase
}

                                          END;  { CLASS CAFE_TCollectionSave }

  CAFE_TCollectionManejadorString       = CLASS
                        ( CAFE_TCollectionManejador0, CAFE_InterfacePipe )
{
  CAFE_TCollectionManejadorString       : incorpora funcionalidad
        de CAFE_InterfacePipe.  Aunque en realidad, unicamente
        implementa el procesamiento OnExecuted
}

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
    Private
  InterfaceManejadorActivo      : CAFE_InterfaceBasico;
{
  InterfaceManejadorActivo      : Es la interface que actual,  que
        interpreta y ejecuta las ordenes (como String)
}
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

  GrupoSaveActivo               : ShortString;
{
  GrupoSaveActivo               : Indica cual es le grupoSave actual
        al que se dirigen las operaciones que podrian afectarlo.
        Como la creacion de un nuevo elemento interprete.
}

  BanderaMantenerGrupoSave      : Boolean;
{
  BanderaMantenerGrupoSave      : Muchas operaciones se acumulan
        en un mismo grupoSave condicion TRUE.
        Sin embargo, algunas declaraciones
        como la de hoja AISLADA, solicitan un pronto cambio
        de grupo SAVE si se generara una siguiente hoja.
        La condicion FALSE indica que se pretende no agregar
        nuevos elementos interpretes al actual grupo SAVE i.e. el grupo
        Save es Aislado o TEMPORAL.
}

  ListaGruposLoadSave           : CAFE_TCollectionSave;
{
  ListaGruposLoadSave           :
        Los interpretes en CAFE.EXE se agrupan en colecciones LOAD
        SAVE a los que se le aplica SAVE o LOAD como grupo.
        Aqui se tiene la informacion total ordenada;
        algunos se destruiran internamente otros externamente
        como los interpretes
}

  ListaManejadoresLoad          : TStringList;
{
  ListaManejadoresLoad          :
        Algunas reglas de un proceso Load
        Estas reglas surgen para proteger al usuario de errores
        de diseno y mala fe.
  A. No se permite la duplicacion de nombres de manejador al
        interior ni en anidamiento.
        Si requiere duplicacion de nombres utilice un proceso TXT de
        configuracion.
        El proceso Load si puede utilizar nombres ya existentes;
        pero no puede repetir nombres en su interior.
  B. Unicamente se accesan Manejadores generados por el mismo proceso
        Load.  Pero Loads anidados pueden accesar a manejadores
        previos.  Esto facilita la programacion, y la subdivision
        del archivo en bloques.
  C. Debido a B, es muy probable que la primera orden LOAD sea
        la creacion de un manejador.
  D. Los procesos LOAD no accesan al manejador TEMPORAL en su version
        inicial.  Por seguridad, pues TEMPORAL probablemente
        tengan amplias libertades por decision de usuario.
  E. Los procesos LOAD no pueden invocar procesos TXT, ni Basic;  y otras
        restricciones similares.  Con el fin de facilitar el cumplimiento
        de las reglas anteriores.
  F. Aunque los procesos LOAD entienden la mayoria de las ordenes de
        Pipa se recomienda que los procesos SAVE correspondientes;
        recurran casi exclusivamente a ordenes que pretendan
        cierta validez "Universal".  Es decir que sean aceptables,
        por otros tipos de Hojas y formas de pensar.  A los que
        crean a mano ordenes LOAD se sugiere que hagan lo mismo.
        Y dejen las ordenes "diferenciadoras" para procesos TXT.
        He aqui una lista de las ordenes LOAD sugeridas:
        La mayoria de estos operadores pueden aplicarse tambien en version
        de solo una casilla o como region...
        "CREARHOJATRABAJO( 200, 300, 'displaynombre' [, aislada] )"
                la hoja creada se activa inmediatamente
        "ACTIVARHOJATRABAJO( 'displaynombre' [, ClaveResult ] )"
        "A1:= " y variantes...
        "(...)"   calcular, probablemente inutil en un LOAD autentico
        "//  "  comentarios de toda una linea se ignoran como un NULL pipa
        "FORMATOCASILLA( A1:A3, VERDE, ITALICA, ... )"
        "FORMATOCOLUMNA( 12, [57.6,], ...  )"
        "FORMATOFILA( 24, [23.4,], ... )"
        "FORMATODEFAULT( VERDE, ITALICA )"
        "PROTEGERCASILLA( A1:A3 )" aplicable version NOT()
        "VERFUNCIONAL"  aplicable version NOT()
        "VERVALORPRUEBA" aplicable version NOT()
        "TODOCICLOPROHIBIDO" aplicable version NOT()
        "RECALCULARTODOHOJA"
        "DEFOBJ( IDENTIFICADOROBJETO, ... [,ALT()][,ALT()] )"
               alias "DEFINIROBJETO()"  permite varias versiones alternas
                                        como texto e imagen simple
        "MODOBJ( IDENTIFICADOROBJETO, ... )"
               alias "MODIFICAROBJETO()"
        "OBJCAS(A1:D4, IDENTIFICADOROBJETO )" puede definirse solo la esquina
               alias "OBJETOCASILLA()"
        "A1"    solicitud de casilla, probablemente inutil en un Load
        "A1:A2" solicitud de zona, probablemente inutil en un Load
        "DESCRIPTORHOJA( $23, ... )"
        "CASILLARECURSIVA( A1:B3 [, 20 ] )" aplicable version NOT()
        "CASILLACICLICA( A1:B3 )" aplicable version NOT()
        "PUBLICIDAD( ['ARCHIVOS(,)',] '...','...' )"
                        Lista de Strings o quiza un archivo o enlace
        "DERECHOS( ... )"   Lista de Strings o quiza un archivo o enlace
        "REM( ... )"        Lista de Strings o quiza un archivo o enlace
                La primera version de CAFE.EXE admite unicamente
                dos String y un Archivo y los devuelve como
                un mensaje de pipa pertinente PublicidadREPO
                DerechosREPO, RemREPO
}

  Published
CONSTRUCTOR Create; override;
{
  Sustituye al Create de TStreamCollection, pues ya el tipo esta decidido
}

  Public
DESTRUCTOR  Destroy; override;
{
  Destructor basico de la unidad
}

  Public
  Class
PROCEDURE   Activar; override;
{
  PROCEDURE Activar
        Se supone que solo existe una instancia Raiz
        de CAFE_TCollectionManejadorString; aunque en el futuro
        probablemente se convierta en arbol.  Activar inicializa
        esta instancia y otros elementos para darle
        la funcionabilidad inicial a CAFE.EXE
}

  Public
  Class
PROCEDURE   Desactivar; override;
{
  PROCEDURE Desactivar
        Desactiva el sistema CAFE.EXE.  Eliminando los recursos
        de memoria.  Esta disenado para facilitar el "pasar" las pruebas de
        punteros.  Aunque deberia tomar en cuenta las previsiones
        de FPC sobre ampliacion de recursos de memoria RAM.
}

PROCEDURE   EjecutarOrden
  (       Solicitud             : CAFE_PipeItem                 ); virtual;
{
  PROCEDURE EjecutarOrden
        No implementado todavia.  Necesario para la CAFE_InterfacePipe;
        en modalidad general
  Solicitud                     : Recibe la orden de pipa, previamente
        modificada a formato CAFE_PipeItem
}

PROCEDURE   EjecutarRenglonCompleted
  ( CONST OrdenPipe             : String                        ); virtual;
{
  PROCEDURE EjecutarRenglonCompleted
        Procedimiento de interface que recibe las ordenes renglon por
        renglon, y las ejecuta hasta terminadas.
  OrdenPipe                     : Orden actual a procesar hasta
        terminacion.
}

PROCEDURE   EjecutarRenglonLoad
  ( CONST OrdenPipe             : String;
    VAR   ConteoRenglonActual   : CAFE_MatrizRenglonConteo      ); virtual;
{
  PROCEDURE EjecutarRenglonLoad
        EjecutarRenglonCompleted, llama a EjecutarRenglonLoad
        en procesos Load con algun desperdicio de codigo,
        para simplificar la logica del proceso.
        Note que un solo renglon de pipa de tipo Load,
        puede convertirse en miles de renglones, segun el archivo.
  OrdenPipe                     : Orden actual a procesar hasta
        terminacion.
  ConteoRenglonActual           : Contiene el conteo iniciado
        en EjecutarRenglonCompleted.  Este conteo es el de
        renglon de pipa.
        Los renglones load no reinicializan el conteo.
}

  Private
FUNCTION    ReadItemID
  (     Ide                     : String        ) : CAFE_InterfaceBasico;

  Private
FUNCTION    ReadAdministrador                           : TCustomApplication;

  Private
FUNCTION    Leer_Actual         : TStreamCollectionItem;

  Private
PROCEDURE   SetDisplayNameI
  (       MyName                : String                                );

  Private
FUNCTION    GetDisplayNameI                                     : String;

  Public
  Property
    DisplayNombre               :  String
                                   READ  GetDisplayNameI
                                   WRITE SetDisplayNameI;
{
  DisplayNombre                 : Sustituye a
        TStreanCollectionItem.DisplayName en EJES.EXE, se le cambio
        el nombre para evitar interferencia en algoritmos previos
        de FreePascal.
        Aqui seria el nombre de usuario de la Hoja de Calculo
        o similar
}

  Public
  Property
    Actual                      : TStreamCollectionItem READ Leer_Actual;
{
  Actual                        : Sirve como Self de la clase que
        implemente la Interface.  Probablemente requiera AS.
}

  Public
  Property
    ID[ ide : String  ]         : CAFE_InterfaceBasico
                                  Read  ReadItemID;
{
  ID                            : Tipo array para accesar a los
        diferentes manejadores subordinados.  No se recomieda su
        uso por el momento.
}

  Public
  Property
    Administrador               : TCustomApplication
                                  Read  ReadAdministrador;
{
  Administrador                 : Para facilitarle al manejador
        el acceso a la pipa.
        Su principal uso por ahora, sera el descargue de mensajes
        a la pipa, para ser transferidos al usuario
}

                                END;
                                { CLASS CAFE_TCollectionManejadorString }

FUNCTION    CAFE_ConjuntoParametroBasicoToLongInt
  (       Descriptor            : CAFE_ConjuntoParametroBasico  ) : LongInt;
{
  FUNCTION CAFE_ConjuntoParametroBasicoToLongInt
        Funcion algo innecesaria, pero se crea para tranquilidad
        de los usuarios del tipo de dato;  para facilitar
        compatibilidad a futuro.  La traduccion no sigue
        el orden usual del conjunto, para obligar a su uso,
        evitando la conversion de tipo forzada.
  Descriptor                    : Conjunto a ser transcrito
  FUNCTION CAFE_ConjuntoParametroBasicoToLongInt        : Devuelve
        el valor solicitado
}

FUNCTION    CAFE_LongIntToConjuntoParametroBasico
  (       ClaveLongInt  : LongInt       ) : CAFE_ConjuntoParametroBasico;
{
  FUNCTION CAFE_LongIntToConjuntoParametroBasico
        Funcion algo innecesaria, pero se crea para tranquilidad
        de los usuarios del tipo de dato;  para facilitar
        compatibilidad a futuro.  La traduccion no sigue
        el orden usual del conjunto, para obligar a su uso,
        evitando la conversion de tipo forzada.
  ClaveLongInt                  : Entero que describe el conjunto.
  FUNCTION CAFE_ConjuntoParametroBasicoToLongInt        : Devuelve el
        tipo Conjunto solicitado.
}

FUNCTION    CAFE_ConjuntoVariantesDescriptoresHojaToLongInt
  (       Descriptor            :
                CAFE_ConjuntoVariantesDescriptoresHoja          ) : LongInt;
{
  FUNCTION CAFE_ConjuntoVariantesDescriptoresHojaToLongInt
        Funcion algo innecesaria, pero se crea para tranquilidad
        de los usuarios del tipo de dato;  para facilitar
        compatibilidad a futuro.  La traduccion no sigue
        el orden usual del conjunto, para obligar a su uso,
        evitando la conversion de tipo forzada.
  Descriptor                    : Conjunto a ser transcrito
  FUNCTION CAFE_ConjuntoVariantesDescriptoresHojaToLongInt      : Devuelve
        el valor solicitado
}

FUNCTION    CAFE_LongIntToConjuntoVariantesDescriptoresHoja
  (       ClaveLongInt          : LongInt
                                ) : CAFE_ConjuntoVariantesDescriptoresHoja;
{
  FUNCTION CAFE_LongIntToConjuntoVariantesDescriptoresHoja
        Funcion algo innecesaria, pero se crea para tranquilidad
        de los usuarios del tipo de dato;  para facilitar
        compatibilidad a futuro.  La traduccion no sigue
        el orden usual del conjunto, para obligar a su uso,
        evitando la conversion de tipo forzada.
  ClaveLongInt                  : Entero que describe el conjunto.
  FUNCTION CAFE_LongIntToConjuntoVariantesDescriptoresHoja      : Devuelve el
        tipo Conjunto solicitado.
}

FUNCTION    CAFE_VariantToString
  ( CONST MyVariant     : Variant                       ) : ShortString;
{
  FUNCTION CAFE_VariantToString
        Convierte el variante MyVariant en un ShortString reconocible
        por CAFE.EXE en archivos TXT.  Con la salvedad que el tipo
        varString, siplemente se asigna;  sin agregar comillas.
        A los demas se aplican funciones del tipo DateToStr,
        FloatToStr, etc...  los boolean se convierten en TRUE or FALSE.
        No incluye espacios en blanco ni separadores.
        El varNull se convierte en un NULL.
  MyVariant                     : Variante a ser transcrito.
}

FUNCTION    CAFE_StringToVariant
  ( CONST MyString      : String                                ) : Variant;
{
  FUNCTION CAFE_StringToVariant
        Convierte MyString en un variante.  Donde se supone que MyString
        se recive de algun archivo TXT o similar.
        Algunas reglas:
        A. Se aplica Trim al principio.  Sin embargo, una asignacion
        de un String sin comillas se asigna como TrimLeft.
        B. Case insensitive para TRUE, FALSE, NULL
        C. Si el Trim crea MyString vacio o NULL se asigna Null.
        D. Datos entrecomillados se les elimina la comillas y
        se toman como varString.  FUNCTION genera RAISE si error
        sintactico en este proceso.
        E. Los Byte seran asignados como VarInteger, y cualquier
        real unicamente como varDouble.
        F. Tener cuidado con los Date.  Utilizan simplemente
        StrToDate, y luego lo asigna al variante. (Paso E se
        aplica primero)
        G. Si no se reconoce nada y no genero RAISE, probablemente
        se asigne varString como TrimLeft
        sin proceso de eliminar comillas.
        H. Por supuesto un TRUE String o similar, deberia asignarse
        como 'TRUE' si se quiere evitar el tipo Boolean.
  MyString                      : Tipo String a convertir
  FUNCTION CAFE_StringToVariant : Retorna el variante resultado
        de la conversion.
}

FUNCTION    CAFE_ConstToString
  (       MyData        : ARRAY OF CONST                ) : TStringDynArray;
{
  FUNCTION CAFE_ConstToString
        Convierte el tipo ARRAY OF CONST en un tipo TStringDynArray,
        de entrada se exige que todos los datos en MyData sean Strings
        simples.
        ADVERTENCIA: Esta FUNCTION tiene riesgo de incompatibilidad
        futura con FreePascal, porque se ejecuta en base a algoritmos de
        conversion de tipo forzada.  Disculpas, si surge algun problema.
  MyData                        : Lista de Strings a convertir
  FUNCTION CAFE_ConstToString                   : Devuelve el
        TStringDynArray solicitado.
}

TYPE
  CAFE_ReferenciaTCustomApplication     = CLASS OF TCustomApplication;
{
  CAFE_ReferenciaTCustomApplication     : Crea una referencia
        de la clase TCustomApplication.  Util en la inicializacion
        de CAFE.EXE.
}

VAR
  CAFE_TipoHojaAsignado         : CAFE_ReferenciaHojaCalculo;
{
  CAFE_TipoHojaAsignado                 : Contiene el tipo de clase
        para hojas de calculo actual que se generara en CAFE.EXE.
}

  CAFE_Application              : CAFE_TriplePipeMemory;
{
  CAFE_Application              : Variable global encargada del
        manejo de la pipa de instrucciones, y talvez
        del control de la aplicacion.
}

  CAFE_ReferenciaApplication    : CAFE_ReferenciaTCustomApplication;
{
  CAFE_ReferenciaAppliction     : Referencia utilizada en la
        inicializacion de CAFE_Application
}

  CAFE_AlternativaVariableGeneral               : TStringDynArray;
{
  CAFE_AlternativaVariableGeneral       : Contiene una lista
        de alternativas para variables generales reconocidas
        y modificables por la pipa.
}

IMPLEMENTATION

CONST
  { LISTA de mensajes de Pipa definidoa en CAFE_Ej5 }
  {ErrorREPO}
  CAFE_ErrorError                       = 1;
  CAFE_SError                           = 'Error...';
  CAFE_ErrorTipoVarianteIncompatible    = 2;
  CAFE_STipoVarianteIncompatible        = 'Tipo variante incompatible';
  CAFE_ErrorPosibleIncompatibilidadVersion      = 3;
  CAFE_SPosibleIncompatibilidadVersion          =
                                'Posible incompatibilidad de version';
  CAFE_ErrorFormatoIncompatiblePendiente        = 4;
  CAFE_SFormatoIncompatiblePendiente            =
                                'Formato incompatible: %s pendiente';
  CAFE_ErrorDescriptorCasillaIncompatible       = 5;
  CAFE_SDescriptorCasillaIncompatible           =
                                'Descriptor casilla incompatible %s';
  CAFE_ErrorVarErrorEvaluar                     = 6;
  CAFE_SVarErrorEvaluar                         = 'varError al evaluar';
  CAFE_ErrorIdentificadorInvalido               = 7;
  CAFE_SIdentificadorInvalido                   =
                                'Identificador %s no permitido';
  CAFE_ErrorVarErrorInterpretar                 = 8;
  CAFE_SVarErrorInterpretar                     = 'varError al interpretar';
  CAFE_ErrorOrdenNoEntendida                    = 9;
  CAFE_SOrdenNoEntendida                        = 'Orden no entendida';
  CAFE_ErrorFaltanParametrosEnOperador          = 10;
  CAFE_SFaltanParametrosEnOperador              =
                                        'Faltan datos en operador %s';
  CAFE_ErrorIdentificadorRequiereHojaTrabajo    = 11;
  CAFE_SIdentificadorRequiereHojaTrabajo        =
                'El Identificador carece de Hoja de Trabajo asignada';
  CAFE_ErrorOrdenRequiereHojaTrabajo            = 12;
  CAFE_SOrdenRequiereHojaTrabajo                =
                                'Orden requiere Hoja de Trabajo';
  CAFE_ErrorNombreHojaTrabajoPendiente          = 13;
  CAFE_SNombreHojaTrabajoPendiente              =
                                'Nombre Hoja de Trabajo pendiente';
  CAFE_ErrorNombreGrupoSaveInexistente          = 14;
  CAFE_SNombreGrupoSaveInexistente              =
                                'Nombre de grupo save %s inexistente';
  CAFE_ErrorDatoStringPendiente                 = 15;
  CAFE_SDatoStringPendiente                     =
                                'Dato tipo string pendiente';
  CAFE_ErrorTotalDatosEquivocadoOrden           = 16;
  CAFE_STotalDatosEquivocadoOrden               =
                                'Total de datos equivocado en orden %s';
  CAFE_FracasoNoPudoAbrirArchivo                = 17;
  CAFE_SFracasoNoPudoAbrirArchivo               =
                                'No pudo abrir archivo %s';
  CAFE_FracasoNoPudoCrearArchivo                = 18;
  CAFE_SFracasoNoPudoCrearArchivo               =
                                'No pudo crear archivo %s';
  CAFE_ErrorDatoEnteroPendiente                 = 19;
  CAFE_SDatoEnteroPendiente                     =
                                'Dato tipo entero pendiente';
  CAFE_ErrorSelectorAlternativaPendiente        = 20;
  CAFE_SSelectorAlternativaPendiente            =
                                'Selector alternativa pendiente';
  CAFE_FracasoArchivoTXTPendiente               = 21;
  CAFE_SFracasoArchivoTXTPendiente              =
                                'Orden requiere archivo en formato TXT';
  CAFE_FatalSuperoCapacidadErroresArchivo       = 22;
  CAFE_SFatalSuperoCapacidadErroresArchivo      =
                                'Archivo %s supera capacidad de errores';
  CAFE_FatalErroresNoPermitidosLoad             = 23;
  CAFE_SFatalErroresNoPermitidosLoad            =
                                'Errores no permitidos en Load';
  CAFE_DescartadoLoadInterrumpidoArchivo        = 24;
  CAFE_SDescartadoLoadInterrumpidoArchivo       =
                                'Proceso load de archivo %s interrumpido';
  CAFE_FatalInterrumpidoLoadArchivo             = 25;
  CAFE_SFatalInterrumpidoLoadArchivo            =
                                'Interrumpido load de archivo %s';
  CAFE_ErrorStringIdentificadorValido           = 26;
  CAFE_SStringIdentificadorValido               =
                '%s no cumple sintaxis solicitada de identificador';
  CAFE_ErrorDimensionesInaceptablesHojaTrabajo  = 27;
  CAFE_SDimensionesInaceptablesHojaTrabajo      =
                'Dimensiones inaceptables para hoja de trabajo';
  CAFE_ErrorNombreDuplicadoHojaTrabajoEnGrupo   = 28;
  CAFE_SNombreDuplicadoHojaTrabajoEnGrupo       =
                'Nombre de hoja de trabajo %s duplicado en grupo %s';
  CAFE_ErrorNoPudoVincularseHojasTrabajoEnGrupo = 29;
  CAFE_SNoPudoVincularseHojasTrabajoEnGrupo     =
                'No pudo vincularse %s con hoja de trabajo %s en grupo %s';
  CAFE_ErrorNombreHojaTrabajoInexistente        = 30;
  CAFE_SNombreHojaTrabajoInexistente            =
                                'Nombre de hoja de trabajo %s inexistente';
  CAFE_ErrorNoConcordanciaNombreHojaTrabajoControl      = 31;
  CAFE_SNoConcordanciaNombreHojaTrabajoControl          =
        'No concordancia entre nombre hoja de trabajo %s y control %s';
  CAFE_ErrorHojaTrabajoCareceGrupoSaveAsignado          = 32;
  CAFE_SHojaTrabajoCareceGrupoSaveAsignado              =
                'Hoja de trabajo %s carece de grupo Save asignado';
  CAFE_ErrorAccesoNoPermitidoHojaTrabajo                = 33;
  CAFE_SAccesoNoPermitidoHojaTrabajo                    =
                'Acceso no permitido a hoja de trabajo %s';
  CAFE_ErrorAccesoNoPermitidoGrupoSave                  = 34;
  CAFE_SAccesoNoPermitidoGrupoSave                      =
                'Acceso no permitido a grupo save %s';
  CAFE_ErrorDatoIdentificadorCasillaPendiente           = 35;
  CAFE_SDatoIdentificadorCasillaPendiente               =
                'Dato tipo identificador casilla pendiente';
  CAFE_ResultVarError                                   = 36;
  CAFE_SResultVarError                                  = 'VarError';
  CAFE_ErrorStringMalDefinida           = 37;
  CAFE_SStringMalDefinida               = 'String mal definida';
  CAFE_ErrorHojaTrabajoInactiva         = 38;
  CAFE_SHojaTrabajoInactiva             = 'Hoja trabajo inactiva';
  CAFE_ErrorCasillaBloqueadaHojaTrabajo                 = 39;
  CAFE_SCasillaBloqueadaHojaTrabajo     =
                        'Casilla bloqueada en hoja de trabajo';
  CAFE_ErrorRangoSolicitadoNoPermitidoEnCopia           = 40;
  CAFE_SRangoSolicitadoNoPermitidoEnCopia               =
                        'Rango solicitado no permitido en copia';
  CAFE_FatalProcesoCopiaCasillasInterrumpido            = 41;
  CAFE_SFatalProcesoCopiaCasillasInterrumpido           =
                        'Proceso copia casillas interrumpido';
  CAFE_ErrorMecanismoUndoDesactivadoHojaTrabajo         = 42;
  CAFE_SMecanismoUndoDesactivadoHojaTrabajo             =
                        'Mecanismo undo desactivado en hoja de trabajo';
  CAFE_ErrorDatoFueraRangoAdmisible                     = 43;
  CAFE_SDatoFueraRangoAdmisible                         =
                        'Dato fuera de rango admisible';
  CAFE_AlertaMecanismoUndoRequiereHojaTrabajo           = 44;
  CAFE_SAlertaMecanismoUndoRequiereHojaTrabajo          =
                        'Mecanismo undo requiere hoja de trabajo';
  CAFE_ErrorDatoRealPendiente                   = 45;
  CAFE_SDatoRealPendiente                       =
                                'Dato tipo real pendiente';
  CAFE_ErrorTipoInadecuadoDatoVariableGlobal    = 46;
  CAFE_STipoInadecuadoDatoVariableGlobal        =
                 'Tipo inadecuado de dato para variable global %s';
  CAFE_ErrorDeterminanteNulo                    = 47;
  CAFE_SDeterminanteNulo                        = 'Determinante nulo';
  CAFE_ErrorGramaticaOperadoresCadenaError      = 48;
  CAFE_SGramaticaOperadoresCadenaError          =
                                'Lectura de %s con error de sintaxis';
  CAFE_ErrorSintaxisGeneral                     = 49;
  CAFE_SSintaxisGeneral                         =
                                'Error de sintaxis';
  CAFE_ErrorAlEvaluarEnLugar                    = 50;
  CAFE_SAlEvaluarEnLugar                        =
                                'Error al evaluar %s';
  CAFE_ErrorExcesoParentesisCerrados            = 51;
  CAFE_SExcesoParentesisCerrados                =
                                'Exceso de agrupamiento derecho '')''';
  CAFE_ErrorLlamadaCiclica                      = 52;
  CAFE_SLlamadaCiclica                          =
                                'Ciclo recursivo no permitido';
  CAFE_ErrorMacroSinParametros                  = 53;
  CAFE_SMacroSinParametros                      =
                                'Macro indefinida';
  CAFE_ErrorEstiloRecursivoIndefinido           = 54;
  CAFE_SEstiloRecursivoIndefinido               =
                                'Estilo recursivo indefinido';
  CAFE_ErrorFinCicloPendiente                   = 55;
  CAFE_SFinCicloPendiente                       = 'Fin ciclo pendiente';
  CAFE_ErrorDescriptorDimensionalInconsistente  = 56;
  CAFE_SDescriptorDimensionalInconsistente      =
                        'Descriptor dimensional inconsistente';
  CAFE_ErrorMatrizAnalisisNumericoMuyGrande     = 57;
  CAFE_SMatrizAnalisisNumericoMuyGrande         =
                        'Matriz muy grande para proceso...';
  CAFE_ErrorIntegralNoRealizada                 = 58;
  CAFE_SIntegralNoRealizada                     =
                        'Integral de %s no conseguida';
  CAFE_ErrorDefinirSectorRectangular            = 59;
  CAFE_SDefinirSectorRectangular                =
                        'No se pudo definir sector matricial';
  CAFE_ErrorMacroRecibeArgumentosReales         = 60;
  CAFE_SMacroRecibeArgumentosReales             =
                        'Macro recibe exclusivamente argumentos reales';
  CAFE_ErrorCopiaProvocaRangoNoPermitido        = 61;
  CAFE_SCopiaProvocaRangoNoPermitido            =
                        'Copia de %s provoca rango no permitido';
  CAFE_ErrorCopiaNoPermitidaGeneral             = 62;
  CAFE_SCopiaNoPermitidaGeneral                 = 'Copia interrumpida';
  CAFE_ErrorNoPudoEvaluarValoresInicialesCopiaMacro             = 63;
  CAFE_SNoPudoEvaluarValoresInicialesCopiaMacro =
                  'No pudo evaluar valores iniciales de macro en copia...';
  CAFE_ErrorIrregularAccesoCasilla              = 64;
  CAFE_SIrregularAccesoCasilla                  =
                                'Acceso irregular a casilla %s';
  CAFE_ErrorIntegralSuperoTotalCiclos           = 65;
  CAFE_SIntegralSuperoTotalCiclos               =
        'La integral ha superado el valor de total de ciclos actual';
  CAFE_ErrorMacroResultadoNoReal                = 66;
  CAFE_SMacroResultadoNoReal                    =
                        'Inconsistencia de tipo en macro';
  CAFE_ErrorFaltaFinComentario                  = 67;
  CAFE_SFaltaFinComentario                      =
                        'No se encuentra final de comentario %s';
  CAFE_ErrorFaltaFinString                      = 68;
  CAFE_SFaltaFinString                          =
        'Pendiente final de comillas ''STRING'' delimitadoras de String';
  CAFE_ErrorStringGeneral                       = 69;
  CAFE_SStringGeneral                           =
        'Inconsistencia en comillas ''STRING'' delimitadoras de String';
  CAFE_ErrorSintaxisAsignacionGeneral           = 70;
  CAFE_SSintaxisAsignacionGeneral               =
        'Sintaxis defectuosa para %s en proceso de asignar valores';
  CAFE_ErrorSintaxisJustificadoresWrite         = 71 unimplemented;
  CAFE_SSintaxisJustificadoresWrite             =
        'Error al justificar con operador '':'' en orden %s estilo Pascal';
  CAFE_MensajeGrupoSaveSinManejadores           = 72;
  CAFE_SMensajeGrupoSaveSinManejadores          =
                        'Grupo save carece de manejadores';
  CAFE_ErrorNudilladoSubOrden                   = 73;
  CAFE_SNudilladoSubOrden                       =
                        'No se pudo establecer suborden de %s';
  CAFE_ErrorParametrosSubOrden                  = 74;
  CAFE_SParametrosSubOrden                      =
                        'Error en datos de suborden %s';

VAR
  ImplementationAlternativaHojaAislado,
  ImplementationAlternativaCasillaCiclica       : TStringDynArray;
{
  [ 'AISLADO' ]
}

CONST
{
  Cambio de orden, para evitar la tentacion... de
  escritura via cambio de tipo o similar.  Probablemente innecesario.
}

  CAFE_ClaveActivoHCGM                  = $0001;
  CAFE_ClaveBasicoStandardHCGM          = $0002;
  CAFE_ClaveReal1DHCGM                  = $0100;
  CAFE_ClaveReal2DHCGM                  = $0200;
  CAFE_ClaveReal3DHCGM                  = $0400;
  CAFE_ClaveActivarCicloHCGM            = $0010;
  CAFE_ClaveCicloTomarVariantHCGM       = $0020;
  CAFE_ClaveCicloEvaluarHCGM            = $0004;
  CAFE_ClaveCicloConteoHCGM             = $0040;
  CAFE_ClaveFinConteoErrorHCGM          = $0008;
  CAFE_ClaveCasillaIniciativaHCGM       = $0080;
  CAFE_ClaveAlertaDominioHCGM           = $0800;
  CAFE_ConjuntoFuncionDefault           = [ ActivoHCGM, BasicoStandardHCGM ];
  CAFE_ConjuntoMacroBase                =
                        [ Real1DHCGM, Real2DHCGM, Real3DHCGM ];


CONST
  CAFE_ClaveActivoCVDH                          = $0001;
  CAFE_ClaveTodoCicloProhibidoCVDH              = $0002;
  CAFE_ClaveHojaAisladaCVDH                     = $0004;
  CAFE_ClavePeticionCalculoObligadoCVDH         = $0100;
  CAFE_ClaveForzarRecalculoTotalCVDH            = $0200;
  CAFE_ClaveAlertaDominioCVDH                   = $0080;
  CAFE_ClaveVerFuncionalCVDH                    = $0010;
  CAFE_ClaveVerValorPruebaCVDH                  = $0020;
  CAFE_ClaveBloquearCasillasCVDH                = $0008;

VAR
  ImplementationSintactico              : CAFE_CharByte3Sintactico;

FUNCTION ImplementationCharIgnorado
  ( CONST OperadorTraducido             : ShortString   ) : ShortString;
VAR
  PivoteRespuesta               : ShortString;

  { ANIDADO }
  FUNCTION AnidadoImplementationCharIgnorado
    ( CONST DatoTraductor               :
            CAFE_RegistroPrecedenciaOperadorSintactico  ): ShortString;
  VAR
    RecorreOperadores,
    RecorreTraductor            : Byte;

  BEGIN  { FUNCTION AnidadoImplementationCharIgnorado }
    FOR RecorreTraductor := 1 TO
                DatoTraductor.TotalNivelesPrecedencia DO
      WITH DatoTraductor.PunteroArregloRegistroNivel^[ RecorreTraductor ]
      DO BEGIN
        FOR RecorreOperadores := 1 TO TotalOperadoresNivel DO
          WITH PunteroArregloOperador^[ RecorreOperadores ]
          DO BEGIN
            IF OperadorNuevoBasico = OperadorTraducido THEN BEGIN
              AnidadoImplementationCharIgnorado         :=
                                        OperadorSimpleReconocido;
              Exit;
            END;  { IF OperadorNuevoBasico = OperadorTraducido }
          END;  { FOR RecorreOperadores }
      END;  { WITH DatoTraductor.PunteroArregloRegistroNivel... }
    AnidadoImplementationCharIgnorado   := '';
  END;   { FUNCTION AnidadoImplementationCharIgnorado }
  { ANIDADO }

BEGIN  { FUNCTION ImplementationCharIgnorado }
  PivoteRespuesta               :=
        AnidadoImplementationCharIgnorado
        ( CAFE_RegistroPrecedenciaDescriptorIdentificadorPascal );
  IF PivoteRespuesta = '' THEN BEGIN
    PivoteRespuesta             :=
        AnidadoImplementationCharIgnorado
        ( CAFE_RegistroPrecedenciaOperadorSintacticoPascal );
    IF OperadorTraducido = CAFE_OperadorParentesisTraducidoOperadorBasico
    THEN PivoteRespuesta        := '()';
    IF OperadorTraducido =
                CAFE_OperadorAsignacionBasicaTraducidoOperadorBasico
    THEN PivoteRespuesta        := ':=';
    IF OperadorTraducido        =
                CAFE_OperadorStringTraducidoOperadorBasico
    THEN PivoteRespuesta        := '''''';
    IF OperadorTraducido        = CAFE_IdentificadorStringNull
    THEN PivoteRespuesta        := '''''';
    IF PivoteRespuesta = ''
    THEN RAISE CAFE_PipeHaltException.
                Create( 'HALT uso de caracter invalido...' );
  END;  { IF PivoteRespuesta = '' }
  ImplementationCharIgnorado    := PivoteRespuesta;
END;   { FUNCTION ImplementationCharIgnorado }

FUNCTION ImplementationIntentoInfructuosoNoPipe         : Boolean;
VAR
  PivoteMsg                             : ShortString;

BEGIN  { FUNCTION ImplementationIntentoInfructuosoNoPipe }
  IF CAFE_IntentoInfructuosoSintactico THEN BEGIN
    IF CAFE_PosicionInfructuosoSintactico = 0 THEN BEGIN
      CAFE_IntentoInfructuosoSintactico         := FALSE;
      CAFE_PosicionInfructuosoSintactico        := 0;
      IF CAFE_MensajeInfructuosoSintactico <> '' THEN BEGIN
        PivoteMsg       := CAFE_MensajeInfructuosoSintactico;
        CAFE_MensajeInfructuosoSintactico         := '';
        RAISE CAFE_MensajeException.Create( PivoteMsg );
      END;  { IF CAFE_MensajeInfructuosoSintactico <> '' }
    END;  { IF CAFE_PosicionInfructuosoSintactico = 0 }
    IF CAFE_MensajeInfructuosoSintactico <> '' THEN
      IF CAFE_MensajeInfructuosoSintactico[ 1 ] = CAFE_CharIgnoradoLibre
      THEN CAFE_MensajeInfructuosoSintactico        :=
          ImplementationCharIgnorado( CAFE_MensajeInfructuosoSintactico );
  END;  { IF CAFE_IntentoInfructuosoSintactico }
  ImplementationIntentoInfructuosoNoPipe        :=
                                CAFE_IntentoInfructuosoSintactico;
END;   { FUNCTION ImplementationIntentoInfructuosoNoPipe }

FUNCTION    CAFE_ConjuntoParametroBasicoToLongInt
  (       Descriptor            : CAFE_ConjuntoParametroBasico  ) : LongInt;
VAR
  PivoteCiclo                   : CAFE_ParametroBasico;
  PivoteRespuesta               : LongInt;

BEGIN  { FUNCTION CAFE_ConjuntoParametroBasicoToLongInt }
  PivoteRespuesta               := 0;
  FOR PivoteCiclo IN CAFE_ParametroBasico DO BEGIN
    IF PivoteCiclo IN Descriptor THEN BEGIN
      CASE PivoteCiclo OF
        ActivoHCGM              :
                Inc( PivoteRespuesta, CAFE_ClaveActivoHCGM );
        BasicoStandardHCGM      :
                Inc( PivoteRespuesta, CAFE_ClaveBasicoStandardHCGM );
        Real1DHCGM              :
                Inc( PivoteRespuesta, CAFE_ClaveReal1DHCGM );
        Real2DHCGM              :
                Inc( PivoteRespuesta, CAFE_ClaveReal2DHCGM );
        Real3DHCGM              :
                Inc( PivoteRespuesta, CAFE_ClaveReal3DHCGM );
        ActivarCicloHCGM        :
                Inc( PivoteRespuesta, CAFE_ClaveActivarCicloHCGM );
        CicloTomarVariantHCGM   :
                Inc( PivoteRespuesta, CAFE_ClaveCicloTomarVariantHCGM );
        CicloEvaluarHCGM        :
                Inc( PivoteRespuesta, CAFE_ClaveCicloEvaluarHCGM );
        CicloConteoHCGM         :
                Inc( PivoteRespuesta, CAFE_ClaveCicloConteoHCGM );
        FinConteoErrorHCGM      :
                Inc( PivoteRespuesta, CAFE_ClaveFinConteoErrorHCGM );
        CasillaIniciativaHCGM   :
                Inc( PivoteRespuesta, CAFE_ClaveCasillaIniciativaHCGM );
        AlertaDominioHCGM       :
                Inc( PivoteRespuesta, CAFE_ClaveAlertaDominioHCGM );
        ELSE
        RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorPosibleIncompatibilidadVersion );
      END;  { CASE PivoteCiclo }
    END;  { IF PivoteCiclo IN Descriptor }
  END;  { FOR PivoteCiclo }
  CAFE_ConjuntoParametroBasicoToLongInt         := PivoteRespuesta;
END;   { FUNCTION CAFE_ConjuntoParametroBasicoToLongInt }

FUNCTION    CAFE_LongIntToConjuntoParametroBasico
  (       ClaveLongInt  : LongInt       ) : CAFE_ConjuntoParametroBasico;
VAR
  ConjuntoRespuesta             : CAFE_ConjuntoParametroBasico;
  PivoteRespuesta               : CAFE_ParametroBasico;

  { ANIDADO }
  PROCEDURE   AnidadoInclude
    (       PivoteInterior      : CAFE_ParametroBasico;
            NumeroClave         : LongInt                               );
  BEGIN  { PROCEDURE AnidadoInclude }
    IF ( NumeroClave AND ClaveLongInt ) = NumeroClave
    THEN Include( ConjuntoRespuesta, PivoteInterior );
  END;   { PROCEDURE AnidadoInclude }
  { ANIDADO }

BEGIN  { FUNCTION CAFE_LongIntToConjuntoParametroBasico }
  ConjuntoRespuesta             := [];
  FOR PivoteRespuesta IN CAFE_ParametroBasico DO BEGIN
    CASE PivoteRespuesta OF
      ActivoHCGM                : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveActivoHCGM );
      BasicoStandardHCGM        : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveBasicoStandardHCGM );
      Real1DHCGM                : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveReal1DHCGM );
      Real2DHCGM                : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveReal2DHCGM );
      Real3DHCGM                : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveReal3DHCGM );
      ActivarCicloHCGM          : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveActivarCicloHCGM );
      CicloTomarVariantHCGM     : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveCicloTomarVariantHCGM );
      CicloEvaluarHCGM          : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveCicloEvaluarHCGM );
      CicloConteoHCGM           : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveCicloConteoHCGM );
      FinConteoErrorHCGM        : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveFinConteoErrorHCGM );
      CasillaIniciativaHCGM     : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveCasillaIniciativaHCGM );
      AlertaDominioHCGM         : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveAlertaDominioHCGM );
      ELSE
      RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorPosibleIncompatibilidadVersion );
    END;  { CASE PivoteCiclo }
  END;  { FOR PivoteCiclo }
  CAFE_LongIntToConjuntoParametroBasico         := ConjuntoRespuesta;
END;   { FUNCTION CAFE_LongIntToConjuntoParametroBasico }

FUNCTION    CAFE_ConjuntoVariantesDescriptoresHojaToLongInt
  (       Descriptor            :
                CAFE_ConjuntoVariantesDescriptoresHoja          ) : LongInt;
VAR
  PivoteCiclo                   : CAFE_VariantesDescriptoresHoja;
  PivoteRespuesta               : LongInt;

BEGIN  { FUNCTION CAFE_ConjuntoVariantesDescriptoresHojaToLongInt }
  PivoteRespuesta               := 0;
  FOR PivoteCiclo IN CAFE_VariantesDescriptoresHoja DO BEGIN
    IF PivoteCiclo IN Descriptor THEN BEGIN
      CASE PivoteCiclo OF
        ActivoCVDH              :
                Inc( PivoteRespuesta, CAFE_ClaveActivoCVDH );
        TodoCicloProhibidoCVDH  :
                Inc( PivoteRespuesta, CAFE_ClaveTodoCicloProhibidoCVDH );
        HojaAisladaCVDH         :
                Inc( PivoteRespuesta, CAFE_ClaveHojaAisladaCVDH );
        PeticionCalculoObligadoCVDH             :
                Inc( PivoteRespuesta, CAFE_ClavePeticionCalculoObligadoCVDH );
        ForzarRecalculoTotalCVDH                :
                Inc( PivoteRespuesta, CAFE_ClaveForzarRecalculoTotalCVDH );
        AlertaDominioCVDH       :
                Inc( PivoteRespuesta, CAFE_ClaveAlertaDominioCVDH );
        VerFuncionalCVDH        :
                Inc( PivoteRespuesta, CAFE_ClaveVerFuncionalCVDH );
        VerValorPruebaCVDH      :
                Inc( PivoteRespuesta, CAFE_ClaveVerValorPruebaCVDH );
        BloquearCasillasCVDH    :
                Inc( PivoteRespuesta, CAFE_ClaveBloquearCasillasCVDH );
        ELSE
        RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorPosibleIncompatibilidadVersion );
      END;  { CASE PivoteCiclo }
    END;  { IF PivoteCiclo IN Descriptor }
  END;  { FOR PivoteCiclo }
  CAFE_ConjuntoVariantesDescriptoresHojaToLongInt       := PivoteRespuesta;
END;   { FUNCTION CAFE_ConjuntoVariantesDescriptoresHojaToLongInt }

FUNCTION    CAFE_LongIntToConjuntoVariantesDescriptoresHoja
  (       ClaveLongInt          : LongInt
                                ) : CAFE_ConjuntoVariantesDescriptoresHoja;
VAR
  ConjuntoRespuesta             : CAFE_ConjuntoVariantesDescriptoresHoja;
  PivoteRespuesta               : CAFE_VariantesDescriptoresHoja;

  { ANIDADO }
  PROCEDURE   AnidadoInclude
    (       PivoteInterior      : CAFE_VariantesDescriptoresHoja;
            NumeroClave         : LongInt                               );
  BEGIN  { PROCEDURE AnidadoInclude }
    IF ( NumeroClave AND ClaveLongInt ) = NumeroClave
    THEN Include( ConjuntoRespuesta, PivoteInterior );
  END;   { PROCEDURE AnidadoInclude }
  { ANIDADO }

BEGIN  { FUNCTION CAFE_LongIntToConjuntoVariantesDescriptoresHoja }
  ConjuntoRespuesta             := [];
  FOR PivoteRespuesta IN CAFE_VariantesDescriptoresHoja DO BEGIN
    CASE PivoteRespuesta OF
      ActivoCVDH                : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveActivoCVDH );
      TodoCicloProhibidoCVDH    : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveTodoCicloProhibidoCVDH );
      HojaAisladaCVDH           : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveHojaAisladaCVDH );
      PeticionCalculoObligadoCVDH               : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClavePeticionCalculoObligadoCVDH );
      ForzarRecalculoTotalCVDH  : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveForzarRecalculoTotalCVDH );
      AlertaDominioCVDH         : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveAlertaDominioCVDH );
      VerFuncionalCVDH          : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveVerFuncionalCVDH );
      VerValorPruebaCVDH        : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveVerValorPruebaCVDH );
      BloquearCasillasCVDH      : AnidadoInclude
              ( PivoteRespuesta, CAFE_ClaveBloquearCasillasCVDH );
      ELSE
      RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorPosibleIncompatibilidadVersion );
    END;  { CASE PivoteCiclo }
  END;  { FOR PivoteCiclo }
  CAFE_LongIntToConjuntoVariantesDescriptoresHoja       := ConjuntoRespuesta;
END;   { FUNCTION CAFE_LongIntToConjuntoVariantesDescriptoresHoja }

CONSTRUCTOR CAFE_DatoNudilladoString.Create;
BEGIN  { CONSTRUCTOR CAFE_DatoNudilladoString.Create }
  inherited Create;
  ModeloExtendido               := CAFE_DatoNudilladoString;
END;   { CONSTRUCTOR CAFE_DatoNudilladoString.Create }

DESTRUCTOR  CAFE_DatoNudilladoString.Destroy;
BEGIN  { DESTRUCTOR CAFE_DatoNudilladoString.Destroy }
  Inherited Destroy;
END;   { DESTRUCTOR CAFE_DatoNudilladoString.Destroy }

FUNCTION    CAFE_DatoNudilladoString.ToString                   : AnsiString;
{ override; }
VAR
  PivoteString                  : String;
  BanderaPrimero                : Boolean;

BEGIN  { FUNCTION CAFE_DatoNudilladoString.ToString }
  PivoteString                  := '(';
  BanderaPrimero                := TRUE;
  IF ( ( MacroParametro-CAFE_ConjuntoMacroBase ) <>
                        CAFE_ConjuntoFuncionDefault ) OR
      ( CicloConteoMaximo <> CAFE_CicloConteoMaximoDefault ) THEN BEGIN
    IF CAFE_ConjuntoFuncionDefault <= MacroParametro THEN BEGIN
      PivoteString
      +=  '$'+IntToHex
          ( CAFE_ConjuntoParametroBasicoToLongInt
            ( MacroParametro-CAFE_ConjuntoMacroBase ), 1 );
    END ELSE BEGIN  { IF CAFE_ConjuntoFuncionDefault <= MacroParametro ELSE }
      PivoteString
      +=  '$'+IntToHex
          ( CAFE_ConjuntoParametroBasicoToLongInt
            ( MacroParametro ), 1 );
    END;            { IF CAFE_ConjuntoFuncionDefault <= MacroParametro ELSE }
    IF CicloConteoMaximo <> CAFE_CicloConteoMaximoDefault THEN BEGIN
      PivoteString
      += ','+IntToStr( CicloConteoMaximo );
    END;  { IF CicloConteoMaximo <> CAFE_CicloConteoMaximoDefault }
    BanderaPrimero              := FALSE;
  END;  { IF MacroParametro <> CAFE_ConjuntoFuncionDefault }
  IF BanderaMacroFuncional THEN BEGIN
    IF NOT( BanderaPrimero )
    THEN PivoteString
         += ',';
    PivoteString
    +=  NombreParametroUno;
    IF ValorPruebaUno <> 0
    THEN PivoteString
         += ','+FloatToStr( ValorPruebaUno );
    IF ( [ Real2DHCGM, Real3DHCGM ]*MacroParametro ) <> [] THEN BEGIN
      PivoteString
      += ','+NombreParametroDos;
      IF ValorPruebaDos <> 0
      THEN PivoteString
           += ','+FloatToStr( ValorPruebaDos );
      IF Real3DHCGM IN MacroParametro THEN BEGIN
        PivoteString
        += ','+NombreParametroTres;
        IF ValorPruebaTres <> 0
        THEN PivoteString
             += ','+FloatToStr( ValorPruebaTres );
      END;  { IF Real3DHCGM IN MacroParametro }
    END;  { IF Real3DHCGM IN MacroParametro }
  END;  { IF BanderaMacroFuncional }
  PivoteString
  += ')';
  ToString                      := PivoteString;
END;   { FUNCTION CAFE_DatoNudilladoString.ToString }

FUNCTION    CAFE_DatoNudilladoString.PeticionSimilarBaseString
  ( CONST BaseString            : AnsiString    ) : CAFE_DatoNudilladoString;
{ virtual; }
VAR
  PivoteRespuesta               : CAFE_DatoNudilladoString;
  PivoteParametro,
  PivoteString                  : AnsiString;
  PivoteAnt,
  PivotePos                     : SizeInt;
  PivoteParametroEntero         : Integer;
  PivoteParametroReal           : Double;
  NumeroParametroMacro,
  NumeroParametro               : Byte;
  BanderaPrimerEntero,
  BanderaEntero,
  BanderaReal,
  BanderaPrueba,
  BanderaUltimo                 : Boolean;

LABEL
  SalidaRapida,
  SalidaError;

BEGIN  { FUNCTION CAFE_DatoNudilladoString.PeticionSimilarBaseString }
  NumeroParametro               := 0;
  NumeroParametroMacro          := 0;
  BanderaPrimerEntero           := FALSE;
  BanderaPrueba                 := FALSE;
  BanderaUltimo                 := FALSE;
  PivoteRespuesta               :=
                ModeloExtendido.Create as CAFE_DatoNudilladoString;
  WITH PivoteRespuesta DO BEGIN
    BanderaStandard             := TRUE;
    BanderaMacroFuncional       := FALSE;
    BanderaPeticionNudillar     := TRUE;
    BanderaPeticionCalculo      := TRUE;
    PivoteString                := Trim( BaseString );
    PivotePos                   := AnsiPos( '(', PivoteString );
    IF PivotePos <> 1 THEN GOTO SalidaError;
    PivotePos                   := AnsiPos( ')', PivoteString );
    IF PivotePos <> Length( PivoteString ) THEN GOTO SalidaError;
    MacroParametro              := CAFE_ConjuntoFuncionDefault;
    CicloConteoMaximo           := CAFE_CicloConteoMaximoDefault;
    PivoteAnt                   := 2;
    REPEAT
      Inc( NumeroParametro );
      PivotePos                 := AnsiPos( ',', PivoteString );
      IF PivotePos = 0 THEN BEGIN
        BanderaUltimo           := TRUE;
        PivotePos               := Length( PivoteString );
      END;  { IF PivotePos = 0 }
      IF PivotePos > PivoteAnt THEN BEGIN
        PivoteParametro         :=
          Trim( Copy( PivoteString, PivoteAnt, PivotePos-PivoteAnt ) );
        IF NOT( BanderaUltimo ) THEN
                Delete( PivoteString, 1, PivotePos );
        PivoteAnt               := 1;
        IF ( Length( PivoteParametro ) = 0 ) AND
           ( NOT( BanderaUltimo ) OR ( NumeroParametro > 1 ) )
        THEN GOTO SalidaError;
        IF Length( PivoteParametro ) = 0 THEN GOTO SalidaRapida;
        TRY
          PivoteParametroEntero := StrToInt( PivoteParametro );
          BanderaEntero         := TRUE;
        EXCEPT
          ON EConvertError
          DO BanderaEntero      := FALSE;
        END;  { TRY }
        IF BanderaEntero THEN BEGIN
          IF NumeroParametro = 1 THEN BEGIN
            TRY
              MacroParametro    :=
                CAFE_LongIntToConjuntoParametroBasico
                                ( PivoteParametroEntero );
            EXCEPT
              FreeAndNil( PivoteRespuesta );
            END;  { TRY }
            BanderaPrimerEntero := TRUE;
          END ELSE BEGIN  { IF NumeroParametro = 1 ELSE }
            IF ( NumeroParametro = 2 ) AND BanderaPrimerEntero THEN BEGIN
              CicloConteoMaximo   := PivoteParametroEntero;
            END ELSE BEGIN  { IF NumeroParametro = 2 ... ELSE }
              IF NOT( InRange( NumeroParametroMacro, 1, 3 ) ) OR
                 NOT( BanderaPrueba )
              THEN GOTO SalidaError;
              CASE NumeroParametroMacro OF
                1               : ValorPruebaUno  := PivoteParametroEntero;
                2               : ValorPruebaDos  := PivoteParametroEntero;
                3               : ValorPruebaTres := PivoteParametroEntero;
              END;  { CASE NumeroParametroMacro }
              BanderaPrueba     := FALSE;
            END;            { IF NumeroParametro = 2 ... ELSE }
          END;            { IF BanderaPrimero ELSE }
        END ELSE BEGIN  { IF BanderaEntero ELSE }
          TRY
            PivoteParametroReal := StrToFloat( PivoteParametro );
            BanderaReal         := TRUE;
          EXCEPT
            ON EConvertError
            DO BanderaReal        := FALSE;
          END;  { TRY }
          IF BanderaReal THEN BEGIN
            IF NOT( InRange( NumeroParametroMacro, 1, 3 ) ) OR
               NOT( BanderaPrueba )
            THEN GOTO SalidaError;
            CASE NumeroParametroMacro OF
              1               : ValorPruebaUno  := PivoteParametroReal;
              2               : ValorPruebaDos  := PivoteParametroReal;
              3               : ValorPruebaTres := PivoteParametroReal;
            END;  { CASE NumeroParametroMacro }
            BanderaPrueba     := FALSE;
          END ELSE BEGIN  { IF BanderaReal ELSE }
            BanderaMacroFuncional               := TRUE;
            Inc( NumeroParametroMacro );
            IF NOT( ImplementationSintactico.
                        VerificarIdentificador( PivoteParametro ) )
            THEN GOTO SalidaError;
            CASE NumeroParametroMacro OF
              1               : BEGIN
                                  NombreParametroUno      := PivoteParametro;
                                  Include( MacroParametro, Real1DHCGM);
                                END;  { CASE 1 }
              2               : BEGIN
                                  NombreParametroDos      := PivoteParametro;
                                  Exclude( MacroParametro, Real1DHCGM);
                                  Include( MacroParametro, Real2DHCGM);
                                END;  { CASE 2 }
              3               : BEGIN
                                  NombreParametroTres     := PivoteParametro;
                                  Exclude( MacroParametro, Real2DHCGM);
                                  Include( MacroParametro, Real3DHCGM);
                                END;  { CASE 3 }
              ELSE GOTO SalidaError;
            END;  { CASE NumeroParametroMacro }
            BanderaPrueba       := TRUE;
          END;            { IF BanderaReal ELSE }
        END;            { IF BanderaEntero ELSE }
      END ELSE BEGIN  { IF PivotePos > PivoteAnt ELSE }
        IF ( NOT( BanderaUltimo ) OR ( NumeroParametro > 1 ) )
        THEN GOTO SalidaError;
      END;            { IF PivotePos > PivoteAnt ELSE }
    UNTIL BanderaUltimo;
  END;  { WITH PivoteRespuesta DO BEGIN }
SalidaRapida :
  PeticionSimilarBaseString     := PivoteRespuesta;
  Exit;
SalidaError :
  FreeAndNil( PivoteRespuesta );
  PeticionSimilarBaseString     := NIL;
END;   { FUNCTION CAFE_DatoNudilladoString.PeticionSimilarBaseString }

CONSTRUCTOR CAFE_ManejadorBasicoString.Create
  (       ACollection           : TCollection                   );
{ override; }
BEGIN  { CONSTRUCTOR CAFE_ManejadorBasicoString.Create }
  Inherited Create( ACollection );
END;   { CONSTRUCTOR CAFE_ManejadorBasicoString.Create }

PROCEDURE   CAFE_ManejadorBasicoString.ReinicioHojaManejadorBasico;
{ virtual; }
BEGIN  { PROCEDURE CAFE_ManejadorBasicoString.ReinicioHojaManejadorBasico }
  IF HojaDefault <> NIL
  THEN ( HojaDefault as CAFE_HojaCalculoString ).HojaReinicio;
  ( PaquetePredefinidoI as CAFE_InterpreteSintacticoString ).
                        ReinicioPaquetePredefinido;
  PaqueteUndoI.ClearUndo;
  ValorBanderaSimularCalculoI   := CAFE_InicialBanderaSimularCalculo;
  ValorPreliminarSolveI         := CAFE_InicialPreliminarSolve;
  ValorMaximaIteracionIntegralOctavoImparI                      :=
                CAFE_InicialMaximaIteracionIntegralOctavoImpar;
  ValorMaximaIteracionIntegralOctavoImparFuncionI               :=
                CAFE_InicialMaximaIteracionIntegralOctavoImparFuncion;
  ValorEpsilonZeroI             := CAFE_InicialEpsilonZero;
  ValorDefaultToleranciaDeterminanteI                           :=
                CAFE_InicialToleranciaDeterminante;
END;   { PROCEDURE CAFE_ManejadorBasicoString.ReinicioHojaManejadorBasico }

DESTRUCTOR  CAFE_ManejadorBasicoString.Destroy;
BEGIN  { DESTRUCTOR CAFE_ManejadorBasicoString.Destroy }
  Inherited Destroy;
END;   { DESTRUCTOR CAFE_ManejadorBasicoString.Destroy }

PROCEDURE   CAFE_ManejadorBasicoString.DesvincularTodoPaquete;
VAR
  PunteroActual                 : CAFE_Interprete2Sintactico;

BEGIN  { PROCEDURE CAFE_ManejadorBasicoString.DesvincularTodoPaquete }
  PunteroActual                 := PaquetePredefinido;
  WHILE PunteroActual <> NIL DO BEGIN
    IF [ ActivoNITI, ManejadorPrincipalNITI ] <=
                      PunteroActual.DescriptorInterprete
    THEN BEGIN
      IF NOT( ManejadorSelfNITI IN PunteroActual.DescriptorInterprete )
      THEN Exclude( PunteroActual.DescriptorInterprete, ActivoNITI );
    END;  { IF [ ActivoNITI, ManejadorPrincipalNITI ] <= ... }
    PunteroActual               := PunteroActual.SiguienteIdentificador;
  END;  { WHILE PunteroActual <> NIL }
END;   { PROCEDURE CAFE_ManejadorBasicoString.DesvincularTodoPaquete }

PROCEDURE   CAFE_ManejadorBasicoString.ManejadorToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL           );
{ virtual; }
VAR
  PivoteString                  : ShortString;

BEGIN  { PROCEDURE CAFE_ManejadorBasicoString.ManejadorToTStringList }
  IF HojaDefault = NIL
  THEN RAISE CAFE_PipeException.
          Create( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
  IF DisplayNombre = ''
  THEN RAISE CAFE_PipeException.
          Create( ErrorREPO, CAFE_ErrorNombreHojaTrabajoPendiente );
  IF DisplayNombre = CAFE_NombreManejadorTemporal THEN BEGIN
    PivoteString                  := Copy( CAFE_OrdenActivarHojaTrabajo, 1,
                  Pred( Length( CAFE_OrdenActivarHojaTrabajo ) ) );
    PivoteString
    +=          QuotedStr( CAFE_NombreManejadorTemporal )+')';
    MyList.Add( PivoteString );
    MyList.Add( CAFE_OrdenHojaReinicio );
  END ELSE BEGIN  { IF BanderaTemporal ELSE }
    PivoteString                  := Copy( CAFE_OrdenCrearHojaTrabajo, 1,
                  Pred( Length( CAFE_OrdenCrearHojaTrabajo ) ) );
    PivoteString
    +=            IntToStr( HojaDefault.ColumnasEnHoja )+',';
    PivoteString
    +=            IntToStr( HojaDefault.FilasEnHoja )+',';
    PivoteString
    +=            QuotedStr( DisplayNombre );
    IF ( HojaAisladaCVDH IN HojaDefault.DescriptoresHoja )
    THEN PivoteString
         +=       ',AISLADA)'
    ELSE PivoteString
         +=       ')';
    MyList.Add( PivoteString );
  END;            { IF BanderaTemporal ELSE }
  VariableGeneralToTStringList
        ( MyList, NumeroRenglon, CodigoAcumulado, ErrorList );
  ( HojaDefault as CAFE_HojaCalculoString ).HojaCalculoToTStringList
                ( MyList, NumeroRenglon, CodigoAcumulado, ErrorList );
END;   { PROCEDURE CAFE_ManejadorBasicoString.ManejadorToTStringList }

PROCEDURE   CAFE_ManejadorBasicoString.VariableGeneralToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL           );
{ virtual; }
VAR
  PivoteString                  : ShortString;
  VarianteEscribir              : Variant;
  RecorreVariableGlobal         : Byte;
  BanderaEscribir               : Boolean;

BEGIN  { PROCEDURE CAFE_ManejadorBasicoString.ManejadorToTStringList }
  FOR RecorreVariableGlobal := 0 TO
                High( CAFE_AlternativaVariableGeneral ) DO BEGIN
    BanderaEscribir             := FALSE;
    CASE RecorreVariableGlobal OF
      0         : IF ValorBanderaSimularCalculo <>
                        CAFE_InicialBanderaSimularCalculo THEN BEGIN
                    BanderaEscribir             := TRUE;
                    VarianteEscribir            := ValorBanderaSimularCalculo;
                  END;  { IF ValorBanderaSimularCalculo <> ... }
      2         : IF ValorPreliminarSolve <> CAFE_InicialPreliminarSolve
                  THEN BEGIN
                    BanderaEscribir             := TRUE;
                    VarianteEscribir            := ValorPreliminarSolve;
                  END;  { IF ValorPreliminarSolve <> ... }
      3         : IF ValorMaximaIteracionIntegralOctavoImpar <>
                        CAFE_InicialMaximaIteracionIntegralOctavoImpar
                  THEN BEGIN
                    BanderaEscribir             := TRUE;
                    VarianteEscribir            :=
                                ValorMaximaIteracionIntegralOctavoImpar;
                  END;  { IF ValorMaximaIteracionIntegralOctavoImpar }
      4         : IF ValorMaximaIteracionIntegralOctavoImparFuncion <>
                        CAFE_InicialMaximaIteracionIntegralOctavoImparFuncion
                  THEN BEGIN
                    BanderaEscribir             := TRUE;
                    VarianteEscribir            :=
                        ValorMaximaIteracionIntegralOctavoImparFuncion;
                  END;  { IF ...IntegralOctavoImparFuncion... }
      5         : IF CompareValue( ValorEpsilonZero, CAFE_InicialEpsilonZero,
                                        0.01*CAFE_InicialEpsilonZero )
                                 <> EqualsValue THEN BEGIN
                    BanderaEscribir             := TRUE;
                    VarianteEscribir            := ValorEpsilonZero;
                  END;  { IF ValorEpsilonZero <> CAFE_InicialEpsilonZero }
      6         : IF CompareValue( ValorDefaultToleranciaDeterminante,
                        CAFE_InicialToleranciaDeterminante,
                        0.01*CAFE_InicialToleranciaDeterminante )
                                <> EqualsValue THEN BEGIN
                    BanderaEscribir             := TRUE;
                    VarianteEscribir            :=
                                ValorDefaultToleranciaDeterminante;
                  END;  { IF ValorDefaultToleranciaDeterminante <> ... }
      1, 7, 8   : BEGIN END;  { CASE Ignoradas }
      ELSE ErrorList.Add( CAFE_GenerarMensajeOutputCodigoNumeral
                ( CAFE_SPosibleIncompatibilidadVersion, NumeroRenglon,
                  CodigoAcumulado[ ErrorREPO ],
                  ErrorREPO, CAFE_ErrorPosibleIncompatibilidadVersion ) );
    END;  { CASE RecorreVariableGlobal }
    IF BanderaEscribir THEN BEGIN
      PivoteString      := Copy( CAFE_OrdenVariableGeneral, 1,
                Pred( Length( CAFE_OrdenVariableGeneral ) ) );
      PivoteString
      +=        QuotedStr
      ( CAFE_AlternativaVariableGeneral[ RecorreVariableGlobal ] );
      PivoteString
      +=        ','+CAFE_VariantToString( VarianteEscribir )+')';
      MyList.Add( PivoteString );
    END;  { IF BanderaEscribir }
  END;  { FOR RecorreVariableGlobal }
END;   { PROCEDURE CAFE_ManejadorBasicoString.ManejadorToTStringList }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
CONSTRUCTOR CAFE_HojaCalculoString.Create
  (       ACollection           : TCollection                           );
{ override; }
BEGIN  { CONSTRUCTOR CAFE_HojaCalculoString.Create }
  // Sustituir el ADD, en TStreamCollection por uno parametrico
  Inherited Create( ACollection );
  MoldeGeneradorHoja            := CAFE_HojaCalculoString;
END;   { CONSTRUCTOR CAFE_HojaCalculoString.Create }

CONSTRUCTOR CAFE_HojaCalculoString.Create
  (       ACollection           : TStreamCollection;
          Filas, Columnas       : LongInt                               );
BEGIN  { CONSTRUCTOR CAFE_HojaCalculoString.Create }
  Inherited Create( ACollection, Filas, Columnas );
  MoldeGeneradorHoja            := CAFE_HojaCalculoString;
END;   { CONSTRUCTOR CAFE_HojaCalculoString.Create }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }

DESTRUCTOR CAFE_HojaCalculoString.Destroy;
BEGIN  { DESTRUCTOR CAFE_HojaCalculoString.Destroy }
  Inherited Destroy;
END;   { DESTRUCTOR CAFE_HojaCalculoString.Destroy }

  {$IFDEF       SILENCIAR       }
  {$HINTS       OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_HojaCalculoString.IsCasillaBloqueada
  (       Fila, Columna         : LongInt                       ) : Boolean;
BEGIN  { FUNCTION CAFE_HojaCalculoString.IsCasillaBloqueada }
  IsCasillaBloqueada            :=
                BloquearCasillasCVDH IN DescriptoresHoja;
END;   { FUNCTION CAFE_HojaCalculoString.IsCasillaBloqueada }

FUNCTION    CAFE_HojaCalculoString.IsZonaCasillaBloqueada
  (       FilaI, ColumnaI, FilaF, ColumnaF      : LongInt       ) : Boolean;
//VAR
//  RecorreFila,
//  RecorreColumna                : LongInt;

BEGIN  { FUNCTION CAFE_HojaCalculoString.IsZonaCasillaBloqueada }
//  FOR RecorreFila := Min( FilaI, FilaF ) TO Max( FilaI, FilaF ) DO BEGIN
//    FOR RecorreColumna := Min( ColumnaI, ColumnaF ) TO
//                                Max( ColumnaI, ColumnaF ) DO BEGIN
//      IF IsCasillaBloqueada( RecorreFila, RecorreColumna )
//      THEN Exit( TRUE );
//    END;  { FOR RecorreColumna }
//  END;  { FOR RecorreFila }
//  IsZonaCasillaBloqueada        := FALSE;
  IsZonaCasillaBloqueada        :=
                BloquearCasillasCVDH IN DescriptoresHoja;
END;   { FUNCTION CAFE_HojaCalculoString.IsZonaCasillaBloqueada }

PROCEDURE   CAFE_HojaCalculoString.FormatoHojaToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL           );
{ virtual; }
VAR
  PivoteString                  : ShortString;

BEGIN  { PROCEDURE CAFE_HojaCalculoString.FormatoHojaToTStringList }
  GenerarNombreCasillaHoja( PivoteString, FALSE, Pred( ColumnasEnHoja ),
                        FALSE, Pred( FilasEnHoja ) );
  PivoteString                  := Copy( CAFE_OrdenFormatoCasilla,
                1, Pred( Length( CAFE_OrdenFormatoCasilla ) ) )+
                'A1:'+PivoteString+',APPLICATION)';
  MyList.Add( PivoteString );
END;   { PROCEDURE CAFE_HojaCalculoString.FormatoHojaToTStringList }
  {$IFDEF       SILENCIAR       }
  {$HINTS       ON              }
  {$ENDIF                       }

FUNCTION    CAFE_HojaCalculoString.CasillaToString
  (       Fila, Columna         : LongInt                       ) : String;
VAR
  MyString                      : AnsiString;
  PivoteShort                   : ShortString;
  MyVariant                     : Variant;
  PivoteDescriptor              : CAFE_DatoExtendido;
  BanderaSimple                 : Boolean;

BEGIN  { FUNCTION CAFE_HojaCalculoString.CasillaToString }
  GenerarNombreCasillaHoja( PivoteShort, FALSE, Columna, FALSE, Fila );
  MyVariant                     := VariantHoja[ Fila ][ Columna ];
  IF CAFE_TipoVariante( MyVariant ) = varString THEN BEGIN
    PivoteDescriptor            := SintacticaHoja[ Fila ][ Columna ];
    BanderaSimple               := PivoteDescriptor = NIL;
    IF PivoteDescriptor <> NIL
    THEN BanderaSimple          :=
                NOT( PivoteDescriptor IS CAFE_DatoNudilladoString );
    IF BanderaSimple THEN BEGIN
      MyString                  := MyVariant;
      CasillaToString           :=
                PivoteShort+':='+AnsiQuotedStr( PChar( MyString ), '''' );
    END ELSE BEGIN  { IF BanderaSimple ELSE }
      WITH PivoteDescriptor AS CAFE_DatoNudilladoString DO BEGIN
        PivoteShort
        +=      ToString;
        CasillaToString         :=
                PivoteShort+':='+MyVariant;
      END;  { WITH PivoteDescriptor AS CAFE_DatoNudilladoString }
    END;            { IF BanderaSimple ELSE }
  END ELSE BEGIN  { IF CAFE_TipoVariante( MyVariant ) = varString ELSE }
    CasillaToString             :=
        PivoteShort+':='+CAFE_VariantToString( MyVariant );
  END;            { IF CAFE_TipoVariante( MyVariant ) = varString ELSE }
END;   { FUNCTION CAFE_HojaCalculoString.CasillaToString }

PROCEDURE   CAFE_HojaCalculoString.StringToCasilla
  (       Manejador             : CAFE_InterfaceBasico;
    CONST MyString              : String                                );
VAR
  FuncionReturn                 : Variant;
  PivoteMsg                     : ShortString;
  SeccionInicial,
  SeccionDescriptor,
  SeccionAsignada               : String;
  PivoteArbol                   : CAFE_Nudo2Sintactico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  PivoteDescriptor              : CAFE_DatoNudilladoString;
  Fila,
  Columna,
  PosPivote                     : LongInt;
  BanderaDolarFila,
  BanderaDolarColumna,
  BanderaFuncionalInterna       : Boolean;

BEGIN  { PROCEDURE CAFE_HojaCalculoString.StringToCasilla }
  PosPivote                     := AnsiPos( ':=', MyString );
  IF PosPivote = 0 THEN BEGIN
    IF Trim( MyString ) = ''
    THEN Exit
    ELSE RAISE CAFE_PipeException.
        Create( ErrorREPO, CAFE_ErrorFormatoIncompatiblePendiente,
                                [ ''':=''' ] );
  END;  { IF PosPivote = 0 }
  SeccionInicial                :=
        Trim( UpperCase( Copy( MyString, 1, PosPivote-1 ) ) );
  SeccionAsignada               :=
        TrimLeft( Copy( MyString, PosPivote+2, Length( MyString ) ) );
  PosPivote                     := AnsiPos( '(', SeccionInicial );
  IF PosPivote = 0
  THEN BanderaFuncionalInterna  := FALSE
  ELSE BEGIN  { IF PosPivote = 0 ELSE }
    BanderaFuncionalInterna     := TRUE;
    SeccionDescriptor           :=
        Trim( Copy( SeccionInicial, PosPivote, Length( SeccionInicial ) ) );
    SeccionInicial              :=
        Trim( Copy( SeccionInicial, 1, PosPivote-1 ) );
  END;        { IF PosPivote = 0 ELSE }
  IF IdentificadorValidoCasilla( SeccionInicial,
        BanderaDolarFila, Fila, BanderaDolarColumna, Columna ) THEN BEGIN
    IF IsCasillaBloqueada( Fila, Columna )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorCasillaBloqueadaHojaTrabajo );
    AnularCasilla( Fila, Columna );
    IF BanderaFuncionalInterna THEN BEGIN
      VariantHoja[ Fila ][ Columna ]            := SeccionAsignada;
      Manejador.Actual.GetInterfaceByStr
                    ( CAFE_GUIDInterfaceManejador, MyManejador );
      WITH MyManejador DO BEGIN
        PivoteDescriptor        :=
                ( NudilladoManejador AS CAFE_DatoNudilladoString ).
                        PeticionSimilarBaseString( SeccionDescriptor );
        IF PivoteDescriptor = NIL THEN BEGIN
          RAISE CAFE_PipeCasillaException.
            Create( Fila, Columna, SintaxisErrorPECM,
                CAFE_ErrorDescriptorCasillaIncompatible,
                [ QuotedStr( SeccionInicial ) ] );
        END ELSE BEGIN  { IF PivoteDescriptor = NIL ELSE }
          SintacticaHoja[ Fila ][ Columna ]     := PivoteDescriptor;
          WITH PivoteDescriptor DO BEGIN
            IF CAFE_HabilitarUnCiclo THEN BEGIN
              IF [ CicloTomarVariantHCGM,
                   CicloConteoHCGM, CicloEvaluarHCGM ]*MacroParametro = []
              THEN MacroParametro               := MacroParametro+
                        [ ActivarCicloHCGM, CicloTomarVariantHCGM ];
            END;  { IF CAFE_HabilitarUnCiclo }
          END;  { WITH PivoteDescriptor }
          IF NOT( PeticionNudillarMacroFuncionSimple
                ( Fila, Columna, PivoteMsg, Manejador ) ) THEN BEGIN
            PivoteDescriptor.BanderaPeticionNudillar            := TRUE;
            IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
              IF CAFE_PosicionInfructuosoSintactico <> 0 THEN BEGIN
                RAISE CAFE_PipeCasillaException.
                        Create( Fila, Columna, SintaxisErrorPECM,
                        CAFE_PosicionInfructuosoSintactico,
                        [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
              END;  { IF CAFE_MensajeInfructuosoSintactico <> '' }
            END;  { IF ImplementationInfructuosoSintacticoNoPipe }
            CAFE_MensajeInfructuoso.ClearMessage;
            IF PivoteMsg = '' THEN BEGIN
              RAISE CAFE_PipeCasillaException.Create
                ( Fila, Columna, SintaxisErrorPECM,
                  CAFE_ErrorVarErrorInterpretar );
            END ELSE BEGIN  { IF PivoteMsg = '' }
              RAISE CAFE_MensajeException.
                        Create( PivoteMsg+' en '+
                UpCase( SeccionInicial ), Fila*ColumnasEnHoja+Columna+1 );
            END;            { IF PivoteMsg = '' }
          END;  { IF NOT( PeticionNudillarMacroFuncionSimple ) }
        END;            { IF PivoteDescriptor = NIL ELSE }
      END;  { WITH MyManejador }
    END ELSE BEGIN  { IF BanderaFuncionalInterna ELSE }
      PosPivote                     := AnsiPos( '(', SeccionAsignada );
      IF PosPivote = 1 THEN BEGIN
        Manejador.Actual.GetInterfaceByStr
                      ( CAFE_GUIDInterfaceManejador, MyManejador );
        WITH MyManejador DO BEGIN
          IF NOT( GramaticaCharByte.GramaticaOperadores( SeccionAsignada ) )
          THEN BEGIN  { IF NOT( GramaticaCharByte.GramaticaOperadores ) }
            IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
              IF CAFE_PosicionInfructuosoSintactico <> 0 THEN BEGIN
                RAISE CAFE_PipeCasillaException.
                        Create( Fila, Columna, SintaxisErrorPECM,
                        CAFE_PosicionInfructuosoSintactico,
                        [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
              END;  { IF CAFE_MensajeInfructuosoSintactico <> '' }
            END;  { IF ImplementationInfructuosoSintacticoNoPipe }
            RAISE CAFE_PipeCasillaException.
              Create( Fila, Columna, SintaxisErrorPECM,
                CAFE_ErrorVarErrorInterpretar );
          END;        { IF NOT( GramaticaCharByte.GramaticaOperadores ) }
          PivoteArbol                   :=
                GeneradorArbolSintactico.NuevoArbol( GramaticaCharByte );
          IF CAFE_IntentoInfructuosoSintactico THEN BEGIN
            FreeAndNil( PivoteArbol );
            IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
              IF CAFE_PosicionInfructuosoSintactico <> 0 THEN BEGIN
                RAISE CAFE_PipeCasillaException.
                        Create( Fila, Columna, SintaxisErrorPECM,
                        CAFE_PosicionInfructuosoSintactico,
                        [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
              END;  { IF CAFE_MensajeInfructuosoSintactico <> '' }
            END;  { IF ImplementationInfructuosoSintacticoNoPipe }
            RAISE CAFE_PipeCasillaException.
              Create( Fila, Columna, SintaxisErrorPECM,
                CAFE_ErrorDescriptorCasillaIncompatible,
                [ QuotedStr( SeccionInicial ) ] );
          END;  { IF CAFE_IntentoInfructuosoSintactico }
          WITH PivoteArbol DO BEGIN
            IF DescendienteVertical = NIL THEN BEGIN
              FreeAndNIL( PivoteArbol );
              RAISE CAFE_PipeException.Create( ErrorREPO,
                      CAFE_ErrorFaltanParametrosEnOperador,
                      [ QuotedStr( '()' ) ] );
            END;  { IF DescendienteVertical = NIL }
            IF NOT( ( DescendienteVertical as CAFE_Nudo2Sintactico ).
                      InterpretarFuncion( Manejador, FuncionReturn, PivoteMsg ) )
            THEN BEGIN
              FreeAndNil( PivoteArbol );
              IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
                IF CAFE_MensajeInfructuosoSintactico <> '' THEN BEGIN
                  RAISE CAFE_PipeCasillaException.
                          Create( Fila, Columna, SintaxisErrorPECM,
                          CAFE_PosicionInfructuosoSintactico,
                          [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
                END;  { IF CAFE_MensajeInfructuosoSintactico <> '' }
              END;  { IF ImplementationInfructuosoSintacticoNoPipe }
              RAISE CAFE_PipeCasillaException.Create
                ( Fila, Columna, SintaxisErrorPECM,
                  CAFE_ErrorVarErrorInterpretar );
            END;  { IF NOT( PivoteArbol.InterpretarFuncion... ) }
            IF NOT( ( DescendienteVertical as CAFE_Nudo2Sintactico ).
                      EvaluarFuncion( FuncionReturn, PivoteMsg, MyManejador ) )
            THEN BEGIN
              FreeAndNIL( PivoteArbol );
              IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
                IF CAFE_MensajeInfructuosoSintactico <> '' THEN BEGIN
                  RAISE CAFE_PipeCasillaException.
                          Create( Fila, Columna, EjecutarErrorPECM,
                          CAFE_PosicionInfructuosoSintactico,
                          [ QuotedStr
                                ( CAFE_MensajeInfructuosoSintactico ) ] );
                END;  { IF CAFE_MensajeInfructuosoSintactico <> '' }
              END;  { IF ImplementationInfructuosoSintacticoNoPipe }
              RAISE CAFE_PipeCasillaException.Create
                ( Fila, Columna, EjecutarErrorPECM,
                  CAFE_ErrorVarErrorEvaluar );
            END;  { IF NOT( PivoteArbol... ) }
          END;  { WITH PivoteArbol }
          FreeAndNil( PivoteArbol );
          VariantHoja[ Fila ][ Columna ]        := FuncionReturn;
        END;  { WITH MyManejador }
      END ELSE BEGIN  { IF PosPivote = 1 ELSE }
        VariantHoja[ Fila ][ Columna ]          :=
                        CAFE_StringToVariant( SeccionAsignada );
      END;            { IF PosPivote = 1 ELSE }
    END;            { IF BanderaFuncionalInterna ELSE }
  END ELSE BEGIN  { IF IdentificadorValidoCasilla( SeccionInicial... ) ELSE }
    RAISE CAFE_PipeException.Create( ErrorREPO,
        CAFE_ErrorIdentificadorInvalido,
        [ QuotedStr( SeccionInicial ) ] );
  END;            { IF IdentificadorValidoCasilla( SeccionInicial... ) ELSE }
END;   { PROCEDURE CAFE_HojaCalculoString.StringToCasilla }

PROCEDURE   CAFE_HojaCalculoString.VariantHojaToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL           );
VAR
  PivoteString                  : String;
  RecorreFila,
  RecorreColumna                : LongInt;

BEGIN  { PROCEDURE CAFE_HojaCalculoString.VariantHojaToTStringList }
  FOR RecorreFila := Low( VariantHoja ) TO High( VariantHoja ) DO BEGIN
    FOR RecorreColumna := Low( VariantHoja[ RecorreFila ] ) TO
                                High( VariantHoja[ RecorreFila ] ) DO BEGIN
      IF NOT( CasillaNull( RecorreFila, RecorreColumna ) ) THEN BEGIN
        TRY
          PivoteString          :=
                        CasillaToString( RecorreFila, RecorreColumna );
          MyList.Add( PivoteString );
        EXCEPT
          ON MyError    : CAFE_PipeCasillaException
          DO BEGIN
            WITH MyError DO BEGIN
              PivoteString      :=
                QuotedStr( Message )+' '+
                QuotedStr( 'Error casilla ('+
                        IntToStr( Succ( ColumnaReferencia ) )+','+
                        IntToStr( Succ( FilaReferencia ) )+')' );
              ErrorList.Add( CAFE_GenerarMensajeOutputCodigoCasilla
                ( PivoteString, NumeroRenglon,
                  CodigoAcumulado[ TypeException ],
                  TypeException, FilaReferencia, ColumnaReferencia,
                  Ord( EstiloMsgReferencia ), HelpContext ) );
              Inc( CodigoAcumulado[ TypeException ] );
            END;  { WITH MyError }
          END;  { ON CAFE_PipeCasillaException }
          ON MyError    : CAFE_PipeException
          DO BEGIN
            WITH MyError DO BEGIN
              PivoteString      := QuotedStr( Message );
              ErrorList.Add( CAFE_GenerarMensajeOutputCodigoNumeral
                ( PivoteString, NumeroRenglon,
                  CodigoAcumulado[ TypeException ],
                  TypeException, HelpContext ) );
              Inc( CodigoAcumulado[ TypeException ] );
            END;  { WITH MyError }
          END;  { ON CAFE_PipeException }
        END;  { TRY }
      END;  { IF NOT( CasillaNull( RecorreFila, RecorreColumna ) ) }
    END;  { FOR RecorreColumna }
  END;  { FOR RecorreFila }
END;   { PROCEDURE CAFE_HojaCalculoString.VariantHojaToTStringList }

PROCEDURE   CAFE_HojaCalculoString.HojaReinicio;
{ virtual; }
BEGIN  { PROCEDURE CAFE_HojaCalculoString.HojaReinicio }
  IF BloquearCasillasCVDH IN DescriptoresHoja
  THEN RAISE CAFE_PipeException.Create
    ( ErrorREPO, CAFE_ErrorCasillaBloqueadaHojaTrabajo );
  LiberarTodaCasilla;
  DescriptoresHoja              := CAFE_DescriptoresDefaultHoja;
END;   { PROCEDURE CAFE_HojaCalculoString.HojaReinicio }

PROCEDURE   CAFE_HojaCalculoString.HojaCalculoToTStringList
  (       MyList                : CAFE_TStringPipe0;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          ErrorList             : CAFE_TStringPipe0     = NIL           );
VAR
  PivoteString                  : ShortString;

BEGIN  { PROCEDURE CAFE_HojaCalculoString.HojaCalculoToTStringList }
  PivoteString                  := Copy( CAFE_OrdenDescribirHoja, 1,
                Pred( Length( CAFE_OrdenDescribirHoja ) ) );
  PivoteString
  +=    '$'+IntToHex( CAFE_ConjuntoVariantesDescriptoresHojaToLongInt
                ( DescriptoresHoja ), 1 )+')';
  MyList.Add( PivoteString );
  VariantHojaToTStringList
        ( MyList, NumeroRenglon, CodigoAcumulado, ErrorList );
  FormatoHojaToTStringList
        ( MyList, NumeroRenglon, CodigoAcumulado, ErrorList );
END;   { PROCEDURE CAFE_HojaCalculoString.HojaCalculoToTStringList }

FUNCTION    CAFE_VariantToString
  ( CONST MyVariant     : Variant                       ) : ShortString;
VAR
  PivoteReal            : Double;

BEGIN  { FUNCTION CAFE_VariantToString }
  CASE CAFE_TipoVariante( MyVariant ) OF
    varNull             : CAFE_VariantToString  := 'NULL';
    varByte             : CAFE_VariantToString  := IntToStr( MyVariant );
    varInteger          : CAFE_VariantToString  := IntToStr( MyVariant );
    varDouble           : BEGIN
                            PivoteReal          := MyVariant;
                            PivoteReal          :=
                                CAFE_RedondeoTolerancia
                                ( PivoteReal, 5E-8*PivoteReal );
                            CAFE_VariantToString  :=
                                        FloatToStr( PivoteReal );
                          END;  { CASE VarDouble }
    varString           : CAFE_VariantToString  := MyVariant;
    varDate             : CAFE_VariantToString  := DateToStr( MyVariant );
    varBoolean          : CAFE_VariantToString  :=
                BoolToStr( MyVariant, 'TRUE', 'FALSE' );
    ELSE RAISE CAFE_PipeException.
        Create( ErrorREPO, CAFE_ErrorTipoVarianteIncompatible );
  END;  { CASE CAFE_TipoVariante( MyVariant ) }
END;   { FUNCTION CAFE_VariantToString }

FUNCTION    CAFE_StringToVariant
  ( CONST MyString      : String                                ) : Variant;
VAR
  MyPChar               : PChar;
  PivoteStringAux,
  PivoteString          : AnsiString;
  PivoteDate            : TDateTime;
  PivoteReal            : Double;
  PivoteEntero,
  PivotePos             : LongInt;

BEGIN  { FUNCTION CAFE_StringToVariant }
  PivoteString                  := Trim( MyString );
  IF PivoteString = '' THEN BEGIN
    CAFE_StringToVariant        := Null;
    Exit;
  END;  { IF PivoteString = '' }
  PivotePos                     := AnsiPos( '''', PivoteString );
  IF PivotePos = 1 THEN BEGIN
    MyPChar                     := PChar( PivoteString );
    PivoteStringAux             :=
        AnsiExtractQuotedStr( MyPChar, '''' );
    IF MyPChar <> ''
    THEN BEGIN
      MyPChar                   := '';
      PivoteStringAux           := '';
      PivoteString              := '';
      RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorStringMalDefinida );
    END;  { IF MyPChar <> '' }
    PivoteString                := '';
    CAFE_StringToVariant        := PivoteStringAux;
    Exit;
  END;  { IF PivotePos = 1 }
  TRY
    PivoteEntero                := StrToInt( PivoteString );
    CAFE_StringToVariant        := PivoteEntero;
  EXCEPT
    ON EConvertError
    DO BEGIN
      TRY
        PivoteReal              := StrToFloat( PivoteString );
        CAFE_StringToVariant    := PivoteReal;
      EXCEPT
        ON EConvertError
        DO BEGIN
          TRY
            PivoteDate                  := StrToDate( PivoteString );
            CAFE_StringToVariant        := PivoteDate;
          EXCEPT
            ON EConvertError
            DO BEGIN
              PivoteString              := UpCase( PivoteString );
              IF PivoteString = 'NULL'
              THEN CAFE_StringToVariant     := Null
              ELSE IF PivoteString = 'TRUE'
                   THEN CAFE_StringToVariant     := TRUE
                   ELSE IF PivoteString = 'FALSE'
                        THEN CAFE_StringToVariant     := FALSE
                        ELSE CAFE_StringToVariant     := TrimLeft( MyString );
            END;  { ON EConvertError }
          END;  { TRY }
        END;  { ON EConvertError }
      END;  { TRY }
    END;  { ON EConvertError }
  END;  { ON TRY }
END;   { FUNCTION CAFE_StringToVariant }

CONSTRUCTOR CAFE_NudoSintacticoString.Create;
BEGIN  { CONSTRUCTOR CAFE_NudoSintacticoString.Create }
  Inherited Create;
  MoldeGenerar                  := CAFE_NudoSintacticoString;
END;   { CONSTRUCTOR CAFE_NudoSintacticoString.Create }

CONSTRUCTOR CAFE_NudoSintacticoString.Create
  (     Ide                     : LongInt                               );
BEGIN  { CONSTRUCTOR CAFE_NudoSintacticoString.Create }
  Inherited Create( Ide );
  MoldeGenerar                  := CAFE_NudoSintacticoString;
END;   { CONSTRUCTOR CAFE_NudoSintacticoString.Create }

CONSTRUCTOR CAFE_NudoSintacticoString.Create
  (     Ide                     : LongInt;
        NuevoDato               : Variant                               );
BEGIN  { CONSTRUCTOR CAFE_NudoSintacticoString.Create }
  Inherited Create( Ide, NuevoDato );
  MoldeGenerar                  := CAFE_NudoSintacticoString;
END;   { CONSTRUCTOR CAFE_NudoSintacticoString.Create }

CONSTRUCTOR CAFE_NudoSintacticoString.Create
  (     Modelo                  : CAFE_NudoSintactico                   );
BEGIN  { CONSTRUCTOR CAFE_NudoSintacticoString.Create }
  Inherited Create( Modelo );
  MoldeGenerar                  := CAFE_NudoSintacticoString;
END;   { CONSTRUCTOR CAFE_NudoSintacticoString.Create }

DESTRUCTOR  CAFE_NudoSintacticoString.Destroy;
BEGIN  { DESTRUCTOR CAFE_NudoSintacticoString.Destroy }
  Inherited Destroy;
END;   { DESTRUCTOR CAFE_NudoSintacticoString.Destroy }

PROCEDURE   CAFE_NudoSintacticoString.EjecutarOrdenHoja
  ( CONST OrdenPipe             : ShortString;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico                  );
{ virtual; }
VAR
  FuncionReturn                 : Variant;
  PivoteStringPrevio,
  PivoteMsg,
  PivoteString                  : ShortString;
  PivoteNodoNOT                 : CAFE_NudoSintacticoString;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  BanderaNOTInterno             : Boolean;
  ExitoFracaso                  : CAFE_RespuestaEstiloPipe;

    { ANIDADO }
  PROCEDURE AnidadoEvaluarSecuencia;
  VAR
    RecorreFila,
    RecorreColumna,
    FilaI,
    ColumnaI,
    FilaF,
    ColumnaF                    : LongInt;

  BEGIN  { PROCEDURE AnidadoEvaluarSecuencia }
    LeerRangoCasillaObligatorio
        ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    FOR RecorreFila := FilaI TO FilaF DO BEGIN
      FOR RecorreColumna := ColumnaI TO ColumnaF DO BEGIN
        EjecutarOrdenEvaluarCasilla( RecorreFila, RecorreColumna,
                          NumeroRenglon, CodigoAcumulado, Manejador );
      END;  { FOR RecorreColumna }
    END;  { FOR RecorreFila }
  END;   { PROCEDURE AnidadoEvaluarSecuencia }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenSave;
  VAR
    NombreGrupo,
    NombreArch                  : ShortString;
    PivoteNodo                  : CAFE_NudoSintactico;

  BEGIN  { PROCEDURE AnidadoOrdenSave }
    MyManejador.PaqueteUndo.ClearUndo;
    IF TotalDescendientesDirectos <> 2
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenSaveHojaTrabajo ) ] );
    PivoteNodo                  := DescendienteVertical;
    NombreArch                  :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).LeerStObligatorio( TRUE );
    PivoteNodo                  := PivoteNodo.DescendienteHorizontal;
    NombreGrupo                 :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).LeerStObligatorio( TRUE );
    EjecutarOrdenSave( NombreArch, NombreGrupo,
                        NumeroRenglon, CodigoAcumulado, Manejador );
  END;   { PROCEDURE AnidadoOrdenSave }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenLoad;
  VAR
    NombreArch                  : ShortString;
    PivoteNodo                  : CAFE_NudoSintactico;

  BEGIN  { PROCEDURE AnidadoOrdenLoad }
    MyManejador.PaqueteUndo.ClearUndo;
    IF TotalDescendientesDirectos <> 1
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenLoadHojaTrabajo ) ] );
    PivoteNodo                  := DescendienteVertical;
    NombreArch                  :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).LeerStObligatorio( TRUE );
    EjecutarOrdenLoad( NombreArch, NumeroRenglon,
                                CodigoAcumulado, Manejador );
  END;   { PROCEDURE AnidadoOrdenLoad }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenCrearHoja;
  VAR
    NuevaHoja                   : CAFE_HojaCalculoString;
    PivoteNodo                  : CAFE_NudoSintactico;
    NuevoManejador              : CAFE_ManejadorBasico;
    SaveItem                    : CAFE_TCollectionItemSave;
    NombreHoja                  : ShortString;
    ClaveHoja,
    ColumnaInterior,
    FilaInterior,
    TotalParametros             : LongInt;
    BanderaSaveItem,
    BanderaAislado              : Boolean;

  BEGIN  { PROCEDURE AnidadoOrdenCrearHoja }
    MyManejador.PaqueteUndo.ClearUndo;
    TotalParametros             := TotalDescendientesDirectos;
    IF NOT( InRange( TotalParametros, 3, 4 ) )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenCrearHojaTrabajo ) ] );
    PivoteNodo                  := DescendienteVertical;
    ColumnaInterior             :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).LeerLongIntObligatorio;
    PivoteNodo                  := PivoteNodo.DescendienteHorizontal;
    FilaInterior                :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).LeerLongIntObligatorio;
    IF NOT( InRange( FilaInterior, 1, CAFE_MaximoFilaCrearHoja ) AND
            InRange( ColumnaInterior, 1, CAFE_MaximoColumnaCrearHoja ) )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorDimensionesInaceptablesHojaTrabajo );
    PivoteNodo                  := PivoteNodo.DescendienteHorizontal;
    NombreHoja                  :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
    IF NombreHoja = CAFE_NombreManejadorTemporal
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorIdentificadorInvalido,
                [ QuotedStr( NombreHoja ) ] );
    BanderaAislado              := FALSE;
    IF TotalParametros = 4 THEN BEGIN
      PivoteNodo                := PivoteNodo.DescendienteHorizontal;
      ( PivoteNodo as CAFE_NudoSintacticoString ).
        LeerSelectorAlternativaObligatorio
        ( Manejador, ImplementationAlternativaHojaAislado );
      // RAISE si no encuentra el selector
      BanderaAislado            := TRUE;
    END;  { IF TotalParametros = 4 }
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      IF NOT( InProcesoLoad ) THEN ListaManejadoresLoad.Clear
      ELSE IF ListaManejadoresLoad.IndexOf( NombreHoja ) >= 0
           THEN RAISE CAFE_PipeException.Create
              ( ErrorREPO, CAFE_ErrorNombreDuplicadoHojaTrabajoEnGrupo,
                    [ QuotedStr( NombreHoja ),
                      QuotedStr( GrupoSaveActivo ) ] );
      BanderaSaveItem           := BanderaAislado OR
        NOT( BanderaMantenerGrupoSave ) OR
        ( GrupoSaveActivo = CAFE_NombreGrupoTemporal );
      NuevaHoja                   := CAFE_HojaCalculoString.
                  Create( NIL, FilaInterior, ColumnaInterior );
      NuevoManejador              := CAFE_RaizManejadores.Add as
                                                CAFE_ManejadorBasico;
      WITH NuevoManejador as CAFE_ManejadorBasicoString DO BEGIN
        GetInterfaceByStr
            ( CAFE_GUIDInterfaceManejador,
            ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
            InterfaceManejadorActivo );
        ActivarModoBasico( NuevaHoja, CAFE_ModoQuimico );
        EstablecerNombrePaquete( NombreHoja );
        ClaveHoja                   := ID;
        IF BanderaAislado
        THEN Include( NuevaHoja.DescriptoresHoja, HojaAisladaCVDH );
      END;  { WITH NuevoManejador }
      IF BanderaSaveItem AND BanderaAislado THEN BEGIN
        IF ListaGruposLoadSave.GrupoVacio( GrupoSaveActivo )
        THEN BanderaSaveItem            := FALSE;
      END;  { IF BanderaSaveItem AND BanderaAislado }
      IF BanderaSaveItem THEN BEGIN
        SaveItem                    := ListaGruposLoadSave.Add as
                                                CAFE_TCollectionItemSave;
        GrupoSaveActivo             :=
              ListaGruposLoadSave.GenerarNuevoNombreGrupo;
        SaveItem.NombreItemSave               := GrupoSaveActivo;
        BanderaMantenerGrupoSave    := NOT( BanderaAislado );
      END;  { IF BanderaSaveItem }
      ListaGruposLoadSave.
        AgregarManejadorBasicoGrupoSaveVinculado
                        ( GrupoSaveActivo, NuevoManejador );
      IF InProcesoLoad THEN BEGIN
        ListaManejadoresLoad.Add( NombreHoja );
      END ELSE BEGIN  { IF InProcesoLoad ELSE }
        WriteLn( CAFE_Application.PipeOutputText,
          CAFE_GenerarMensajeOutputCodigoNumeral
          ( QuotedStr( CAFE_VariantToString( ClaveHoja ) ),
                  NumeroRenglon,
                  CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
        Inc( CodigoAcumulado[ ResultREPO ] );
        WriteLn( CAFE_Application.PipeOutputText,
          CAFE_GenerarMensajeOutputCodigoNumeral
          ( QuotedStr( GrupoSaveActivo ),
                  NumeroRenglon,
                  CodigoAcumulado[ NombreREPO ], NombreREPO, 0 ) );
        Inc( CodigoAcumulado[ NombreREPO ] );
      END;            { IF InProcesoLoad ELSE }
    END;  { WITH CAFE_RaizManejdores }
  END;   { PROCEDURE AnidadoOrdenCrearHoja }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenDescribirHoja;
  VAR
    ClaveLongInt                        : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenDescribirHoja }
    WITH MyManejador DO BEGIN
      IF HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
          Create( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
      IF TotalDescendientesDirectos <> 1
      THEN RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                          [ QuotedStr( CAFE_OrdenDescribirHoja ) ] );
      ClaveLongInt                      :=
        ( DescendienteVertical as CAFE_NudoSintacticoString ).
                LeerLongIntObligatorio;
      HojaDefault.DescriptoresHoja      :=
        CAFE_LongIntToConjuntoVariantesDescriptoresHoja( ClaveLongInt );
    END;  { WITH MyManejador }
  END;   { PROCEDURE AnidadoOrdenDescribirHoja }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoActivarHojaTrabajo;
  VAR
    NombreHoja                  : ShortString;
    MyGrupoSave                 : CAFE_TCollectionItemSave;
    PivoteNodo                  : CAFE_NudoSintactico;
    MyManejadorBasico           : CAFE_ManejadorBasico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
    MyIntf                      : CAFE_InterfaceBasico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
    TotalParametros,
    ClaveHoja                   : LongInt;

  BEGIN  { PROCEDURE AnidadoActivarHojaTrabajo }
    MyManejador.PaqueteUndo.ClearUndo;
    TotalParametros             := TotalDescendientesDirectos;
    IF NOT( InRange( TotalParametros, 1, 2 ) )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenActivarHojaTrabajo ) ] );
    PivoteNodo                  := DescendienteVertical;
    NombreHoja                  :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
    MyIntf                      :=
      ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
                                      ID[ NombreHoja ];
    IF MyIntf = NIL
    THEN RAISE CAFE_PipeException.Create
      ( ErrorREPO, CAFE_ErrorNombreHojaTrabajoInexistente,
              [ QuotedStr( NombreHoja ) ] );
    IF TotalParametros <> 1 THEN BEGIN
      PivoteNodo                := PivoteNodo.DescendienteHorizontal;
      ClaveHoja                 :=
          ( PivoteNodo as CAFE_NudoSintacticoString ).LeerLongIntObligatorio;
      IF MyIntf.Actual.ID <> ClaveHoja THEN BEGIN
        MyManejadorBasico       := CAFE_RaizManejadores.ID[ ClaveHoja ];
        IF MyManejadorBasico = NIL
        THEN RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorNoConcordanciaNombreHojaTrabajoControl,
                        [ QuotedStr( NombreHoja ),
                          QuotedStr( IntToStr( ClaveHoja ) ) ] );
        IF MyManejadorBasico.HojaDefault = NIL
        THEN RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
        IF NombreHoja <> MyManejadorBasico.DisplayNombre
        THEN RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorNoConcordanciaNombreHojaTrabajoControl,
                        [ QuotedStr( NombreHoja ),
                          QuotedStr( IntToStr( ClaveHoja ) ) ] );
        MyManejadorBasico.GetInterfaceByStr
                        ( CAFE_GUIDInterfaceBasico, MyIntf );
      END;  { IF MyIntf.Actual.ID <> ClaveHoja}
    END;  { IF TotalParametros <> 1 }
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      MyGrupoSave               :=
                      ListaGruposLoadSave.BuscarGrupoSaveManejador
                      ( MyIntf.Actual as CAFE_ManejadorBasico );
      IF MyGrupoSave = NIL
      THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorHojaTrabajoCareceGrupoSaveAsignado,
                        [ QuotedStr( NombreHoja ) ] );
      InterfaceManejadorActivo  := MyIntf;
      GrupoSaveActivo           := MyGrupoSave.NombreItemSave;
      BanderaMantenerGrupoSave  :=
                ( GrupoSaveActivo <> CAFE_NombreGrupoTemporal ) AND
                NOT( MyGrupoSave.IsPrimerAislado( MyIntf ) );
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoActivarHojaTrabajo }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoActivarHojaTrabajoInLoad;
  VAR
    NombreHoja                  : ShortString;
    MyGrupoSave                 : CAFE_TCollectionItemSave;
    PivoteNodo                  : CAFE_NudoSintactico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
    MyIntf                      : CAFE_InterfaceBasico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
    PivotePos,
    TotalParametros             : LongInt;

  BEGIN  { PROCEDURE AnidadoActivarHojaTrabajoInLoad }
    // La diferencia InLoad es que solo se pueden activar
    // hojas predefinidas o 'Temporal'
    MyManejador.PaqueteUndo.ClearUndo;
    TotalParametros             := TotalDescendientesDirectos;
    IF NOT( TotalParametros = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenActivarHojaTrabajo ) ] );
    PivoteNodo                  := DescendienteVertical;
    NombreHoja                  :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
    MyIntf                      :=
      ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
                                      ID[ NombreHoja ];
    IF MyIntf = NIL
    THEN RAISE CAFE_PipeException.Create
      ( ErrorREPO, CAFE_ErrorNombreHojaTrabajoInexistente,
              [ QuotedStr( NombreHoja ) ] );
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      IF NombreHoja <> CAFE_NombreManejadorTemporal THEN BEGIN
        PivotePos               :=
                    ListaManejadoresLoad.IndexOf( NombreHoja );
        IF PivotePos < 0
        THEN RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoHojaTrabajo,
                    [ QuotedStr( NombreHoja ) ] );
      END;  { IF NombreHoja <> CAFE_NombreManejadorTemporal }
      MyGrupoSave               :=
                      ListaGruposLoadSave.BuscarGrupoSaveManejador
                      ( MyIntf.Actual as CAFE_ManejadorBasico );
      IF MyGrupoSave = NIL
      THEN RAISE CAFE_PipeHaltException.Create
        ( 'Proceso load produjo Hoja de trabajo extraviada en memoria' );
      InterfaceManejadorActivo  := MyIntf;
      GrupoSaveActivo           := MyGrupoSave.NombreItemSave;
      BanderaMantenerGrupoSave  := MyGrupoSave.IsPrimerAislado( Manejador );
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoActivarHojaTrabajoInLoad }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenAgregarHojaGrupoSave;
  VAR
    NombreHoja,
    NombreGrupo                 : ShortString;
    MyManejadorBasico           : CAFE_ManejadorBasico;
    PivoteNodo                  : CAFE_NudoSintactico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
    MyIntf                      : CAFE_InterfaceBasico;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
    ClaveHoja,
    TotalParametros             : LongInt;
    BanderaNombreGrupo,
    BanderaClaveHoja            : Boolean;

  BEGIN  { PROCEDURE AnidadoOrdenAgregarHojaGrupoSave }
    MyManejador.PaqueteUndo.ClearUndo;
    TotalParametros             := TotalDescendientesDirectos;
    IF NOT( InRange( TotalParametros, 1, 3 ) )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenAgregarHojaGrupoSave ) ] );
    PivoteNodo                  := DescendienteVertical;
    NombreHoja                  :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
    IF NombreHoja = CAFE_NombreManejadorTemporal
    THEN RAISE CAFE_PipeException.Create
      ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoHojaTrabajo,
                [ QuotedStr( NombreHoja ) ] );
    MyIntf                      :=
      ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
                                      ID[ NombreHoja ];
    IF MyIntf = NIL
    THEN RAISE CAFE_PipeException.Create
      ( ErrorREPO, CAFE_ErrorNombreHojaTrabajoInexistente,
              [ QuotedStr( NombreHoja ) ] );
    IF TotalParametros = 1 THEN BEGIN
      ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
      ListaGruposLoadSave.
        AgregarManejadorBasicoGrupoSaveVinculado
          ( ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
                 GrupoSaveActivo, MyIntf.Actual as CAFE_ManejadorBasico );
      Exit;
    END;  { IF TotalParametros = 1 ELSE }
    BanderaClaveHoja            := FALSE;
    BanderaNombreGrupo          := FALSE;
    IF TotalParametros = 2 THEN BEGIN
      PivoteNodo                := PivoteNodo.DescendienteHorizontal;
      IF CAFE_TipoVariante( PivoteNodo.DatoElemento ) = varString
      THEN BEGIN
        BanderaNombreGrupo      := TRUE;
        NombreGrupo             :=
          ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
      END ELSE BEGIN
        BanderaClaveHoja        := TRUE;
        ClaveHoja               :=
          ( PivoteNodo as CAFE_NudoSintacticoString ).LeerLongIntObligatorio;
      END;
    END;  { IF TotalParametros = 2 }
    IF TotalParametros = 3 THEN BEGIN
      PivoteNodo                := PivoteNodo.DescendienteHorizontal;
      BanderaClaveHoja          := TRUE;
      ClaveHoja                 :=
          ( PivoteNodo as CAFE_NudoSintacticoString ).LeerLongIntObligatorio;
      BanderaNombreGrupo        := TRUE;
      PivoteNodo                := PivoteNodo.DescendienteHorizontal;
      NombreGrupo               :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
    END;  { IF TotalParametros = 3 }
    WITH ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ) DO BEGIN
      MyManejadorBasico         := MyIntf.Actual as CAFE_ManejadorBasico;
      IF BanderaClaveHoja THEN BEGIN
        IF MyIntf.Actual.ID <> ClaveHoja THEN BEGIN
          MyManejadorBasico       := CAFE_RaizManejadores.ID[ ClaveHoja ];
          IF MyManejadorBasico = NIL
          THEN RAISE CAFE_PipeException.Create
            ( ErrorREPO, CAFE_ErrorNoConcordanciaNombreHojaTrabajoControl,
                          [ QuotedStr( NombreHoja ),
                            QuotedStr( IntToStr( ClaveHoja ) ) ] );
          IF MyManejadorBasico.HojaDefault = NIL
          THEN RAISE CAFE_PipeException.Create
                  ( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
          IF NombreHoja <> MyManejadorBasico.DisplayNombre
          THEN RAISE CAFE_PipeException.Create
            ( ErrorREPO, CAFE_ErrorNoConcordanciaNombreHojaTrabajoControl,
                          [ QuotedStr( NombreHoja ),
                            QuotedStr( IntToStr( ClaveHoja ) ) ] );
        END;  { IF MyIntf.Actual.ID <> ClaveHoja}
      END;  { IF BanderaClaveHoja }
      IF BanderaNombreGrupo THEN BEGIN
        IF NombreGrupo = CAFE_NombreGrupoTemporal
        THEN RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoGrupoSave,
                    [ QuotedStr( NombreGrupo ) ] );
        ListaGruposLoadSave.AgregarManejadorBasicoGrupoSaveVinculado
                          ( NombreGrupo, MyManejadorBasico );
      END ELSE BEGIN  { IF BanderaNombreGrupo ELSE }
        IF GrupoSaveActivo = CAFE_NombreGrupoTemporal
        THEN RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoGrupoSave,
                    [ QuotedStr( GrupoSaveActivo ) ] );
        ListaGruposLoadSave.AgregarManejadorBasicoGrupoSaveVinculado
                          ( GrupoSaveActivo, MyManejadorBasico );
      END;            { IF BanderaNombreGrupo ELSE }
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoOrdenAgregarHojaGrupoSave }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenDestuirHojaTrabajo;
  VAR
    NombreHoja                  : ShortString;
    MyManejadorBasico           : CAFE_ManejadorBasico;
    PivoteNodo                  : CAFE_NudoSintactico;
    ClaveHoja,
    TotalParametros             : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenDestuirHojaTrabajo }
    MyManejador.PaqueteUndo.ClearUndo;
    TotalParametros             := TotalDescendientesDirectos;
    IF NOT( TotalParametros = 2 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenDestruirHojaTrabajo ) ] );
    PivoteNodo                  := DescendienteVertical;
    NombreHoja                  :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
    IF NombreHoja = CAFE_NombreManejadorTemporal
    THEN RAISE CAFE_PipeException.Create
      ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoHojaTrabajo,
                [ QuotedStr( NombreHoja ) ] );
    PivoteNodo                  := PivoteNodo.DescendienteHorizontal;
    ClaveHoja                   :=
        ( PivoteNodo as CAFE_NudoSintacticoString).
                                LeerLongIntObligatorio;
    MyManejadorBasico           := CAFE_RaizManejadores.ID[ ClaveHoja ];
    IF MyManejadorBasico = NIL
    THEN RAISE CAFE_PipeException.Create
      ( ErrorREPO, CAFE_ErrorNoConcordanciaNombreHojaTrabajoControl,
                    [ QuotedStr( NombreHoja ),
                      QuotedStr( IntToStr( ClaveHoja ) ) ] );
    IF MyManejadorBasico.HojaDefault = NIL
    THEN RAISE CAFE_PipeException.Create
            ( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
    IF NombreHoja <> MyManejadorBasico.DisplayNombre
    THEN RAISE CAFE_PipeException.Create
      ( ErrorREPO, CAFE_ErrorNoConcordanciaNombreHojaTrabajoControl,
                    [ QuotedStr( NombreHoja ),
                      QuotedStr( IntToStr( ClaveHoja ) ) ] );
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      IF MyManejadorBasico =
                ( InterfaceManejadorActivo.Actual as CAFE_ManejadorBasico )
      THEN RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoHojaTrabajo,
                    [ QuotedStr( NombreHoja ) ] );
      //  No se permite borrar de memoria la hoja activa
      ListaGruposLoadSave.EliminarManejadorBasicoTodoGrupoSaveVinculado
                                        ( MyManejadorBasico );
      AtFreeID( ClaveHoja, TRUE );
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoOrdenDestuirHojaTrabajo }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenDestruirGrupoSave;
  VAR
    NombreGrupo                 : ShortString;
    PivoteNodo                  : CAFE_NudoSintactico;
    SaveItem                    : CAFE_TCollectionItemSave;
    MyManejadorBasico           : TObject;
    TotalParametros             : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenDestruirGrupoSave }
    MyManejador.PaqueteUndo.ClearUndo;
    TotalParametros             := TotalDescendientesDirectos;
    IF NOT( TotalParametros = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenDestruirGrupoSave ) ] );
    PivoteNodo                  := DescendienteVertical;
    NombreGrupo                 :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
    IF NombreGrupo = CAFE_NombreGrupoTemporal
    THEN RAISE CAFE_PipeException.Create
      ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoGrupoSave,
                [ QuotedStr( NombreGrupo ) ] );
    WITH ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ) DO BEGIN
      IF NombreGrupo = GrupoSaveActivo
      THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoGrupoSave,
                  [ QuotedStr( NombreGrupo ) ] );
      SaveItem                  :=
                ListaGruposLoadSave.BuscarNombreGrupoSave( NombreGrupo );
      IF SaveItem = NIL
      THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorNombreGrupoSaveInexistente,
                  [ QuotedStr( NombreGrupo ) ] );
      FOR Pointer( MyManejadorBasico ) IN SaveItem.ListaManejadoresSave
      DO BEGIN
        IF MyManejadorBasico <> NIL THEN BEGIN
          IF MyManejadorBasico is CAFE_ManejadorBasico THEN BEGIN
            IF MyManejadorBasico =
              ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
              InterfaceManejadorActivo.Actual
            THEN RAISE CAFE_PipeException.Create
              ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoGrupoSave,
                        [ QuotedStr( NombreGrupo ) ] );
          END;  { IF MyManejadorBasico is CAFE_ManejadorBasico }
        END;  { IF MyManejadorBasico <> NIL }
      END;  { FOR MyManejadorBasico }
      FOR Pointer( MyManejadorBasico ) IN SaveItem.ListaManejadoresSave
      DO BEGIN
        IF MyManejadorBasico <> NIL THEN BEGIN
          IF MyManejadorBasico is CAFE_ManejadorBasico THEN BEGIN
            CAFE_RaizManejadores.AtFreeID(
                ( MyManejadorBasico as CAFE_ManejadorBasico ).ID, TRUE );
          END ELSE BEGIN  { IF MyManejadorBasico is CAFE_ManejadorBasico }
            FreeAndNIL( MyManejadorBasico );
            // CUIDADO!!!, deberia ser suficiente y coherente....
          END;            { IF MyManejadorBasico is CAFE_ManejadorBasico }
        END;  { IF MyManejadorBasico <> NIL }
      END;  { FOR MyManejadorBasico }
      ListaGruposLoadSave.Delete( SaveItem.Index );
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoOrdenDestruirGrupoSave }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoActivarGrupoSave;
  VAR
    NombreGrupo                 : ShortString;
    PivoteNodo                  : CAFE_NudoSintactico;
    SaveItem                    : CAFE_TCollectionItemSave;
    TotalParametros             : LongInt;

  BEGIN  { PROCEDURE AnidadoActivarGrupoSave }
    MyManejador.PaqueteUndo.ClearUndo;
    TotalParametros             := TotalDescendientesDirectos;
    IF NOT( TotalParametros = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenActivarGrupoSave ) ] );
    PivoteNodo                  := DescendienteVertical;
    NombreGrupo                 :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
    IF NombreGrupo = CAFE_NombreGrupoTemporal
    THEN RAISE CAFE_PipeException.Create
      ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoGrupoSave,
                [ QuotedStr( NombreGrupo ) ] );
    WITH ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ) DO BEGIN
      SaveItem                  :=
                ListaGruposLoadSave.BuscarNombreGrupoSave( NombreGrupo );
      IF SaveItem = NIL
      THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorNombreGrupoSaveInexistente,
                  [ QuotedStr( NombreGrupo ) ] );
      GrupoSaveActivo           := NombreGrupo;
      BanderaMantenerGrupoSave  :=
                ( GrupoSaveActivo <> CAFE_NombreGrupoTemporal ) AND
                NOT( SaveItem.IsPrimerAislado( Manejador ) );
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoActivarGrupoSave }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenListaManejadores;
  VAR
    NombreGrupo                 : ShortString;
    SaveItem                    : CAFE_TCollectionItemSave;
    PivoteNodo                  : CAFE_NudoSintactico;
    MyManejadorBasico           : TObject;
    TotalParametros             : LongInt;
    CuentaManejador             : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenListaManejadores }
    TotalParametros             := TotalDescendientesDirectos;
    IF NOT( TotalParametros = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenListaManejadores ) ] );
    PivoteNodo                  := DescendienteVertical;
    NombreGrupo                 :=
        ( PivoteNodo as CAFE_NudoSintacticoString ).
                        LeerStIdentificadorObligatorio;
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      SaveItem                  :=
                ListaGruposLoadSave.BuscarNombreGrupoSave( NombreGrupo );
      IF SaveItem = NIL
      THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorNombreGrupoSaveInexistente,
                  [ QuotedStr( NombreGrupo ) ] );
      CuentaManejador           := 0;
      FOR Pointer( MyManejadorBasico ) IN SaveItem.ListaManejadoresSave
      DO BEGIN
        IF MyManejadorBasico <> NIL THEN BEGIN
          IF MyManejadorBasico is CAFE_ManejadorBasico THEN BEGIN
            WITH MyManejadorBasico as CAFE_ManejadorBasico DO BEGIN
              Inc( CuentaManejador );
              WriteLn( CAFE_Application.PipeOutputText,
                CAFE_GenerarMensajeOutputCodigoNumeral
                ( QuotedStr( DisplayNombre ),
                        NumeroRenglon,
                        CodigoAcumulado[ NombreREPO ], NombreREPO, 0 ) );
              Inc( CodigoAcumulado[ NombreREPO ] );
              WriteLn( CAFE_Application.PipeOutputText,
                CAFE_GenerarMensajeOutputCodigoNumeral
                ( QuotedStr( CAFE_VariantToString( ID ) ),
                        NumeroRenglon,
                        CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
              Inc( CodigoAcumulado[ ResultREPO ] );
            END;  { WITH MyManejadorBasico }
          END;  { IF MyManejadorBasico is CAFE_ManejadorBasico }
        END;  { IF MyManejadorBasico <> NIL }
      END;  { FOR MyManejadorBasico }
      IF CuentaManejador = 0 THEN BEGIN
        WriteLn( CAFE_Application.PipeStdErrText,
          CAFE_GenerarMensajeOutputCodigoNumeral
          ( QuotedStr( CAFE_SMensajeGrupoSaveSinManejadores ),
                  NumeroRenglon,
                  CodigoAcumulado[ MensajeREPO ], MensajeREPO,
                  CAFE_MensajeGrupoSaveSinManejadores ) );
        Inc( CodigoAcumulado[ MensajeREPO ] );
      END;  { IF CuentaManejador = 0 }
    END;  { WITH RaizManejadores }
  END;   { PROCEDURE AnidadoOrdenListaManejadores }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenCasillaCiclica;
  VAR
    CaracterMacro               : CAFE_ConjuntoParametroBasico;
    RecorreFila,
    RecorreColumna,
    NuevoTipo,
    NuevoConteo,
    FilaI,
    ColumnaI,
    FilaF,
    ColumnaF,
    TotalParametros             : LongInt;
    BanderaNudillado,
    BanderaMacro,
    BanderaConteo,
    BanderaTipo                 : Boolean;

  BEGIN  { PROCEDURE AnidadoOrdenCasillaCiclica }
    TotalParametros             := PivoteNodoNOT.TotalDescendientesDirectos;
    IF NOT( InRange( TotalParametros, 1, 3 ) )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenCasillaCiclica ) ] );
    PivoteNodoNOT               :=
        PivoteNodoNOT.DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteNodoNOT.LeerRangoCasillaObligatorio
        ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    WITH MyManejador.HojaDefault as CAFE_HojaCalculoString DO BEGIN
      IF IsZonaCasillaBloqueada( FilaI, ColumnaI, FilaF, ColumnaF )
      THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorCasillaBloqueadaHojaTrabajo );
      BanderaConteo             := FALSE;
      BanderaTipo               := FALSE;
      IF TotalParametros = 2 THEN BEGIN
        PivoteNodoNOT           :=
          PivoteNodoNOT.DescendienteHorizontal as CAFE_NudoSintacticoString;
        IF CAFE_TipoVariante( PivoteNodoNOT.DatoElemento ) = varString
        THEN BEGIN
          BanderaTipo           := TRUE;
          NuevoTipo             := PivoteNodoNOT.
                LeerSelectorAlternativaObligatorio
                ( Manejador, ImplementationAlternativaCasillaCiclica );
                // RAISE si no encuentra algun selector
        END ELSE BEGIN  { IF CAFE_TipoVariante... ELSE }
          BanderaConteo         := TRUE;
          NuevoConteo           :=
                PivoteNodoNOT.LeerLongIntObligatorio;
        END;            { IF CAFE_TipoVariante... ELSE }
      END;  { IF TotalParametros = 2 }
      IF TotalParametros = 3 THEN BEGIN
        PivoteNodoNOT           :=
          PivoteNodoNOT.DescendienteHorizontal as CAFE_NudoSintacticoString;
        BanderaTipo             := TRUE;
        NuevoTipo               := PivoteNodoNOT.
              LeerSelectorAlternativaObligatorio
              ( Manejador, ImplementationAlternativaCasillaCiclica );
              // RAISE si no encuentra algun selector
        PivoteNodoNOT           :=
          PivoteNodoNOT.DescendienteHorizontal as CAFE_NudoSintacticoString;
        BanderaConteo           := TRUE;
        NuevoConteo             :=
              PivoteNodoNOT.LeerLongIntObligatorio;
      END;  { IF TotalParametros = 3 }
      FOR RecorreFila := FilaI TO FilaF DO BEGIN
        FOR RecorreColumna := ColumnaI TO ColumnaF DO BEGIN
          IF BanderaNOTInterno THEN BEGIN
            IF BanderaTipo THEN BEGIN
              CASE NuevoTipo OF
                0       : ModificarMacroParametro
                        ( RecorreFila, RecorreColumna, [],
                                [ ActivarCicloHCGM, CicloTomarVariantHCGM ] );
                1       : ModificarMacroParametro
                        ( RecorreFila, RecorreColumna, [],
                                [ ActivarCicloHCGM,
                                  CicloConteoHCGM, CicloEvaluarHCGM ] );
                2       : ModificarMacroParametro
                        ( RecorreFila, RecorreColumna, [],
                                [ ActivarCicloHCGM, CicloEvaluarHCGM ] );
                3       : ModificarMacroParametro
                        ( RecorreFila, RecorreColumna, [],
                                [ ActivarCicloHCGM, CicloConteoHCGM,
                                  CicloEvaluarHCGM, FinConteoErrorHCGM ] );
                4       : ModificarMacroParametro
                        ( RecorreFila, RecorreColumna, [],
                                [ ActivarCicloHCGM, CicloTomarVariantHCGM,
                                  CicloConteoHCGM, CicloEvaluarHCGM,
                                  FinConteoErrorHCGM ] );
              END;  { CASE NuevoTipo OF }
            END ELSE BEGIN  { IF BanderaTipo ELSE }
              ModificarMacroParametro
                ( RecorreFila, RecorreColumna, [], [ ActivarCicloHCGM ] );
            END;            { IF BanderaTipo ELSE }
          END ELSE BEGIN  { IF BanderaNOTInterno ELSE }
            IF BanderaTipo THEN BEGIN
              CASE NuevoTipo OF
                0, 4    : ModificarMacroParametro
                        ( RecorreFila, RecorreColumna,
                                [ ActivarCicloHCGM, CicloTomarVariantHCGM ],
                                [ CicloConteoHCGM, CicloEvaluarHCGM,
                                  FinConteoErrorHCGM ] );
                1       : ModificarMacroParametro
                        ( RecorreFila, RecorreColumna,
                                [ ActivarCicloHCGM, CicloConteoHCGM ],
                                [ CicloTomarVariantHCGM, CicloEvaluarHCGM,
                                  FinConteoErrorHCGM ] );
                2       : ModificarMacroParametro
                        ( RecorreFila, RecorreColumna,
                                [ ActivarCicloHCGM, CicloEvaluarHCGM ],
                                [ CicloTomarVariantHCGM, CicloConteoHCGM,
                                  FinConteoErrorHCGM ] );
                3       : ModificarMacroParametro
                        ( RecorreFila, RecorreColumna,
                                [ ActivarCicloHCGM,
                                  CicloConteoHCGM, FinConteoErrorHCGM ],
                                [ CicloTomarVariantHCGM, CicloEvaluarHCGM ] );
              END;  { CASE NuevoTipo OF }
            END ELSE BEGIN  { IF BanderaTipo ELSE }
              LecturaTipo( RecorreFila, RecorreColumna,
                BanderaNudillado, BanderaMacro, CaracterMacro );
              IF BanderaNudillado THEN BEGIN
                IF ( [ CicloTomarVariantHCGM, CicloConteoHCGM,
                        CicloEvaluarHCGM ]*CaracterMacro ) <> [] THEN BEGIN
                  ModificarMacroParametro
                    ( RecorreFila, RecorreColumna,
                        [ ActivarCicloHCGM ], [] );
                END ELSE BEGIN  { IF ( ...*CaracterMacro ) <> [] ELSE }
                  ModificarMacroParametro
                    ( RecorreFila, RecorreColumna,
                        [ ActivarCicloHCGM, CicloTomarVariantHCGM ], [] );
                END;            { IF ( ...*CaracterMacro ) <> [] ELSE }
              END;  { IF BanderaNudillado }
            END;            { IF BanderaTipo ELSE }
            IF BanderaConteo THEN BEGIN
              ModificarMacroParametro
                      ( RecorreFila, RecorreColumna, [], [], NuevoConteo );
            END;  { IF BanderaConteo }
          END;            { IF BanderaNOTInterno ELSE }
        END;  { FOR RecorreColumna }
      END;  { FOR RecorreFila }
    END;  { WITH MyManejador.HojaDefault }
  END;   { PROCEDURE AnidadoOrdenCasillaCiclica }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenRangoCasillaSimple
    (       OrdenActual         : LongInt;
            RevisarBloqueo      : Boolean                               );
  VAR
    PivoteNodoNOT1              : CAFE_NudoSintacticoString;
    RecorreFila,
    FilaI,
    FilaF,
    RecorreColumna,
    ColumnaI,
    ColumnaF                    : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenRangoCasillaSimple }
    PivoteNodoNOT1              := PivoteNodoNOT;
    IF NOT( PivoteNodoNOT.TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( PivoteNodoNOT1.DatoElemento ) ] );
    PivoteNodoNOT               :=
        PivoteNodoNOT.DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteNodoNOT.LeerRangoCasillaObligatorio
        ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    WITH MyManejador.HojaDefault as CAFE_HojaCalculoString DO BEGIN
      IF RevisarBloqueo THEN BEGIN
        IF IsZonaCasillaBloqueada( FilaI, ColumnaI, FilaF, ColumnaF )
        THEN RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorCasillaBloqueadaHojaTrabajo );
      END;  { IF RevisarBloqueo }
      FOR RecorreFila := FilaI TO FilaF DO BEGIN
        FOR RecorreColumna := ColumnaI TO ColumnaF DO BEGIN
          CASE OrdenActual OF
            1           : IF BanderaNOTInterno
                          THEN ModificarMacroParametro
            ( RecorreFila, RecorreColumna, [], [ CasillaIniciativaHCGM ] )
                          ELSE ModificarMacroParametro
            ( RecorreFila, RecorreColumna, [ CasillaIniciativaHCGM ], [] );
            2           :
                IF NOT( AnularCasilla( RecorreFila, RecorreColumna ) ) THEN
                RAISE CAFE_PipeHaltException.Create( 'NULL no aplicable' );
          END;  { CASE OrdenActual }
        END;  { FOR RecorreColumna }
      END;  { FOR RecorreFila }
    END;  { WITH MyManejador.HojaDefault }
  END;   { PROCEDURE AnidadoOrdenRangoCasillaSimple }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenFormatoCasilla;
  // Este PROCEDURE simplemente hace teatro en la version actual
  VAR
    FilaI,
    ColumnaI,
    FilaF,
    ColumnaF                    : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenFormatoCasilla }
    IF NOT( TotalDescendientesDirectos > 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenFormatoCasilla ) ] );
    ( DescendienteVertical as CAFE_NudoSintacticoString ).
        LeerRangoCasillaObligatorio
        ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
  END;   { PROCEDURE AnidadoOrdenFormatoCasilla }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenCopiarCasillas;
  VAR
    Msg                         : ShortString;
    PivoteNodo                  : CAFE_NudoSintacticoString;
    RecorreFila,
    RecorreColumna,
    FilaOrigen,
    ColumnaOrigen,
    FilaI,
    FilaF,
    ColumnaI,
    ColumnaF,
    FilaI2,
    ColumnaI2,
    FilaF2,
    ColumnaF2,
    TotalParametros             : LongInt;
    BanderaSuperposicion        : Boolean;

    PROCEDURE AnidadoAjusteRangoCopia;
    BEGIN  { PROCEDURE AnidadoAjusteRangoCopia }
      IF ( FilaI2 = FilaF2 ) AND ( ColumnaI2 = ColumnaF2 ) THEN BEGIN
        FilaF2                  := FilaI2+( FilaF-FilaI );
        ColumnaF2               := ColumnaI2+( ColumnaF-ColumnaI );
        IF ( FilaF2 >= MyManejador.HojaDefault.FilasEnHoja ) OR
           ( ColumnaF2 >= MyManejador.HojaDefault.ColumnasEnHoja )
        THEN RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorRangoSolicitadoNoPermitidoEnCopia );
      END;  { IF ( FilaI2 = FilaF2 ) AND ColumnaI2 = ColumnaF2 }
      IF ( ( ( FilaF2-FilaI2+1 ) MOD ( FilaF-FilaI+1 ) ) <> 0  )
      THEN RAISE CAFE_PipeException.Create
              ( ErrorREPO, CAFE_ErrorRangoSolicitadoNoPermitidoEnCopia );
      // El rango debe ser multiplo exacto, probablemente de uno
      IF ( ( ( ColumnaF2-ColumnaI2+1 ) MOD ( ColumnaF-ColumnaI+1 ) ) <> 0  )
      THEN RAISE CAFE_PipeException.Create
              ( ErrorREPO, CAFE_ErrorRangoSolicitadoNoPermitidoEnCopia );
      // El rango debe ser multiplo exacto, probablemente de uno
      BanderaSuperposicion              := FALSE;
      IF NOT( ( FilaF2 < FilaI ) OR
              ( FilaI2 > FilaF ) OR
              ( ColumnaF2 < ColumnaI ) OR
              ( ColumnaI2 > ColumnaF ) ) THEN BEGIN
        // Cuando existe superposicion de zona
        // debe de concordar alguna de las esquinas
        IF NOT( ( ( FilaI = FilaI2 ) AND ( ColumnaI = ColumnaI2 ) ) OR
                ( ( FilaF = FilaF2 ) AND ( ColumnaF = ColumnaF2 ) ) OR
                ( ( FilaI = FilaI2 ) AND ( ColumnaF = ColumnaF2 ) ) OR
                ( ( FilaF = FilaF2 ) AND ( ColumnaI = ColumnaI2 ) ) )
        THEN RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorRangoSolicitadoNoPermitidoEnCopia );
        BanderaSuperposicion            := TRUE;
      END;  { IF NOT( ... ) }
      WITH MyManejador.HojaDefault as CAFE_HojaCalculoString DO
              IF IsZonaCasillaBloqueada
                      ( FilaI2, ColumnaI2, FilaF2, ColumnaF2 )
              THEN RAISE CAFE_PipeException.Create
                      ( ErrorREPO, CAFE_ErrorCasillaBloqueadaHojaTrabajo );
    END;   { PROCEDURE AnidadoAjusteRangoCopia }

  BEGIN  { PROCEDURE AnidadoOrdenCopiarCasillas }
    TotalParametros             := TotalDescendientesDirectos;
    IF NOT( TotalParametros = 2 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenCopiarCasillas ) ] );
    PivoteNodo                  :=
                DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteNodo.LeerRangoCasillaObligatorio
                ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    PivoteNodo                  :=
        PivoteNodo.DescendienteHorizontal as CAFE_NudoSintacticoString;
    PivoteNodo.LeerRangoCasillaObligatorio
                ( FilaI2, ColumnaI2, FilaF2, ColumnaF2, Manejador );
    AnidadoAjusteRangoCopia;
    WITH MyManejador.HojaDefault as CAFE_HojaCalculoString DO BEGIN
      FOR RecorreFila := FilaI2 TO FilaF2 DO BEGIN
        FOR RecorreColumna := ColumnaI2 TO ColumnaF2 DO BEGIN
          FilaOrigen              :=
                  FilaI+( RecorreFila-FilaI2 )
                                  MOD ( FilaF-FilaI+1 );
          ColumnaOrigen           :=
                  ColumnaI+( RecorreColumna-ColumnaI2 )
                                  MOD ( ColumnaF-ColumnaI+1 );
          IF NOT( CopiarCasilla( FilaOrigen, ColumnaOrigen,
                RecorreFila, RecorreColumna, Msg, Manejador, TRUE, TRUE,
                0, 0, FALSE, BanderaSuperposicion ) )
          THEN BEGIN
            IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
              IF CAFE_PosicionInfructuosoSintactico <> 0 THEN BEGIN
                RAISE CAFE_PipeException.
                        Create( ErrorREPO, CAFE_PosicionInfructuosoSintactico,
                        [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
              END;  { IF CAFE_MensajeInfructuosoSintactico <> '' }
            END;  { IF ImplementationInfructuosoSintacticoNoPipe }
            IF Msg = ''
            THEN RAISE CAFE_PipeCasillaException.Create
                ( RecorreFila, RecorreColumna, CopiarErrorPECM,
                  CAFE_FatalProcesoCopiaCasillasInterrumpido );
            RAISE CAFE_MensajeException.Create( Msg );
          END;  { IF NOT( CopiarCasillas... ) }
        END;  { FOR RecorreColumna }
      END;  { FOR RecorreFila }
    END;  { WITH MyManejador.HojaDefault }
    ExitoFracaso                := ExitoREPO;
  END;   { PROCEDURE AnidadoOrdenCopiarCasillas }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoAuxiliarMoverCasillas
    (       FilaI, ColumnaI, FilaF, ColumnaF,
            FilaI2, ColumnaI2   : LongInt;
            BanderaCorreccion   : Boolean               = FALSE;
            FilaColumna         : Boolean               = TRUE          );
  VAR
    Msg                         : ShortString;
    RecorreFila,
    RecorreColumna,
    FilaOrigen,
    ColumnaOrigen,
    FilaProteccion,
    ColumnaProteccion,
    FinFilaCorreccion,
    FinColumnaCorreccion,
    FilaF2,
    ColumnaF2                   : LongInt;

      { ANIDADO }
    PROCEDURE AnidadoAjusteRangoMover;
    BEGIN  { PROCEDURE AnidadoAjusteRangoMover }
      FilaF2                  := FilaI2+( FilaF-FilaI );
      ColumnaF2               := ColumnaI2+( ColumnaF-ColumnaI );
      IF ( FilaF2 >= MyManejador.HojaDefault.FilasEnHoja ) AND
         ( ColumnaF2 >= MyManejador.HojaDefault.ColumnasEnHoja )
      THEN RAISE CAFE_PipeException.Create
              ( ErrorREPO, CAFE_ErrorRangoSolicitadoNoPermitidoEnCopia );
      WITH MyManejador.HojaDefault as CAFE_HojaCalculoString DO
        IF NOT( BanderaCorreccion ) THEN BEGIN
              IF IsZonaCasillaBloqueada
                      ( FilaI2, ColumnaI2, FilaF2, ColumnaF2 )
              THEN RAISE CAFE_PipeException.Create
                      ( ErrorREPO, CAFE_ErrorCasillaBloqueadaHojaTrabajo );
        END;  { IF NOT( BanderaCorreccion ) }
      WITH MyManejador.HojaDefault as CAFE_HojaCalculoString DO
        IF NOT( BanderaCorreccion ) THEN BEGIN
              IF IsZonaCasillaBloqueada
                      ( FilaI, ColumnaI, FilaF, ColumnaF )
              THEN RAISE CAFE_PipeException.Create
                      ( ErrorREPO, CAFE_ErrorCasillaBloqueadaHojaTrabajo );
        END;  { IF NOT( BanderaCorreccion ) }
    END;   { PROCEDURE AnidadoAjusteRangoMover }
      { ANIDADO }

  BEGIN  { PROCEDURE AnidadoAuxiliarMoverCasillas }
    AnidadoAjusteRangoMover;
    IF ( FilaI = FilaI2 ) AND ( ColumnaI = ColumnaI2 ) THEN Exit;
    WITH MyManejador.HojaDefault as CAFE_HojaCalculoString DO BEGIN
      FilaProteccion            := 0;
      ColumnaProteccion         := 0;
      IF BanderaCorreccion THEN BEGIN
        // BanderaCorrecion indica insercion o borrado de lineas
        // Aqui se procesa las casillas que no se movieron
        // pero que probablemente hacen referencia a las
        // casillas que si se movieron
        IF FilaColumna THEN BEGIN
          FilaProteccion        := FilaI;
          FinFilaCorreccion     := Pred( Min( FilaI, FilaI2 ) );
          FinColumnaCorreccion  := ColumnaF;
        END ELSE BEGIN  { IF FilaColumna ELSE }
          ColumnaProteccion     := ColumnaI;
          FinFilaCorreccion     := FilaF;
          FinColumnaCorreccion  := Pred( Min( ColumnaI, ColumnaI2 ) );
        END;            { IF FilaColumna ELSE }
        FOR RecorreFila := 0 TO FinFilaCorreccion DO BEGIN
          FOR RecorreColumna := 0 TO FinColumnaCorreccion DO BEGIN
            IF NOT( CopiarCasilla( RecorreFila, RecorreColumna,
                  RecorreFila+FilaI2-FilaI,
                  RecorreColumna+ColumnaI2-ColumnaI,
                  Msg, Manejador, TRUE, TRUE,
                  FilaProteccion, ColumnaProteccion,
                  BanderaCorreccion ) )
            THEN BEGIN
              IF Msg = ''
              THEN RAISE CAFE_PipeCasillaException.Create
                  ( RecorreFila, RecorreColumna, CopiarErrorPECM,
                    CAFE_FatalProcesoCopiaCasillasInterrumpido );
              RAISE CAFE_MensajeException.Create( Msg );
            END;  { IF NOT( CopiarCasillas... ) }
          END;  { FOR RecorreColumna }
        END;  { FOR RecorreFila }
      END;  { IF BanderaCorreccion }
      IF FilaI > FilaI2 THEN BEGIN
        IF ColumnaI > ColumnaI2 THEN BEGIN
          FOR RecorreFila := FilaI2 TO FilaF2 DO BEGIN
            FOR RecorreColumna := ColumnaI2 TO ColumnaF2 DO BEGIN
              FilaOrigen              :=
                      FilaI+( RecorreFila-FilaI2 );
              ColumnaOrigen           :=
                      ColumnaI+( RecorreColumna-ColumnaI2 );
              IF NOT( CopiarCasilla( FilaOrigen, ColumnaOrigen,
                    RecorreFila, RecorreColumna, Msg, Manejador, TRUE, TRUE,
                    FilaProteccion, ColumnaProteccion,
                    TRUE ) )
              THEN BEGIN
                IF Msg = ''
                THEN RAISE CAFE_PipeCasillaException.Create
                    ( RecorreFila, RecorreColumna, CopiarErrorPECM,
                      CAFE_FatalProcesoCopiaCasillasInterrumpido );
                RAISE CAFE_MensajeException.Create( Msg );
              END;  { IF NOT( CopiarCasillas... ) }
              IF NOT( AnularCasilla( FilaOrigen, ColumnaOrigen ) )
              THEN RAISE CAFE_PipeHaltException.Create( 'NULL no aplicable' );
            END;  { FOR RecorreColumna }
          END;  { FOR RecorreFila }
        END ELSE BEGIN  { IF ColumnaI > ColumnaI2 ELSE }
          FOR RecorreFila := FilaI2 TO FilaF2 DO BEGIN
            FOR RecorreColumna := ColumnaF2 DOWNTO ColumnaI2 DO BEGIN
              FilaOrigen              :=
                      FilaI+( RecorreFila-FilaI2 );
              ColumnaOrigen           :=
                      ColumnaI+( RecorreColumna-ColumnaI2 );
              IF NOT( CopiarCasilla( FilaOrigen, ColumnaOrigen,
                    RecorreFila, RecorreColumna, Msg, Manejador, TRUE, TRUE,
                    FilaProteccion, ColumnaProteccion,
                    TRUE ) )
              THEN BEGIN
                IF Msg = ''
                THEN RAISE CAFE_PipeCasillaException.Create
                    ( RecorreFila, RecorreColumna, CopiarErrorPECM,
                      CAFE_FatalProcesoCopiaCasillasInterrumpido );
                RAISE CAFE_MensajeException.Create( Msg );
              END;  { IF NOT( CopiarCasillas... ) }
              IF NOT( AnularCasilla( FilaOrigen, ColumnaOrigen ) )
              THEN RAISE CAFE_PipeHaltException.Create( 'NULL no aplicable' );
            END;  { FOR RecorreColumna }
          END;  { FOR RecorreFila }
        END;            { IF ColumnaI <= ColumnaI2 ELSE }
      END ELSE BEGIN  { IF FilaI > FilaI2 ELSE }
        IF ColumnaI > ColumnaI2 THEN BEGIN
          FOR RecorreFila := FilaF2 DOWNTO FilaI2 DO BEGIN
            FOR RecorreColumna := ColumnaI2 TO ColumnaF2 DO BEGIN
              FilaOrigen              :=
                      FilaI+( RecorreFila-FilaI2 );
              ColumnaOrigen           :=
                      ColumnaI+( RecorreColumna-ColumnaI2 );
              IF NOT( CopiarCasilla( FilaOrigen, ColumnaOrigen,
                    RecorreFila, RecorreColumna, Msg, Manejador, TRUE, TRUE,
                    FilaProteccion, ColumnaProteccion,
                    TRUE ) )
              THEN BEGIN
                IF Msg = ''
                THEN RAISE CAFE_PipeCasillaException.Create
                    ( RecorreFila, RecorreColumna, CopiarErrorPECM,
                      CAFE_FatalProcesoCopiaCasillasInterrumpido );
                RAISE CAFE_MensajeException.Create( Msg );
              END;  { IF NOT( CopiarCasillas... ) }
              IF NOT( AnularCasilla( FilaOrigen, ColumnaOrigen ) )
              THEN RAISE CAFE_PipeHaltException.Create( 'NULL no aplicable' );
            END;  { FOR RecorreColumna }
          END;  { FOR RecorreFila }
        END ELSE BEGIN  { IF ColumnaI > ColumnaI2 ELSE }
          FOR RecorreFila := FilaF2 DOWNTO FilaI2 DO BEGIN
            FOR RecorreColumna := ColumnaF2 DOWNTO ColumnaI2 DO BEGIN
              FilaOrigen              :=
                      FilaI+( RecorreFila-FilaI2 );
              ColumnaOrigen           :=
                      ColumnaI+( RecorreColumna-ColumnaI2 );
              IF NOT( CopiarCasilla( FilaOrigen, ColumnaOrigen,
                    RecorreFila, RecorreColumna, Msg, Manejador, TRUE, TRUE,
                    FilaProteccion, ColumnaProteccion,
                    TRUE ) )
              THEN BEGIN
                IF Msg = ''
                THEN RAISE CAFE_PipeCasillaException.Create
                    ( RecorreFila, RecorreColumna, CopiarErrorPECM,
                      CAFE_FatalProcesoCopiaCasillasInterrumpido );
                RAISE CAFE_MensajeException.Create( Msg );
              END;  { IF NOT( CopiarCasillas... ) }
              IF NOT( AnularCasilla( FilaOrigen, ColumnaOrigen ) )
              THEN RAISE CAFE_PipeHaltException.Create( 'NULL no aplicable' );
            END;  { FOR RecorreColumna }
          END;  { FOR RecorreFila }
        END;            { IF ColumnaI > ColumnaI2 ELSE }
      END;            { IF FilaI > FilaI2 ELSE }
    END;  { WITH MyManejador.HojaDefault }
  END;   { PROCEDURE AnidadoAuxiliarMoverCasillas }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenMoverCasillas;
  VAR
    PivoteNodo                  : CAFE_NudoSintacticoString;
    FilaI,
    FilaF,
    ColumnaI,
    ColumnaF,
    FilaI2,
    ColumnaI2                   : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenMoverCasillas }
    IF NOT( TotalDescendientesDirectos = 2 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenMoverCasillas ) ] );
    PivoteNodo                  :=
                DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteNodo.LeerRangoCasillaObligatorio
                ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    PivoteNodo                  :=
        PivoteNodo.DescendienteHorizontal as CAFE_NudoSintacticoString;
    PivoteNodo.LeerCasillaObligatorio
                ( FilaI2, ColumnaI2, Manejador );
    AnidadoAuxiliarMoverCasillas( FilaI, ColumnaI, FilaF, ColumnaF,
                                FilaI2, ColumnaI2 );
    ExitoFracaso                := ExitoREPO;
  END;   { PROCEDURE AnidadoOrdenMoverCasillas }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenLineaNull
    (       FilaColumna         : Boolean                               );
  VAR
    PivoteNodo                  : CAFE_NudoSintacticoString;
    RecorreFila,
    RecorreColumna,
    FilaI,
    FilaF,
    ColumnaI,
    ColumnaF                    : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenLineaNull }
    IF NOT( TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( DatoElemento ) ] );
    PivoteNodo                  :=
                DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteNodo.LeerRangoCasillaObligatorio
                ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    IF FilaColumna THEN BEGIN
      ColumnaI                  := 0;
      ColumnaF                  :=
                Pred( MyManejador.HojaDefault.ColumnasEnHoja );
    END ELSE BEGIN  { IF FilaColumna ELSE }
      FilaI                     := 0;
      FilaF                     :=
                Pred( MyManejador.HojaDefault.FilasEnHoja );
    END;            { IF FilaColumna ELSE }
    FOR RecorreFila := FilaI TO FilaF DO BEGIN
      FOR RecorreColumna := ColumnaI TO ColumnaF DO BEGIN
        IF NOT( MyManejador.HojaDefault.
                        AnularCasilla( RecorreFila, RecorreColumna ) ) THEN
        RAISE CAFE_PipeHaltException.Create( 'NULL no aplicable' );
      END;  { FOR RecorreColumna }
    END;  { FOR RecorreFila }
  END;  { PROCEDURE AnidadoOrdenLineaNull }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenCorrimientoLinea
    (       FilaColumna         : Boolean;
            InsertarEliminar    : Boolean                               );
  VAR
    PivoteNodo                  : CAFE_NudoSintacticoString;
    DeltaRango,
    FilaI,
    FilaF,
    ColumnaI,
    ColumnaF                    : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenCorrimientoLinea }
    IF NOT( TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( DatoElemento ) ] );
    PivoteNodo                  :=
                DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteNodo.LeerRangoCasillaObligatorio
                ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    WITH MyManejador.HojaDefault DO BEGIN
      IF FilaColumna THEN BEGIN
        ColumnaI                  := 0;
        ColumnaF                  := Pred( ColumnasEnHoja );
        DeltaRango                := FilaF-FilaI+1;
      END ELSE BEGIN  { IF FilaColumna ELSE }
        FilaI                     := 0;
        FilaF                     := Pred( FilasEnHoja );
        DeltaRango                := ColumnaF-ColumnaI+1;
      END;            { IF FilaColumna ELSE }
      IF InsertarEliminar THEN BEGIN
        IF FilaColumna THEN BEGIN
          AnidadoAuxiliarMoverCasillas
                  ( FilaI, ColumnaI, FilasEnHoja-DeltaRango-1 , ColumnaF,
                        FilaI+DeltaRango, ColumnaI, TRUE, TRUE );
        END ELSE BEGIN  { IF FilaColumna ELSE }
          AnidadoAuxiliarMoverCasillas
                  ( FilaI, ColumnaI, FilaF, ColumnasEnHoja-DeltaRango-1,
                        FilaI, ColumnaI+DeltaRango, TRUE, FALSE );
        END;            { IF FilaColumna ELSE }
      END ELSE BEGIN  { IF InsertarEliminar ELSE }
        IF FilaColumna THEN BEGIN
          AnidadoAuxiliarMoverCasillas
                ( FilaI+DeltaRango, ColumnaI, FilasEnHoja-1, ColumnaF,
                        FilaI, ColumnaI, TRUE, TRUE );
        END ELSE BEGIN  { IF FilaColumna ELSE }
          AnidadoAuxiliarMoverCasillas
                ( FilaI, ColumnaI+DeltaRango, FilaF, ColumnasEnHoja-1,
                        FilaI, ColumnaI, TRUE, FALSE );
        END;            { IF FilaColumna ELSE }
      END;            { IF InsertarEliminar ELSE }
    END;  { WITH MyManejador.HojaDefault }
    ExitoFracaso                := ExitoREPO;
  END;  { PROCEDURE AnidadoOrdenCorrimientoLinea }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenUndo;
  VAR
    PivoteNivelUndo             : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenUndo }
    IF NOT( TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenUndo ) ] );
    PivoteNivelUndo             :=
        ( DescendienteVertical as CAFE_NudoSintacticoString ).
                                        LeerLongIntObligatorio;
    MyManejador.PaqueteUndo.UndoHojaCalculo( PivoteNivelUndo );
  END;   { PROCEDURE AnidadoOrdenUndo }
    { ANIDADO }

  PROCEDURE AnidadoRaiseZona
    (       ValorPrueba         : Double;
            LimiteInf, LimiteSup        : Double                        );
  BEGIN  { PROCEDURE AnidadoRaiseZona }
    IF NOT( InRange( ValorPrueba, LimiteInf, LimiteSup ) )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorDatoFueraRangoAdmisible );
  END;   { PROCEDURE AnidadoRaiseZona }

    { ANIDADO }
  PROCEDURE AnidadoOrdenEnteroGlobal
    (       EnteroGlobal        : Byte                                  );
  VAR
    PivoteEntero                : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenEnteroGlobal }
    IF NOT( TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenUndo ) ] );
    PivoteEntero                :=
        ( DescendienteVertical as CAFE_NudoSintacticoString ).
                                        LeerLongIntObligatorio;
    CASE EnteroGlobal OF
      1         : BEGIN
                    MyManejador.PaqueteUndo.NivelUndo           :=
                                                        PivoteEntero;
                  END;  { CASE 1 }
      2         : BEGIN
                    MyManejador.ValorPreliminarSolve            :=
                                                        PivoteEntero;
                  END;  { CASE 2 }
      3         : BEGIN
                    MyManejador.ValorMaximaIteracionIntegralOctavoImpar :=
                                                        PivoteEntero;
                  END;  { CASE 3 }
      4         : BEGIN
                    MyManejador.
                    ValorMaximaIteracionIntegralOctavoImparFuncion      :=
                                                        PivoteEntero;
                  END;  { CASE 4 }
    END;  { CASE EnteroGlobal }
  END;   { PROCEDURE AnidadoOrdenEnteroGlobal }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenRealGlobal
    (       RealGlobal          : Byte                                  );
  VAR
    PivoteReal                  : Double;

  BEGIN  { PROCEDURE AnidadoOrdenNivelesUndo }
    IF NOT( TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( DatoElemento ) ] );
    PivoteReal                  :=
        ( DescendienteVertical as CAFE_NudoSintacticoString ).
                                        LeerFloatObligatorio;
    CASE RealGlobal OF
      1         : BEGIN
                    MyManejador.ValorEpsilonZero        := PivoteReal;
                  END;  { CASE 1 }
      2         : BEGIN
                    MyManejador.
                    ValorDefaultToleranciaDeterminante          :=
                                                        PivoteReal;
                  END;  { CASE 2 }
    END;  { CASE RealGlobal }
  END;   { PROCEDURE AnidadoOrdenRealGlobal }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenRecalculoConErrores;
  VAR
    DescriptorInterno           : CAFE_ConjuntoVariantesDescriptoresHoja;
    RecorreFila,
    RecorreColumna,
    FilaI,
    ColumnaI,
    FilaF,
    ColumnaF                    : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenRecalculoConErrores }
    IF NOT( TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenRecalculoConErrores ) ] );
    ( DescendienteVertical as CAFE_NudoSintacticoString ).
        LeerRangoCasillaObligatorio
                ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    WITH MyManejador.HojaDefault DO BEGIN
      DescriptorInterno       := DescriptoresHoja;
      DescriptoresHoja        := DescriptoresHoja+
              [ ForzarRecalculoTotalCVDH, VerValorPruebaCVDH ]-
              [ VerFuncionalCVDH ];
      TRY
        FOR RecorreFila := FilaI TO FilaF DO BEGIN
          FOR RecorreColumna := ColumnaI TO ColumnaF DO BEGIN
            EjecutarOrdenEvaluarCasilla( RecorreFila, RecorreColumna,
              NumeroRenglon, CodigoAcumulado, Manejador, TRUE, TRUE );
          END;  { FOR RecorreFila }
        END;  { FOR RecorreColumna }
      FINALLY
        DescriptoresHoja      := DescriptorInterno;
      END;  { TRY }
    END;  { WITH MyManejador.HojaDefault }
  END;   { PROCEDURE AnidadoOrdenRecalculoConErrores }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenVariableGeneral;
  VAR
    VarianteFinal,
    NuevoVariante               : Variant;
    PivoteNodo1,
    PivoteNodo                  : CAFE_NudoSintacticoString;
    TipoVarianteEsperado        : SizeInt;
    SelectorVariable            : Byte;

  BEGIN  { PROCEDURE AnidadoOrdenVariableGeneral }
    IF NOT( TotalDescendientesDirectos = 2 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenVariableGeneral ) ] );
    PivoteNodo1                 :=
        DescendienteVertical as CAFE_NudoSintacticoString;
    SelectorVariable            := PivoteNodo1.
                LeerSelectorAlternativaObligatorio
        ( Manejador, CAFE_AlternativaVariableGeneral );
      // RAISE si no encuentra el selector
    PivoteNodo                  := PivoteNodo1.
        DescendienteHorizontal as CAFE_NudoSintacticoString;
    IF CAFE_TipoVariante( PivoteNodo.DatoElemento ) = varString
    THEN NuevoVariante          :=
                        CAFE_StringToVariant( PivoteNodo.DatoElemento )
    ELSE NuevoVariante          := PivoteNodo.DatoElemento;
      { CASE para verificar dato adecuado }
    CASE SelectorVariable OF
      0, 1              : TipoVarianteEsperado  := varBoolean;
      2, 3, 4           : TipoVarianteEsperado  := varInteger;
      5, 6              : TipoVarianteEsperado  := varDouble;
      7, 8              : RAISE CAFE_PipeException.Create
         ( ErrorREPO, CAFE_ErrorPosibleIncompatibilidadVersion );
    END;  { CASE SelectorVariable }
    IF NOT( CAFE_TypeSimpleValorCompatible
        ( TipoVarianteEsperado, CAFE_TipoVariante( NuevoVariante ) ) )
    THEN RAISE CAFE_PipeException.Create
         ( ErrorREPO, CAFE_ErrorTipoInadecuadoDatoVariableGlobal,
                       [ QuotedStr( PivoteNodo1.DatoElemento ) ] );
      { CASE para asignacion definitiva }
    CASE SelectorVariable OF
      0         : BEGIN
                    CAFE_VarCast( VarianteFinal, NuevoVariante, varBoolean );
                    MyManejador.ValorBanderaSimularCalculo      :=
                                                        VarianteFinal;
                  END;  { CASE 0 }
      1         : BEGIN
                    CAFE_VarCast( VarianteFinal, NuevoVariante, varBoolean );
                    CAFE_HabilitarUnCiclo         := VarianteFinal;
                  END;  { CASE 1 }
      2         : BEGIN
                    CAFE_VarCast( VarianteFinal, NuevoVariante, varInteger );
                    MyManejador.ValorPreliminarSolve            :=
                                                        VarianteFinal;
                  END;  { CASE 2 }
      3         : BEGIN
                    CAFE_VarCast( VarianteFinal, NuevoVariante, varInteger );
                    MyManejador.ValorMaximaIteracionIntegralOctavoImpar :=
                                                        VarianteFinal;
                  END;  { CASE 3 }
      4         : BEGIN
                    CAFE_VarCast( VarianteFinal, NuevoVariante, varDouble );
                    MyManejador.
                    ValorMaximaIteracionIntegralOctavoImparFuncion      :=
                                                        VarianteFinal;
                  END;  { CASE 4 }
      5         : BEGIN
                    CAFE_VarCast( VarianteFinal, NuevoVariante, varDouble );
                    MyManejador.ValorEpsilonZero        := VarianteFinal;
                  END;  { CASE 5 }
      6         : BEGIN
                    MyManejador.
                    ValorDefaultToleranciaDeterminante          :=
                                                        VarianteFinal;
                  END;  { CASE 6 }
    END;  { CASE SelectorVariable }
  END;   { PROCEDURE AnidadoOrdenVariableGeneral }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenActualVariableGeneral;
  VAR
    PivoteResultado             : Variant;
    PivoteNodo1                 : CAFE_NudoSintacticoString;
    SelectorVariable            : Byte;

  BEGIN  { PROCEDURE AnidadoOrdenVariableGeneral }
    IF NOT( TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( CAFE_OrdenVariableGeneral ) ] );
    PivoteNodo1                 :=
        DescendienteVertical as CAFE_NudoSintacticoString;
    SelectorVariable            := PivoteNodo1.
                LeerSelectorAlternativaObligatorio
        ( Manejador, CAFE_AlternativaVariableGeneral );
      // RAISE si no encuentra el selector
    CASE SelectorVariable OF
      0         : PivoteResultado       :=
                        MyManejador.ValorBanderaSimularCalculo;
      1         : PivoteResultado       := CAFE_HabilitarUnCiclo;
      2         : PivoteResultado       :=
                        MyManejador.ValorPreliminarSolve;
      3         : PivoteResultado       :=
                        MyManejador.ValorMaximaIteracionIntegralOctavoImpar;
      4         : PivoteResultado       := MyManejador.
                        ValorMaximaIteracionIntegralOctavoImparFuncion;
      5         : PivoteResultado       :=
                        MyManejador.ValorEpsilonZero;
      6         : PivoteResultado       :=
                        MyManejador.ValorDefaultToleranciaDeterminante;
      7, 8      : BEGIN
                    IF MyManejador.HojaDefault = NIL
                    THEN BEGIN
                      CAFE_VarCast( PivoteResultado, 0, varInteger );
                    END ELSE BEGIN  { IF MyManejador.HojaDefault = NIL ELSE }
                      IF SelectorVariable = 7
                      THEN PivoteResultado      :=
                                        MyManejador.HojaDefault.FilasEnHoja
                      ELSE PivoteResultado      :=
                                        MyManejador.HojaDefault.ColumnasEnHoja;
                    END;            { IF MyManejador.HojaDefault = NIL ELSE }
                  END;  { CASE 7, 8 }
    END;  { CASE SelectorVariable }
    WriteLn( CAFE_Application.PipeOutputText,
      CAFE_GenerarMensajeOutputCodigoNumeral
      ( QuotedStr( CAFE_VariantToString( PivoteResultado ) ),
              NumeroRenglon,
              CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
    Inc( CodigoAcumulado[ ResultREPO ] );
  END;   { PROCEDURE AnidadoOrdenVariableGeneral }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenHaciaDesdeTemporal
    (       HaciaDesde                  : Boolean                       );
  VAR
    PivoteNodo                  : CAFE_NudoSintacticoString;
    FilaI,
    FilaF,
    RecorreFila,
    ColumnaI,
    ColumnaF,
    RecorreColumna              : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenHaciaDesdeTemporal }
    IF NOT( TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( DatoElemento ) ] );
    PivoteNodo                  :=
                DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteNodo.LeerRangoCasillaObligatorio
                ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    IF NOT( HaciaDesde ) THEN BEGIN
      IF ( MyManejador.HojaDefault as CAFE_HojaCalculoString ).
         IsZonaCasillaBloqueada( FilaI, ColumnaI, FilaF, ColumnaF )
      THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorCasillaBloqueadaHojaTrabajo );
    END;  { IF NOT( HaciaDesde ) }
    WITH CAFE_ManejadorTemporal as CAFE_ManejadorBasicoString DO BEGIN
      IF ( HojaDefault.FilasEnHoja < ( FilaF-FilaI+1 ) ) OR
         ( HojaDefault.ColumnasEnHoja < ( ColumnaF-ColumnaI+1 ) )
      THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorRangoSolicitadoNoPermitidoEnCopia );
      FOR RecorreFila := FilaI TO FilaF DO BEGIN
        FOR RecorreColumna := ColumnaI TO ColumnaF DO BEGIN
          EjecutarOrdenCopiaCasillaTemporal( RecorreFila, RecorreColumna,
                RecorreFila-FilaI, RecorreColumna-ColumnaI,
                HaciaDesde, NumeroRenglon, CodigoAcumulado, Manejador );
        END;  { FOR RecorreColumna }
      END;  { FOR RecorreFila }
    END;  { WITH CAFE_ManejadorTemporal as CAFE_ManejadorBasicoString }
    ExitoFracaso                := ExitoREPO;
  END;   { PROCEDURE AnidadoOrdenHaciaDesdeTemporal }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenCasillaATexto;
  VAR
    PivoteString                : ShortString;
    PivoteNodo                  : CAFE_NudoSintacticoString;
    Fila,
    Columna                     : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenCasillaATexto }
    IF NOT( TotalDescendientesDirectos = 1 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( DatoElemento ) ] );
    PivoteNodo                  :=
                DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteNodo.LeerCasillaObligatorio
                ( Fila, Columna, Manejador );
    WITH ( MyManejador.HojaDefault as CAFE_HojaCalculoString ) DO BEGIN
      PivoteString              := CasillaToString( Fila, Columna );
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( PivoteString ), NumeroRenglon,
                CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
      Inc( CodigoAcumulado[ ResultREPO ] );
    END;  { WITH MyManejador.HojaDefault }
  END;   { PROCEDURE AnidadoOrdenCasillaATexto }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOperadorAsignacionFinal
    (       OrdenPipe           : ShortString                           );
  VAR
    Fila,
    Columna                     : LongInt;
    PosParentesis               : LongInt;
    DolarFila,
    DolarColumna                : Boolean;

  BEGIN  { IF AnidadoOperadorAsignacionFinal }
    PosParentesis               := AnsiPos( ':=', OrdenPipe );
    IF PosParentesis < 0 THEN Exit;
    OrdenPipe                   :=
                UpperCase( Copy( OrdenPipe, 1, Pred( PosParentesis ) ) );
    PosParentesis               := AnsiPos( '(', OrdenPipe );
    IF PosParentesis > 0
    THEN OrdenPipe              :=
                Copy( OrdenPipe, 1, Pred( PosParentesis ) );
    IF NOT( MyManejador.HojaDefault.IdentificadorValidoCasilla( OrdenPipe,
                        DolarFila, Fila, DolarColumna, Columna ) )
    THEN Exit;
    EjecutarOrdenEvaluarCasilla( Fila, Columna,
                      NumeroRenglon, CodigoAcumulado, Manejador );
  END;   { IF AnidadoOperadorAsignacionFinal }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenLeerCasillas;
  VAR
    PivoteString                : ShortString;
    PivoteDescendiente          : CAFE_NudoSintacticoString;
    DescriptorInterno           : CAFE_ConjuntoVariantesDescriptoresHoja;
    FilaI,
    FilaF,
    ColumnaI,
    ColumnaF,
    RecorreFila,
    RecorreColumna              : LongInt;
    TotPar                      : Word;
    BanderaDefault              : Boolean;

  BEGIN  { PROCEDURE AnidadoOrdenLeerCasillas }
    TotPar                      := TotalDescendientesDirectos;
    IF NOT( InRange( TotPar, 1, 2 ) )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( DatoElemento ) ] );
    PivoteDescendiente          :=
                DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteDescendiente.LeerRangoCasillaObligatorio
        ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    BanderaDefault              := FALSE;
    IF TotPar = 2 THEN BEGIN
      PivoteDescendiente        := PivoteDescendiente.
                DescendienteHorizontal as CAFE_NudoSintacticoString;
      IF CAFE_TipoVariante( PivoteDescendiente.DatoElemento )  <> varString
      THEN RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorSelectorAlternativaPendiente,
                          [ QuotedStr( DatoElemento ) ] );
      PivoteString              :=
                UpperCase( PivoteDescendiente.DatoElemento );
      IF ( PivoteString <> 'DEFECTO' ) AND
         ( PivoteString <> 'DEFAULT' )
      THEN RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorSelectorAlternativaPendiente,
                          [ QuotedStr( DatoElemento ) ] );
      BanderaDefault            := TRUE;
    END;  { IF TotPar = 2 }
    WITH MyManejador.HojaDefault DO BEGIN
      DescriptorInterno         := DescriptoresHoja;
      DescriptoresHoja          := DescriptoresHoja+
              [ PeticionCalculoObligadoCVDH ]-
              [ ForzarRecalculoTotalCVDH ];
      IF BanderaDefault
      THEN DescriptoresHoja
           -= [ VerFuncionalCVDH, VerValorPruebaCVDH ];
      TRY
        FOR RecorreFila := FilaI TO FilaF DO BEGIN
          FOR RecorreColumna := ColumnaI TO ColumnaF DO BEGIN
            EjecutarOrdenEvaluarCasilla( RecorreFila, RecorreColumna,
                              NumeroRenglon, CodigoAcumulado, Manejador );
          END;  { FOR RecorreColumna }
        END;  { FOR RecorreFila }
      FINALLY
        DescriptoresHoja        := DescriptorInterno;
      END;  { TRY }
    END;  {WITH }
  END;   { PROCEDURE AnidadoOrdenLeerCasillas }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenCasillasAArchivo;
  VAR
    MyArchivoTexto              : Text;
    PivoteString,
    NombreArchivo               : ShortString;
    PivoteDescendiente          : CAFE_NudoSintacticoString;
    DescriptorInterno           : CAFE_ConjuntoVariantesDescriptoresHoja;
    FilaI,
    FilaF,
    ColumnaI,
    ColumnaF,
    RecorreFila,
    RecorreColumna              : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenLeerCasillas }
    IF NOT( TotalDescendientesDirectos = 2 )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                        [ QuotedStr( DatoElemento ) ] );
    PivoteDescendiente          :=
                DescendienteVertical as CAFE_NudoSintacticoString;
    PivoteDescendiente.LeerRangoCasillaObligatorio
        ( FilaI, ColumnaI, FilaF, ColumnaF, Manejador );
    PivoteDescendiente          := PivoteDescendiente.
                DescendienteHorizontal as CAFE_NudoSintacticoString;
    NombreArchivo               :=
                PivoteDescendiente.LeerStObligatorio( TRUE );
    WITH MyManejador.HojaDefault DO BEGIN
      DescriptorInterno         := DescriptoresHoja;
      DescriptoresHoja          := DescriptoresHoja+
              [ PeticionCalculoObligadoCVDH ]-
              [ ForzarRecalculoTotalCVDH, VerFuncionalCVDH,
                        VerValorPruebaCVDH ];
      System.Assign( MyArchivoTexto, NombreArchivo );
      {$I-}
      ReWrite( MyArchivoTexto );
      {$I+}
      IF IOResult <> 0 THEN
      RAISE CAFE_PipeException.
                    Create( FracasoREPO, CAFE_FracasoNoPudoAbrirArchivo,
                                    [ QuotedStr( NombreArchivo ) ] );
      WriteLn( MyArchivoTexto, IntToStr( ColumnaI+1 ) );
      WriteLn( MyArchivoTexto, IntToStr( FilaI+1 ) );
      WriteLn( MyArchivoTexto, IntToStr( ColumnaF+1 ) );
      WriteLn( MyArchivoTexto, IntToStr( FilaF+1 ) );
      TRY
        FOR RecorreFila := FilaI TO FilaF DO BEGIN
          FOR RecorreColumna := ColumnaI TO ColumnaF DO BEGIN
            PivoteString        :=
                EjecutarOrdenEvaluarCasilla( RecorreFila, RecorreColumna,
                              NumeroRenglon, CodigoAcumulado, Manejador,
                              FALSE, FALSE );
            WriteLn( MyArchivoTexto, PivoteString );
          END;  { FOR RecorreColumna }
        END;  { FOR RecorreFila }
      FINALLY
        DescriptoresHoja        := DescriptorInterno;
        Close( MyArchivoTexto );
      END;  { TRY }
    END;  {WITH }
    ExitoFracaso                := ExitoREPO;
  END;   { PROCEDURE AnidadoOrdenCasillasAArchivo }
    { ANIDADO }

BEGIN  { FUNCTION CAFE_NudoSintacticoString.EjecutarOrdenHoja }
  IF CAFE_TipoVariante( DatoElemento ) <> varString
  THEN RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorOrdenNoEntendida );
  PivoteStringPrevio            := DatoElemento;
  IF PivoteStringPrevio = '' THEN Exit;
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
  WITH MyManejador DO BEGIN
    PivoteString                := PaqueteIdioma.Values[ PivoteStringPrevio ];
    IF PivoteString = ''
    THEN PivoteString                   := PivoteStringPrevio
    ELSE DatoElemento                   := PivoteString;
    BanderaNOTInterno                   := FALSE;
    PivoteNodoNOT                       := Self;
    IF PivoteString = 'NO()' THEN BEGIN
      IF DescendienteVertical = NIL THEN BEGIN
        RAISE CAFE_PipeException.Create( ErrorREPO,
                CAFE_ErrorFaltanParametrosEnOperador,
                        [ QuotedStr( PivoteString ) ] );
        Exit;
      END;  { IF DescendienteVertical = NIL }
      IF TotalDescendientesDirectos <> 1
      THEN RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                          [ QuotedStr( 'NO()' ) ] );
      PivoteNodoNOT                     :=
                        DescendienteVertical as CAFE_NudoSintacticoString;
      IF CAFE_TipoVariante( PivoteNodoNOT.DatoElemento ) <> varString
      THEN RAISE CAFE_PipeException.
                    Create( ErrorREPO, CAFE_ErrorOrdenNoEntendida );
      PivoteStringPrevio                := PivoteNodoNOT.DatoElemento;
      PivoteString                      := PaqueteIdioma.
                                                Values[ PivoteStringPrevio ];
      IF PivoteString = ''
      THEN PivoteString                 := PivoteStringPrevio
      ELSE PivoteNodoNOT.DatoElemento   := PivoteString;
      BanderaNOTInterno                 := TRUE;
      IF PivoteString[ Length( PivoteString ) ] <> ')' THEN BEGIN
        PivoteNodoNOT.EjecutarOrdenIdentificadorHoja
                  ( OrdenPipe, NumeroRenglon, CodigoAcumulado,
                        Manejador, TRUE );
        Exit;
      END;  { IF PivoteString[ Length( PivoteString ) ] <> ')' }
      IF PivoteString = CAFE_OrdenCasillaCiclica THEN BEGIN
        AnidadoOrdenCasillaCiclica;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenCasillaCiclica }
      IF PivoteString = CAFE_OrdenCasillaIniciativa THEN BEGIN
        AnidadoOrdenRangoCasillaSimple( 1, TRUE );
        Exit;
      END;  { IF PivoteString = CAFE_OrdenCasillaIniciativa }
      Exit;
    END;  { IF PivoteString = 'ActivoHCGM' }
    IF PivoteString[ Length( PivoteString ) ] <> ')' THEN BEGIN
      EjecutarOrdenIdentificadorHoja
                ( OrdenPipe, NumeroRenglon, CodigoAcumulado, Manejador );
      Exit;
    END;  { IF PivoteString[ Length( PivoteString ) ] <> ')' }
    IF PivoteString = CAFE_OperadorAsignacionBasicaTraducidoOperadorBasico
    THEN BEGIN
      IF HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
          Create( ErrorREPO, CAFE_ErrorIdentificadorRequiereHojaTrabajo );
      TRY
        ( HojaDefault as CAFE_HojaCalculoString ).
                        StringToCasilla( Manejador, OrdenPipe );
      FINALLY
        IF InProcesoVerbose THEN AnidadoOperadorAsignacionFinal( OrdenPipe );
      END;  { TRY }
      Exit;
    END;  { IF PivoteString = CAFE_OperadorAsignacionBasicaTraducido... }
    IF PivoteString = CAFE_SecuenciaRectangularHojaTraducidoOperadorBasico
    THEN BEGIN
      IF HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
          Create( ErrorREPO, CAFE_ErrorIdentificadorRequiereHojaTrabajo );
      IF InProcesoVerbose THEN AnidadoEvaluarSecuencia;
      Exit;
    END;  { IF PivoteString = CAFE_SecuenciaRectangularHojaTraducido... }
    IF PivoteString = CAFE_OrdenLeerCasillas THEN BEGIN
      IF HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
          Create( ErrorREPO, CAFE_ErrorIdentificadorRequiereHojaTrabajo );
      IF InProcesoVerbose THEN AnidadoOrdenLeerCasillas;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenLeerCasillas }
    IF PivoteString = CAFE_OperadorParentesisTraducidoOperadorBasico
    THEN BEGIN
      IF DescendienteVertical = NIL
      THEN RAISE CAFE_PipeException.Create( ErrorREPO,
                CAFE_ErrorFaltanParametrosEnOperador, [ QuotedStr( '()' ) ] );
      IF NOT( TotalDescendientesDirectos = 1 )
      THEN RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
            [ QuotedStr(
              CAFE_VariantToString( DescendienteVertical.DatoElemento ) ) ] );
      IF NOT( ( DescendienteVertical as CAFE_Nudo2Sintactico ).
                InterpretarFuncion( Manejador, FuncionReturn, PivoteMsg ) )
      THEN BEGIN
        IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
          IF CAFE_MensajeInfructuosoSintactico <> '' THEN BEGIN
            RAISE CAFE_PipeException.
                    Create( ErrorREPO, CAFE_PosicionInfructuosoSintactico,
                    [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
          END;  { IF CAFE_MensajeInfructuosoSintactico <> '' }
        END;  { IF ImplementationInfructuosoSintacticoNoPipe }
        RAISE CAFE_PipeException.Create
          ( ErrorREPO, CAFE_ErrorVarErrorInterpretar );
      END;  { IF NOT( PivoteArbol.InterpretarFuncion... ) }
      IF NOT( ( DescendienteVertical as CAFE_Nudo2Sintactico ).
                EvaluarFuncion( FuncionReturn, PivoteMsg, MyManejador ) )
      THEN BEGIN
        IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
          IF CAFE_MensajeInfructuosoSintactico <> '' THEN BEGIN
            RAISE CAFE_PipeException.
                    Create( ErrorREPO, CAFE_PosicionInfructuosoSintactico,
                    [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
          END;  { IF CAFE_MensajeInfructuosoSintactico <> '' }
        END;  { IF ImplementationInfructuosoSintacticoNoPipe }
        RAISE CAFE_PipeException.Create
            ( ErrorREPO, CAFE_ErrorVarErrorEvaluar );
      END;  { IF NOT( PivoteArbol... ) }
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( CAFE_VariantToString( FuncionReturn ) ),
                NumeroRenglon,
                CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
      Inc( CodigoAcumulado[ ResultREPO ] );
      Exit
    END;  { IF PivoteString = CAFE_OperadorParentesisTraducidoOperadorBasico }
    IF PivoteString = CAFE_OrdenLoadHojaTrabajo THEN BEGIN
      AnidadoOrdenLoad;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenLoadHojaTrabajo }
    IF PivoteString = CAFE_OrdenDescribirHoja THEN BEGIN
      AnidadoOrdenDescribirHoja;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenDescribirHoja }
    IF PivoteString = CAFE_OrdenCrearHojaTrabajo THEN BEGIN
      AnidadoOrdenCrearHoja;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenCrearHojaTrabajo }
    IF PivoteString = CAFE_OrdenListaManejadores THEN BEGIN
      IF InProcesoVerbose THEN AnidadoOrdenListaManejadores;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenListaManejadores }
    IF PivoteString = CAFE_OrdenCasillaCiclica THEN BEGIN
      AnidadoOrdenCasillaCiclica;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenCasillaCiclica }
    IF PivoteString = CAFE_OrdenCasillaIniciativa THEN BEGIN
      AnidadoOrdenRangoCasillaSimple( 1, TRUE );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenCasillaIniciativa }
    IF PivoteString = CAFE_OrdenCasillaNull THEN BEGIN
      AnidadoOrdenRangoCasillaSimple( 2, TRUE );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenCasillaNull }
    IF PivoteString = CAFE_OrdenFilaNull THEN BEGIN
      AnidadoOrdenLineaNull( TRUE );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenFilaNull }
    IF PivoteString = CAFE_OrdenColumnaNull THEN BEGIN
      AnidadoOrdenLineaNull( FALSE );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenCasillaNull }
    IF PivoteString = CAFE_OrdenEliminarFila THEN BEGIN
      ExitoFracaso              := FracasoREPO;
      TRY
        AnidadoOrdenCorrimientoLinea( TRUE, FALSE );
      FINALLY
        IF NOT( InProcesoLoad ) THEN BEGIN
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ ExitoFracaso ], ExitoFracaso, 0 );
          IF ExitoFracaso = ExitoREPO
          THEN WriteLn( CAFE_Application.PipeOutputText, PivoteMsg )
          ELSE WriteLn( CAFE_Application.PipeStdErrText, PivoteMsg );
          Inc( CodigoAcumulado[ ExitoFracaso ] );
        END;  { IF NOT( InProcesoLoad ) }
      END;  { TRY }
      Exit;
    END;  { IF PivoteString = CAFE_OrdenEliminarFila }
    IF PivoteString = CAFE_OrdenInsertarFila THEN BEGIN
      ExitoFracaso              := FracasoREPO;
      TRY
        AnidadoOrdenCorrimientoLinea( TRUE, TRUE );
      FINALLY
        IF NOT( InProcesoLoad ) THEN BEGIN
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ ExitoFracaso ], ExitoFracaso, 0 );
          IF ExitoFracaso = ExitoREPO
          THEN WriteLn( CAFE_Application.PipeOutputText, PivoteMsg )
          ELSE WriteLn( CAFE_Application.PipeStdErrText, PivoteMsg );
          Inc( CodigoAcumulado[ ExitoFracaso ] );
        END;  { IF NOT( InProcesoLoad ) }
      END;  { TRY }
      Exit;
    END;  { IF PivoteString = CAFE_OrdenInsertarFila }
    IF PivoteString = CAFE_OrdenEliminarColumna THEN BEGIN
      ExitoFracaso              := FracasoREPO;
      TRY
        AnidadoOrdenCorrimientoLinea( FALSE, FALSE );
      FINALLY
        IF NOT( InProcesoLoad ) THEN BEGIN
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ ExitoFracaso ], ExitoFracaso, 0 );
          IF ExitoFracaso = ExitoREPO
          THEN WriteLn( CAFE_Application.PipeOutputText, PivoteMsg )
          ELSE WriteLn( CAFE_Application.PipeStdErrText, PivoteMsg );
          Inc( CodigoAcumulado[ ExitoFracaso ] );
        END;  { IF NOT( InProcesoLoad ) }
      END;  { TRY }
      Exit;
    END;  { IF PivoteString = CAFE_OrdenEliminarColumna }
    IF PivoteString = CAFE_OrdenInsertarColumna THEN BEGIN
      ExitoFracaso              := FracasoREPO;
      TRY
        AnidadoOrdenCorrimientoLinea( FALSE, TRUE );
      FINALLY
        IF NOT( InProcesoLoad ) THEN BEGIN
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ ExitoFracaso ], ExitoFracaso, 0 );
          IF ExitoFracaso = ExitoREPO
          THEN WriteLn( CAFE_Application.PipeOutputText, PivoteMsg )
          ELSE WriteLn( CAFE_Application.PipeStdErrText, PivoteMsg );
          Inc( CodigoAcumulado[ ExitoFracaso ] );
        END;  { IF NOT( InProcesoLoad ) }
      END;  { TRY }
      Exit;
    END;  { IF PivoteString = CAFE_OrdenInsertarColumna }
    IF PivoteString = CAFE_OrdenFormatoCasilla THEN BEGIN
      AnidadoOrdenFormatoCasilla;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenFormatoCasilla }
    IF PivoteString = CAFE_OrdenCopiarCasillas THEN BEGIN
      ExitoFracaso              := FracasoREPO;
      TRY
        AnidadoOrdenCopiarCasillas;
      FINALLY
        IF NOT( InProcesoLoad ) THEN BEGIN
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ ExitoFracaso ], ExitoFracaso, 0 );
          IF ExitoFracaso = ExitoREPO
          THEN WriteLn( CAFE_Application.PipeOutputText, PivoteMsg )
          ELSE WriteLn( CAFE_Application.PipeStdErrText, PivoteMsg );
          Inc( CodigoAcumulado[ ExitoFracaso ] );
        END;  { IF NOT( InProcesoLoad ) }
      END;  { TRY }
      Exit;
    END;  { IF PivoteString = CAFE_OrdenCopiarCasillas }
    IF PivoteString = CAFE_OrdenMoverCasillas THEN BEGIN
      ExitoFracaso              := FracasoREPO;
      TRY
        AnidadoOrdenMoverCasillas;
      FINALLY
        IF NOT( InProcesoLoad ) THEN BEGIN
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ ExitoFracaso ], ExitoFracaso, 0 );
          IF ExitoFracaso = ExitoREPO
          THEN WriteLn( CAFE_Application.PipeOutputText, PivoteMsg )
          ELSE WriteLn( CAFE_Application.PipeStdErrText, PivoteMsg );
          Inc( CodigoAcumulado[ ExitoFracaso ] );
        END;  { IF NOT( InProcesoLoad ) }
      END;  { TRY }
      Exit;
    END;  { IF PivoteString = CAFE_OrdenMoverCasillas }
    IF PivoteString = CAFE_OrdenHaciaTemporal THEN BEGIN
      ExitoFracaso              := FracasoREPO;
      TRY
        AnidadoOrdenHaciaDesdeTemporal( TRUE );
      FINALLY
        IF NOT( InProcesoLoad ) THEN BEGIN
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ ExitoFracaso ], ExitoFracaso, 0 );
          IF ExitoFracaso = ExitoREPO
          THEN WriteLn( CAFE_Application.PipeOutputText, PivoteMsg )
          ELSE WriteLn( CAFE_Application.PipeStdErrText, PivoteMsg );
          Inc( CodigoAcumulado[ ExitoFracaso ] );
        END;  { IF NOT( InProcesoLoad ) }
      END;  { TRY }
      Exit;
    END;  { IF PivoteString = CAFE_OrdenHaciaCasillas }
    IF PivoteString = CAFE_OrdenDesdeTemporal THEN BEGIN
      ExitoFracaso              := FracasoREPO;
      TRY
        AnidadoOrdenHaciaDesdeTemporal( FALSE );
      FINALLY
        IF NOT( InProcesoLoad ) THEN BEGIN
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ ExitoFracaso ], ExitoFracaso, 0 );
          IF ExitoFracaso = ExitoREPO
          THEN WriteLn( CAFE_Application.PipeOutputText, PivoteMsg )
          ELSE WriteLn( CAFE_Application.PipeStdErrText, PivoteMsg );
          Inc( CodigoAcumulado[ ExitoFracaso ] );
        END;  { IF NOT( InProcesoLoad ) }
      END;  { TRY }
      Exit;
    END;  { IF PivoteString = CAFE_OrdenDesdeTemporal }
    IF PivoteString = CAFE_OrdenRecalculoConErrores THEN BEGIN
      AnidadoOrdenRecalculoConErrores;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenRecalculoConErrores }
    IF PivoteString = CAFE_OrdenVariableGeneral THEN BEGIN
      AnidadoOrdenVariableGeneral;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenVariableGeneral }
    IF PivoteString = CAFE_OrdenActualVariableGeneral THEN BEGIN
      IF InProcesoVerbose THEN AnidadoOrdenActualVariableGeneral;
      Exit;
    END;  { IF PivoteString = CAFE_OrdenActualVariableGeneral }
    IF PivoteString = CAFE_OrdenRaizPreliminar THEN BEGIN
      AnidadoOrdenEnteroGlobal( 2 );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenRaizPreliminar }
    IF PivoteString = CAFE_OrdenMaximoCiclosIntegral THEN BEGIN
      AnidadoOrdenEnteroGlobal( 3 );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenMaximoCiclosIntegral }
    IF PivoteString = CAFE_OrdenMaximoCiclosIntegralInterna THEN BEGIN
      AnidadoOrdenEnteroGlobal( 4 );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenMaximoCiclosIntegralFuncional }
    IF PivoteString = CAFE_OrdenEpsilonZero THEN BEGIN
      AnidadoOrdenRealGlobal( 1 );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenEpsilonZero }
    IF PivoteString = CAFE_OrdenEpsilonZeroDeterminante THEN BEGIN
      AnidadoOrdenRealGlobal( 2 );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenEpsilonZeroDeterminante }
    IF InProcesoLoad THEN BEGIN
      IF PivoteString = CAFE_OrdenActivarHojaTrabajo THEN BEGIN
        AnidadoActivarHojaTrabajoInLoad;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenActivarHojaTrabajo }
    END ELSE BEGIN  { IF InProcesoLoad ELSE }
      // Ordenes prohibidas en Load
      IF PivoteString = CAFE_OrdenCasillasAArchivo THEN BEGIN
        IF HojaDefault = NIL
        THEN RAISE CAFE_PipeException.
            Create( ErrorREPO, CAFE_ErrorIdentificadorRequiereHojaTrabajo );
        ExitoFracaso              := FracasoREPO;
        TRY
          AnidadoOrdenCasillasAArchivo;
        FINALLY
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ ExitoFracaso ], ExitoFracaso, 0 );
          IF ExitoFracaso = ExitoREPO
          THEN WriteLn( CAFE_Application.PipeOutputText, PivoteMsg )
          ELSE WriteLn( CAFE_Application.PipeStdErrText, PivoteMsg );
          Inc( CodigoAcumulado[ ExitoFracaso ] );
        END;  { TRY }
        Exit;
      END;  { IF PivoteString = CAFE_OrdenLeerCasillas }
      IF PivoteString = CAFE_OrdenActivarHojaTrabajo THEN BEGIN
        //  Reconocida en Load pero con codigo ejecucion diferente
        AnidadoActivarHojaTrabajo;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenActivarHojaTrabajo }
      IF PivoteString = CAFE_OrdenActivarGrupoSave THEN BEGIN
        AnidadoActivarGrupoSave;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenActivarGrupoSave }
      IF PivoteString = CAFE_OrdenDestruirHojaTrabajo THEN BEGIN
        AnidadoOrdenDestuirHojaTrabajo;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenDestuirHojaTrabajo }
      IF PivoteString = CAFE_OrdenDestruirGrupoSave THEN BEGIN
        AnidadoOrdenDestruirGrupoSave;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenDestruirGrupoSave }
      IF PivoteString = CAFE_OrdenSaveHojaTrabajo THEN BEGIN
        AnidadoOrdenSave;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenSaveHojaTrabajo }
      IF PivoteString = CAFE_OrdenAgregarHojaGrupoSave THEN BEGIN
        AnidadoOrdenAgregarHojaGrupoSave;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenAgregarHojaGrupoSave }
      IF PivoteString = CAFE_OrdenUndo THEN BEGIN
        AnidadoOrdenUndo;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenUndo }
      IF PivoteString = CAFE_OrdenNivelesUndo THEN BEGIN
        AnidadoOrdenEnteroGlobal( 1 );
        Exit;
      END;  { IF PivoteString = CAFE_OrdenNivelesUndo }
      IF PivoteString = CAFE_OrdenCasillaATexto THEN BEGIN
        IF InProcesoVerbose THEN AnidadoOrdenCasillaATexto;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenCasillaATexto }
    END;  { IF InProcesoLoad ELSE }
  END;  { WITH MyManejador }
  RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorOrdenNoEntendida );
END;   { FUNCTION CAFE_NudoSintacticoString.EjecutarOrdenHoja }

  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$HINTS       OFF             }
  {$ENDIF                       }
PROCEDURE   CAFE_NudoSintacticoString.EjecutarOrdenLoad
  ( CONST ArchivoString         : ShortString;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico          );
{ virtual; }
VAR
  MyTextLoad                    : Text;
  PivoteMsg,
  NuevaLinea                    : ShortString;
  ListaLoad                     : CAFE_TStringPipe0;
  ConteoInternoErrores          : LongInt;
  PivoteBanderaConteo,
  BanderaIniciadorLoad          : Boolean;

BEGIN  { PROCEDURE CAFE_NudoSintacticoString.EjecutarOrdenLoad }
  WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString,
                CAFE_Application DO BEGIN
    FreeAndNIL( PipeBufferFile );
    TRY
      PipeBufferFile            :=
              TFileStream.Create( ArchivoString, fmOpenRead );
    EXCEPT
      ON EFOpenError
      DO RAISE CAFE_PipeException.Create( FracasoREPO,
              CAFE_FracasoNoPudoAbrirArchivo,
              [ QuotedStr( ArchivoString ) ] );
    END;  { TRY }
    ListaLoad                   := CAFE_TStringPipe0.Create;
    AssignStream( MyTextLoad, PipeBufferFile );
    Reset( MyTextLoad );
    WHILE NOT( EOF( MyTextLoad ) ) DO BEGIN
      {$I-}
      ReadLn( MyTextLoad, NuevaLinea );
      {$I+}
      IF IOResult <> 0 THEN BEGIN
        Close( MyTextLoad );
        FreeAndNil( ListaLoad );
        FreeAndNil( PipeBufferFile );
        RAISE CAFE_PipeException.Create( FracasoREPO,
              CAFE_FracasoArchivoTXTPendiente );
      END;  { IF IOResult <> 0 }
      ListaLoad.Add( NuevaLinea );
    END;  { WHILE NOT( EOF( MyTextLoad ) ) }
    Close( MyTextLoad );
    FreeAndNil( PipeBufferFile );
    BanderaIniciadorLoad        := FALSE;
    IF NOT( InProcesoLoad ) THEN BEGIN
      BanderaIniciadorLoad      := TRUE;
      GrupoSaveActivo           := CAFE_NombreGrupoTemporal;
      ListaManejadoresLoad.Clear;
      BanderaMantenerGrupoSave  := FALSE;
      InterfaceManejadorActivo  := ID[ CAFE_NombreManejadorTemporal ];
      PivoteBanderaConteo       :=
        CAFE_Application.BanderaConteoPrincipalRenglon;
      CAFE_Application.BanderaLoad                              := TRUE;
      CAFE_Application.BanderaConteoPrincipalRenglon            := FALSE;
      PivoteMsg                     :=
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( ArchivoString ), NumeroRenglon,
          CodigoAcumulado[ BeginLoadREPO ], BeginLoadREPO, 0 );
      WriteLn( PipeOutputText, PivoteMsg );
      Inc( CodigoAcumulado[ BeginLoadREPO ] );
    END;  { IF NOT( InProcesoLoad ) }
    ConteoInternoErrores                := 0;
    IF NOT( BanderaWaitOnCompleted )
    THEN RAISE CAFE_PipeHaltException.
        Create( 'Esta application requiere BanderaWaitOnCompleted activa' );
    WHILE ListaLoad.Count > 0 DO BEGIN
      CAFE_MensajeInfructuoso.ClearMessage;
      TRY
        TRY
          ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
              EjecutarRenglonLoad( ListaLoad.FifoStrings, CodigoAcumulado );
        EXCEPT
          ON MyError : CAFE_PipeCasillaException DO BEGIN
            WITH MyError DO BEGIN
              IF NOT( BanderaPermitirLoad ) THEN BEGIN
                CASE TypeException OF
                  ErrorREPO   : BEGIN
                    TypeException := ErrorLoadREPO;
                    Inc( ConteoInternoErrores );
                    IF ConteoInternoErrores > CAFE_MaximoConteoErroresLoad
                    THEN BEGIN
                      IF CAFE_MaximoConteoErroresLoad > 0
                      THEN RAISE CAFE_PipeFatalException.
                          Create( CAFE_FatalSuperoCapacidadErroresArchivo,
                                [ QuotedStr( ArchivoString ) ] )
                      ELSE RAISE CAFE_PipeFatalException.
                          Create( CAFE_FatalErroresNoPermitidosLoad );
                    END;  { IF ConteoInternoErrores > ... }
                                END;  { CASEErrorREPO }
                  MensajeREPO : TypeException := MensajeLoadREPO;
                  HintREPO,
                  NoteREPO,
                  TipREPO     : TypeException := NullREPO;
                END;  { CASE TypeMsg }
                IF TypeException <> NullREPO THEN BEGIN
                  PivoteMsg         :=
                    QuotedStr( Message )+' '+
                    QuotedStr( 'Error casilla ('+
                          IntToStr( Succ( ColumnaReferencia ) )
                          +','+IntToStr( Succ( FilaReferencia ) )+')' );
                  WriteLn( PipeStdErrText,
                    CAFE_GenerarMensajeOutputCodigoCasilla
                    ( PivoteMsg, NumeroRenglon,
                      CodigoAcumulado[ TypeException ],
                      TypeException, FilaReferencia, ColumnaReferencia,
                      Ord( EstiloMsgReferencia ), HelpContext ) );
                  Inc( CodigoAcumulado[ TypeException ] );
                END;  { IF TypeException <> NullREPO }
              END;  { IF NOT( BanderaPermitidoLoad ) }
            END;  { WITH MyError }
          END;  { ON CAFE_PipeCasillaException }
          ON MyError : CAFE_PipeException DO BEGIN
            WITH MyError DO BEGIN
              CASE TypeException OF
                ErrorREPO   : BEGIN
                  TypeException := ErrorLoadREPO;
                  Inc( ConteoInternoErrores );
                  IF ConteoInternoErrores > CAFE_MaximoConteoErroresLoad
                  THEN BEGIN
                    IF CAFE_MaximoConteoErroresLoad > 0
                    THEN RAISE CAFE_PipeFatalException.
                        Create( CAFE_FatalSuperoCapacidadErroresArchivo,
                              [ QuotedStr( ArchivoString ) ] )
                    ELSE RAISE CAFE_PipeFatalException.
                        Create( CAFE_FatalErroresNoPermitidosLoad );
                  END;  { IF ConteoInternoErrores > ... }
                              END;  { CASE ErrorREPO }
                MensajeREPO : TypeException := MensajeLoadREPO;
                HintREPO,
                NoteREPO    : TypeException := NullREPO;
              END;  { CASE TypeMsg }
              IF TypeException <> NullREPO THEN BEGIN
                PivoteMsg         := QuotedStr( Message );
                WriteLn( PipeStdErrText,
                  CAFE_GenerarMensajeOutputCodigoNumeral
                  ( PivoteMsg, NumeroRenglon,
                    CodigoAcumulado[ TypeException ],
                    TypeException, HelpContext ) );
                Inc( CodigoAcumulado[ TypeException ] );
              END;  { IF TypeException <> NullREPO }
            END;  { WITH MyError }
          END;  { ON CAFE_PipeException }
        END;  { TRY }
      EXCEPT
        ON MyError : CAFE_PipeFatalException DO BEGIN
          WITH MyError DO BEGIN
            PivoteMsg         := QuotedStr( Message );
            WriteLn( PipeStdErrText,
              CAFE_GenerarMensajeOutputCodigoNumeral
              ( PivoteMsg, NumeroRenglon,
                CodigoAcumulado[ TypeException ],
                TypeException, HelpContext ) );
            Inc( CodigoAcumulado[ TypeException ] );
          END;  { WITH MyError }
          PivoteMsg                     :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', NumeroRenglon,
              CodigoAcumulado[ EndLoadREPO ], EndLoadREPO, 0 );
          WriteLn( PipeOutputText, PivoteMsg );
          Inc( CodigoAcumulado[ EndLoadREPO ] );
          FreeAndNil( ListaLoad );
          IF BanderaIniciadorLoad THEN BEGIN
            RAISE CAFE_PipeException.
                      Create( DescartadoLoadREPO,
                                CAFE_DescartadoLoadInterrumpidoArchivo,
                                      [ QuotedStr( ArchivoString ) ] );
          END ELSE BEGIN  { IF BanderaIniciadorLoad ELSE }
            RAISE CAFE_PipeFatalException.
                      Create( CAFE_FatalInterrumpidoLoadArchivo,
                                      [ QuotedStr( ArchivoString ) ] );
          END;            { IF BanderaIniciadorLoad ELSE }
        END;  { ON MyError : CAFE_PipeFatalException }
      END;  { TRY }
    END;  { WHILE ListaLoad.Count > 0 }
    IF BanderaIniciadorLoad THEN BEGIN
      IF ConteoInternoErrores = 0 THEN BEGIN
        PivoteMsg                     :=
          CAFE_GenerarMensajeOutputCodigoNumeral
          ( '', NumeroRenglon,
            CodigoAcumulado[ AceptadoLoadREPO ], AceptadoLoadREPO, 0 );
        WriteLn( PipeOutputText, PivoteMsg );
        Inc( CodigoAcumulado[ AceptadoLoadREPO ] );
      END;  { IF ConteoInternoErrores = 0 }
      PivoteMsg                     :=
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( ArchivoString ), NumeroRenglon,
          CodigoAcumulado[ EndLoadREPO ], EndLoadREPO, 0 );
      WriteLn( PipeOutputText, PivoteMsg );
      Inc( CodigoAcumulado[ EndLoadREPO ] );
      CAFE_Application.BanderaLoad                              := FALSE;
      CAFE_Application.BanderaConteoPrincipalRenglon
                                := PivoteBanderaConteo;
      ListaManejadoresLoad.Clear;
    END;  { IF BanderaIniciadorLoad }
  END;  { WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString }
END;   { PROCEDURE CAFE_NudoSintacticoString.EjecutarOrdenLoad }
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$HINTS       ON              }
  {$ENDIF                       }

PROCEDURE   CAFE_NudoSintacticoString.EjecutarOrdenSave
  ( CONST ArchivoString         : ShortString;
    CONST GrupoString           : ShortString;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico                  );
{ virtual; }
VAR
  MyArchivoTexto                : Text;
  PivoteMsg                     : ShortString;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  MyGrupo                       : CAFE_TCollectionItemSave;
  MyListError,
  MyList                        : CAFE_TStringPipe0;
  MyManejadorBasico             : TObject;

BEGIN  { PROCEDURE CAFE_NudoSintacticoString.EjecutarOrdenSave }
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
  WITH CAFE_Application DO BEGIN
    MyGrupo                     :=
        ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
                ListaGruposLoadSave.BuscarNombreGrupoSave( GrupoString );
    IF MyGrupo = NIL
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorNombreGrupoSaveInexistente,
                                [ QuotedStr( GrupoString ) ] );
    IF MyGrupo.ContieneNombresDuplicados( PivoteMsg )
    THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorNombreDuplicadoHojaTrabajoEnGrupo,
                [ QuotedStr( PivoteMsg ), QuotedStr( GrupoString ) ] );
    System.Assign( MyArchivoTexto, ArchivoString );
    {$I-}
    ReWrite( MyArchivoTexto );
    {$I+}
    IF IOResult <> 0 THEN
    RAISE CAFE_PipeException.
                  Create( FracasoREPO, CAFE_FracasoNoPudoAbrirArchivo,
                                  [ QuotedStr( ArchivoString ) ] );
    PivoteMsg                     :=
      CAFE_GenerarMensajeOutputCodigoNumeral
      ( '', ConteoPrincipalRenglon,
        CodigoAcumulado[ BeginSaveREPO ], BeginSaveREPO, 0 );
    WriteLn( PipeOutputText, PivoteMsg );
    Inc( CodigoAcumulado[ BeginSaveREPO ] );
    MyList                      := CAFE_TStringPipe0.Create;
    MyListError                 := CAFE_TStringPipe0.Create;
    TRY
      FOR Pointer( MyManejadorBasico ) IN MyGrupo.ListaManejadoresSave
      DO BEGIN
        IF MyManejadorBasico <> NIL THEN BEGIN
          // NIL deberia ser imposible
          IF MyManejadorBasico is CAFE_ManejadorBasicoString
          THEN ( MyManejadorBasico as CAFE_ManejadorBasicoString ).
                  ManejadorToTStringList
                  ( MyList, NumeroRenglon, CodigoAcumulado, MyListError )
          ELSE CAFE_PipeHaltException.
                  Create( 'Clase incompatible en grupo Save' );
        END;  { IF MyManejadorBasico <> NIL }
      END;  { FOR MyManejador }
    EXCEPT
      ON CAFE_PipeFatalException DO BEGIN
        PivoteMsg                     :=
          CAFE_GenerarMensajeOutputCodigoNumeral
          ( '', ConteoPrincipalRenglon,
            CodigoAcumulado[ EndSaveREPO ], EndSaveREPO, 0 );
        WriteLn( PipeOutputText, PivoteMsg );
        Inc( CodigoAcumulado[ EndSaveREPO ] );
        FreeAndNil( MyList );
        FreeAndNil( MyListError );
        Close( MyArchivoTexto );
        RAISE CAFE_PipeException.
                    Create( FracasoREPO, CAFE_FracasoNoPudoCrearArchivo,
                                    [ QuotedStr( ArchivoString ) ] );
      END;  { ON Exception }
    END;  { TRY }
    WHILE MyList.Count <> 0
    DO WriteLn( MyArchivoTexto, MyList.FIFOStrings );
    FreeAndNil( MyList );
    WHILE MyListError.Count <> 0 DO BEGIN
      WriteLn( PipeStdErrText, MyListError.FIFOStrings );
    END;  { WHILE MyListError.Count <> 0 }
    FreeAndNil( MyListError );
    Close( MyArchivoTexto );
    PivoteMsg                     :=
      CAFE_GenerarMensajeOutputCodigoNumeral
      ( '', ConteoPrincipalRenglon,
        CodigoAcumulado[ EndSaveREPO ], EndSaveREPO, 0 );
    WriteLn( PipeOutputText, PivoteMsg );
    Inc( CodigoAcumulado[ EndSaveREPO ] );
    PivoteMsg                     :=
      CAFE_GenerarMensajeOutputCodigoNumeral
      ( '', ConteoPrincipalRenglon,
        CodigoAcumulado[ ExitoREPO ], ExitoREPO, 0 );
    WriteLn( PipeOutputText, PivoteMsg );
    Inc( CodigoAcumulado[ ExitoREPO ] );
  END;  { WITH MyManejador }
END;   { PROCEDURE CAFE_NudoSintacticoString.EjecutarOrdenSave }

  {$IFDEF       SILENCIAR       }
  {$HINTS       OFF             }
  {$ENDIF                       }
PROCEDURE   CAFE_NudoSintacticoString.EjecutarOrdenIdentificadorHoja
  ( CONST OrdenPipe             : ShortString;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico;
          BanderaNOT            : Boolean       = FALSE                 );
{ virtual; }
VAR
  PivoteString                  : ShortString;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  Fila,
  Columna                       : LongInt;

    { ANIDADO }
  PROCEDURE AnidadoOrdenNuevoGrupoSave;
  VAR
    SaveItem                    : CAFE_TCollectionItemSave;

  BEGIN  { PROCEDURE AnidadoOrdenNuevoGrupoSave }
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      SaveItem                          := ListaGruposLoadSave.Add as
                                                CAFE_TCollectionItemSave;
      GrupoSaveActivo                   :=
            ListaGruposLoadSave.GenerarNuevoNombreGrupo;
      SaveItem.NombreItemSave           := GrupoSaveActivo;
      BanderaMantenerGrupoSave          := TRUE;
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( GrupoSaveActivo ),
                NumeroRenglon,
                CodigoAcumulado[ NombreREPO ], NombreREPO, 0 ) );
      Inc( CodigoAcumulado[ NombreREPO ] );
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoOrdenNuevoGrupoSave }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenActualGrupoSave;
  BEGIN  { PROCEDURE AnidadoOrdenActualGrupoSave }
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( GrupoSaveActivo ),
                NumeroRenglon,
                CodigoAcumulado[ NombreREPO ], NombreREPO, 0 ) );
      Inc( CodigoAcumulado[ NombreREPO ] );
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoOrdenActualGrupoSave }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenActualManejador;
  BEGIN  { PROCEDURE AnidadoOrdenActualManejador }
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( InterfaceManejadorActivo.DisplayNombre ),
                NumeroRenglon,
                CodigoAcumulado[ NombreREPO ], NombreREPO, 0 ) );
      Inc( CodigoAcumulado[ NombreREPO ] );
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( CAFE_VariantToString
                ( InterfaceManejadorActivo.Actual.ID ) ),
                NumeroRenglon,
                CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
      Inc( CodigoAcumulado[ ResultREPO ] );
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoOrdenActualManejador }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenActualDescriptorHoja;
  VAR
    PivoteString                : ShortString;

  BEGIN  { PROCEDURE AnidadoOrdenActualManejador }
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      IF MyManejador.HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
      PivoteString                      :=
            '$'+IntToHex( CAFE_ConjuntoVariantesDescriptoresHojaToLongInt
                    ( MyManejador.HojaDefault.DescriptoresHoja ), 1 );
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( PivoteString ),
                NumeroRenglon,
                CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
      Inc( CodigoAcumulado[ ResultREPO ] );
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoOrdenActualDescriptorHoja }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenListaGruposSave;
  VAR
    SaveItem                    : CAFE_TCollectionItemSave;

  BEGIN  { PROCEDURE AnidadoOrdenListaGruposSave }
    WITH CAFE_RaizManejadores as CAFE_TCollectionManejadorString DO BEGIN
      FOR TCollectionItem( SaveItem ) IN ListaGruposLoadSave DO BEGIN
        WriteLn( CAFE_Application.PipeOutputText,
          CAFE_GenerarMensajeOutputCodigoNumeral
          ( QuotedStr( SaveItem.NombreItemSave ),
                  NumeroRenglon,
                  CodigoAcumulado[ NombreREPO ], NombreREPO, 0 ) );
        Inc( CodigoAcumulado[ NombreREPO ] );
      END;  { FOR SaveItem }
    END;  { WITH CAFE_RaizManejadores }
  END;   { PROCEDURE AnidadoOrdenListaGruposSave }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenListaManejadoresTotal;
  VAR
    MyManejadorBasico           : CAFE_ManejadorBasico;

  BEGIN  { PROCEDURE AnidadoOrdenListaManejadoresTotal }
    FOR TCollectionItem( MyManejadorBasico ) IN CAFE_RaizManejadores DO BEGIN
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( MyManejadorBasico.DisplayNombre ),
                NumeroRenglon,
                CodigoAcumulado[ NombreREPO ], NombreREPO, 0 ) );
      Inc( CodigoAcumulado[ NombreREPO ] );
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( CAFE_VariantToString( MyManejadorBasico.ID ) ),
                NumeroRenglon,
                CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
      Inc( CodigoAcumulado[ ResultREPO ] );
    END;  { FOR MyManejadorBasico }
  END;   { PROCEDURE AnidadoOrdenListaManejadoresTotal }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenFuncionalHoja
    (       ItemDescriptor      : CAFE_VariantesDescriptoresHoja        );
  BEGIN  { PROCEDURE AnidadoOrdenFuncionalHoja }
    WITH MyManejador DO BEGIN
      IF HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
      IF BanderaNOT
      THEN Exclude( HojaDefault.DescriptoresHoja, ItemDescriptor )
      ELSE Include( HojaDefault.DescriptoresHoja, ItemDescriptor );
    END;  { WITH MyManejador }
  END;   { PROCEDURE AnidadoOrdenFuncionalHoja }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenTotalNivelesUndo;
  BEGIN  { PROCEDURE AnidadoOrdenTotalNivelesUndo }
    WriteLn( CAFE_Application.PipeOutputText,
      CAFE_GenerarMensajeOutputCodigoNumeral
      ( QuotedStr( CAFE_VariantToString
              ( MyManejador.PaqueteUndo.NivelUndo ) ),
              NumeroRenglon,
              CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
    Inc( CodigoAcumulado[ ResultREPO ] );
    WriteLn( CAFE_Application.PipeOutputText,
      CAFE_GenerarMensajeOutputCodigoNumeral
      ( QuotedStr( CAFE_VariantToString
              ( MyManejador.PaqueteUndo.Count ) ),
              NumeroRenglon,
              CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
    Inc( CodigoAcumulado[ ResultREPO ] );
    IF MyManejador.HojaDefault = NIL THEN BEGIN
      WriteLn( CAFE_Application.PipeStdErrText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( QuotedStr( CAFE_ListaMensajePipe.LeerMensaje
                ( AlertaREPO, CAFE_AlertaMecanismoUndoRequiereHojaTrabajo ) ),
                NumeroRenglon,
                CodigoAcumulado[ AlertaREPO ], AlertaREPO,
                CAFE_AlertaMecanismoUndoRequiereHojaTrabajo ) );
      Inc( CodigoAcumulado[ AlertaREPO ] );
    END;  { IF HojaDefault = NIL }
  END;   { PROCEDURE AnidadoOrdenTotalNivelesUndo }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenRecalculo;
  VAR
    DescriptorInterno           : CAFE_ConjuntoVariantesDescriptoresHoja;
    RecorreFila,
    RecorreColumna              : LongInt;

  BEGIN  { PROCEDURE AnidadoOrdenRecalculo }
    WITH MyManejador DO BEGIN
      IF HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
      WITH HojaDefault DO BEGIN
        DescriptorInterno       := DescriptoresHoja;
        DescriptoresHoja        := DescriptoresHoja+
                [ ForzarRecalculoTotalCVDH, VerValorPruebaCVDH ]-
                [ VerFuncionalCVDH ];
        TRY
          FOR RecorreFila := 0 TO Pred( FilasEnHoja ) DO BEGIN
            FOR RecorreColumna := 0 TO Pred( ColumnasEnHoja ) DO BEGIN
              EjecutarOrdenEvaluarCasilla( RecorreFila, RecorreColumna,
                NumeroRenglon, CodigoAcumulado, Manejador, FALSE );
            END;  { FOR RecorreFila }
          END;  { FOR RecorreColumna }
        FINALLY
          DescriptoresHoja      := DescriptorInterno;
        END;  { TRY }
      END;  { WITH HojaDefault }
    END;  { WITH MyManejador }
  END;   { PROCEDURE AnidadoOrdenRecalculo }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenHojaReinicio;

  BEGIN  { PROCEDURE AnidadoOrdenHojaReinicio }
    WITH MyManejador DO BEGIN
      IF HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
      ( Actual as CAFE_ManejadorBasicoString ).ReinicioHojaManejadorBasico;
    END;  { WITH MyManejador }
  END;   { PROCEDURE AnidadoOrdenHojaReinicio }
    { ANIDADO }

    { ANIDADO }
  PROCEDURE AnidadoOrdenBooleanGlobal
    (       BooleanGlobal       : Byte                                  );
  BEGIN  { PROCEDURE AnidadoOrdenBooleanGlobal }
    WITH MyManejador DO BEGIN
      IF HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
      CASE BooleanGlobal OF
        1               : ValorBanderaSimularCalculo    := NOT( BanderaNOT );
        2               : CAFE_HabilitarUnCiclo         := NOT( BanderaNOT );
      END;  { CASE BooleanGlobal }
    END;  { WITH MyManejador }
  END;   { PROCEDURE AnidadoOrdenBooleanGlobal }
    { ANIDADO }

BEGIN  { FUNCTION CAFE_NudoSintacticoString.EjecutarOrdenIdentificadorHoja }
  IF CAFE_TipoVariante( DatoElemento ) <> varString
  THEN RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorOrdenNoEntendida );
  PivoteString                  := DatoElemento;
  IF PivoteString = '' THEN Exit;
  Manejador.Actual.GetInterfaceByStr
                ( CAFE_GUIDInterfaceManejador, MyManejador );
  WITH MyManejador DO BEGIN
    IF NOT( BanderaNOT ) THEN BEGIN
      // ordenes incompatibles con NOT
      IF PivoteString = CAFE_OrdenNuevoGrupoSave THEN BEGIN
        AnidadoOrdenNuevoGrupoSave;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenNuevoGrupoSave }
      IF PivoteString = CAFE_OrdenActualGrupoSave THEN BEGIN
        IF InProcesoVerbose THEN AnidadoOrdenActualGrupoSave;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenActualGrupoSave }
      IF PivoteString = CAFE_OrdenActualManejador THEN BEGIN
        IF InProcesoVerbose THEN AnidadoOrdenActualManejador;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenActualManejador }
      IF PivoteString = CAFE_OrdenActualDescriptorHoja THEN BEGIN
        IF InProcesoVerbose THEN AnidadoOrdenActualDescriptorHoja;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenActualDescriptorHoja }
      IF PivoteString = CAFE_OrdenListaManejadoresTotal THEN BEGIN
        IF InProcesoVerbose THEN AnidadoOrdenListaManejadoresTotal;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenListaManejadoresTotal }
      IF PivoteString = CAFE_OrdenListaGruposSave THEN BEGIN
        IF InProcesoVerbose THEN AnidadoOrdenListaGruposSave;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenListaGruposSave }
      IF PivoteString = CAFE_OrdenUndoSeguridad THEN BEGIN
        PaqueteUndo.CopiaActualHojaCalculo;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenUndoSeguridad }
      IF PivoteString = CAFE_OrdenTotalNivelesUndo THEN BEGIN
        IF InProcesoVerbose THEN AnidadoOrdenTotalNivelesUndo;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenTotalNivelesUndo }
      IF PivoteString = CAFE_OrdenRecalculo THEN BEGIN
        AnidadoOrdenRecalculo;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenRecalculo }
      IF PivoteString = CAFE_OrdenHojaReinicio THEN BEGIN
        AnidadoOrdenHojaReinicio;
        Exit;
      END;  { IF PivoteString = CAFE_OrdenHojaReinicio }
      IF PivoteString = CAFE_OrdenHabilitarUnCiclo THEN BEGIN
      // Se considera que como NOT el usuario probablemente no entienda
      // su funcionamiento
        AnidadoOrdenBooleanGlobal( 2 );
        Exit;
      END;  { IF PivoteString = CAFE_OrdenHabilitarUnCiclo }
    END;  { IF NOT( BanderaNOT ) }
    IF PivoteString = CAFE_OrdenVerFuncional THEN BEGIN
      AnidadoOrdenFuncionalHoja( VerFuncionalCVDH );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenVerFuncional }
    IF PivoteString = CAFE_OrdenVerValorPrueba THEN BEGIN
      AnidadoOrdenFuncionalHoja( VerValorPruebaCVDH );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenVerValorPrueba }
    IF PivoteString = CAFE_OrdenTodoCicloProhibido THEN BEGIN
      AnidadoOrdenFuncionalHoja( TodoCicloProhibidoCVDH );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenTodoCicloProhibido }
    IF PivoteString = CAFE_OrdenHojaAislada THEN BEGIN
      AnidadoOrdenFuncionalHoja( HojaAisladaCVDH );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenHojaAislada }
    IF PivoteString = CAFE_OrdenPeticionCalculoObligatorio THEN BEGIN
      AnidadoOrdenFuncionalHoja( PeticionCalculoObligadoCVDH );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenPeticionCalculoObligatorio }
    IF PivoteString = CAFE_OrdenForzarRecalculoTotal THEN BEGIN
      AnidadoOrdenFuncionalHoja( ForzarRecalculoTotalCVDH );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenForzarRecalculoTotal }
    IF PivoteString = CAFE_OrdenBloquearCasillas THEN BEGIN
      IF Manejador.Actual = CAFE_ManejadorTemporal
      THEN RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoHojaTrabajo,
                [ QuotedStr( CAFE_NombreManejadorTemporal ) ] );
      AnidadoOrdenFuncionalHoja( BloquearCasillasCVDH );
      Exit;
    END;  { IF PivoteString = CAFE_OrdenBloquerCasillas }
    IF NOT( InProcesoLoad ) THEN BEGIN
      IF PivoteString = CAFE_OrdenModoSimularCalculo THEN BEGIN
        AnidadoOrdenBooleanGlobal( 1 );
        Exit;
      END;  { IF PivoteString = CAFE_OrdenModoSimularCalculo }
      IF NOT( BanderaNOT ) THEN BEGIN
        IF PivoteString = CAFE_OrdenSalida THEN BEGIN
          PaqueteUndo.ClearUndo;
          CAFE_Application.Terminate;
          Exit;
        END;  { IF PivoteString = CAFE_OrdenSalida }
      END;  { IF NOT( BanderaNOT ) }
    END;  { IF NOT( InProcesoLoad ) }
  END;  { WITH MyManejador }
  IF NOT( BanderaNOT ) THEN BEGIN
    TRY
      LeerCasillaObligatorio( Fila, Columna, Manejador );
    EXCEPT
      ON CAFE_PipeException
      DO BEGIN
        RAISE CAFE_PipeException.
                      Create( ErrorREPO, CAFE_ErrorOrdenNoEntendida );
      END;  { ON CAFE_PipeException }
    END;  { TRY }
    IF InProcesoVerbose THEN EjecutarOrdenEvaluarCasilla( Fila, Columna,
                      NumeroRenglon, CodigoAcumulado, Manejador );
    Exit;
  END;  { IF NOT( BanderaNOT ) }
  RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorOrdenNoEntendida );
END;   { FUNCTION CAFE_NudoSintacticoString.EjecutarOrdenIdentificadorHoja }
  {$IFDEF       SILENCIAR       }
  {$HINTS       ON              }
  {$ENDIF                       }

FUNCTION    CAFE_NudoSintacticoString.EjecutarOrdenEvaluarCasilla
  (       Fila, Columna         : LongInt;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico;
          BanderaWritePipe      : Boolean       = TRUE;
          BanderaWriteErrors    : Boolean       = FALSE ) : ShortString;
VAR
  PivoteString,
  Msg                           : ShortString;
  DatoVariante,
  DatoResultado                 : Variant;
  CaracterMacro                 : CAFE_ConjuntoParametroBasico;
  MyRec                         : CAFE_DatoExtendido;
  PivoteReal                    : Double;
  BanderaSalidaError,
  BanderaNudillado,
  BanderaMacro                  : Boolean;

LABEL
  SalidaError;

BEGIN  { PROCEDURE CAFE_NudoSintacticoString.EjecutarOrdenEvaluarCasilla }
  // Debe entrar con numero casilla valido
  WITH Manejador.Actual as CAFE_ManejadorBasico DO BEGIN
    EjecutarOrdenEvaluarCasilla := 'NULL';
    BanderaSalidaError          := FALSE;
    BanderaWriteErrors          := BanderaWriteErrors AND
                                                InProcesoVerbose;
    BanderaWritePipe            := BanderaWritePipe AND
                                                InProcesoVerbose;
    HojaDefault.LecturaTipo( Fila, Columna,
                BanderaNudillado, BanderaMacro, CaracterMacro,
                DatoVariante, DatoResultado );
    DatoResultado               := DatoVariante;
    IF BanderaNudillado THEN BEGIN
      IF BanderaMacro THEN BEGIN
        IF VerValorPruebaCVDH IN HojaDefault.DescriptoresHoja THEN BEGIN
          DatoVariante          :=
                HojaDefault.LeerCasilla( MyRec, Fila, Columna );
          WITH MyRec as CAFE_DatoNudillado DO BEGIN
            IF NOT( HojaDefault.EvaluarMacroSimple
                ( Fila, Columna, PivoteReal,
                  Msg, Manejador, CantidadParametros, ValorPruebaUno,
                  ValorPruebaDos, ValorPruebaTres ) ) THEN BEGIN
              IF BanderaWritePipe THEN BEGIN
                WriteLn( CAFE_Application.PipeOutputText,
                  CAFE_GenerarMensajeOutputCodigoNumeral
                  ( QuotedStr( CAFE_SResultVarError ),
                          NumeroRenglon,
                          CodigoAcumulado[ ResultREPO ], ResultREPO,
                          CAFE_ResultVarError ) );
                Inc( CodigoAcumulado[ ResultREPO ] );
              END;  { IF BanderaWritePipe }
              IF BanderaWriteErrors THEN BEGIN
                IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
                  BanderaSalidaError              := TRUE;
                  GOTO SalidaError;
                END;  { IF ImplementationIntentoInfructuosoNoPipe }
                IF Msg = '' THEN BEGIN
                  WriteLn( CAFE_Application.PipeStdErrText,
                    CAFE_GenerarMensajeOutputCodigoNumeral
                    ( QuotedStr( CAFE_SVarErrorEvaluar ),
                            NumeroRenglon,
                            CodigoAcumulado[ ErrorREPO ], ErrorREPO,
                            CAFE_ErrorVarErrorEvaluar ) );
                  Inc( CodigoAcumulado[ ErrorREPO ] );
                END ELSE BEGIN  { IF Msg = '' ELSE }
                  RAISE CAFE_MensajeException.Create( Msg );
                END;            { IF Msg = '' ELSE }
              END;  { IF BanderaWriteErrors }
              CAFE_MensajeInfructuoso.ClearMessage;
              EjecutarOrdenEvaluarCasilla         := 'VarError';
              Exit;
            END;  { IF NOT( HojaDefault.EvaluarMacroSimple... ) }
            CAFE_VarCast( DatoResultado, PivoteReal, varDouble );
          END;  { WITH MyRec as CAFE_DatoNudillado }
        END;  { IF VerValorPrueba CVDH IN HojaDefault.DescriptoresHoja }
      END ELSE BEGIN  { IF BanderaMacro ELSE }
        IF NOT( VerFuncionalCVDH IN HojaDefault.DescriptoresHoja ) THEN BEGIN
          IF NOT( HojaDefault.EvaluarFuncionSimple
                ( Fila, Columna, DatoResultado, Msg, Manejador ) ) THEN BEGIN
            IF BanderaWritePipe THEN BEGIN
              WriteLn( CAFE_Application.PipeOutputText,
                CAFE_GenerarMensajeOutputCodigoNumeral
                ( QuotedStr( CAFE_SResultVarError ),
                        NumeroRenglon,
                        CodigoAcumulado[ ResultREPO ], ResultREPO,
                        CAFE_ResultVarError ) );
              Inc( CodigoAcumulado[ ResultREPO ] );
            END;  { IF BanderaWritePipe }
            IF BanderaWriteErrors THEN BEGIN
              IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
                BanderaSalidaError              := TRUE;
                GOTO SalidaError;
              END;  { IF ImplementationIntentoInfructuosoNoPipe }
              IF Msg = '' THEN BEGIN
                WriteLn( CAFE_Application.PipeStdErrText,
                  CAFE_GenerarMensajeOutputCodigoNumeral
                  ( QuotedStr( CAFE_SVarErrorEvaluar ),
                          NumeroRenglon,
                          CodigoAcumulado[ ErrorREPO ], ErrorREPO,
                          CAFE_ErrorVarErrorEvaluar ) );
                Inc( CodigoAcumulado[ ErrorREPO ] );
              END ELSE BEGIN  { IF Msg = '' ELSE }
                RAISE CAFE_MensajeException.Create( Msg );
              END;            { IF Msg = '' ELSE }
            END;  { IF BanderaWriteErrors }
            CAFE_MensajeInfructuoso.ClearMessage;
            EjecutarOrdenEvaluarCasilla         := 'VarError';
            Exit;
          END;  { IF NOT( HojaDefault.EvaluarFuncionSimple... ) }
        END;  { IF NOT( VerFuncionalCVDH IN ... ) }
      END;            { IF BanderaMacro ELSE }
    END ELSE BEGIN  { IF BanderaNudillado ELSE }
      DatoResultado                     := DatoVariante;
    END;            { IF BanderaNudillado ELSE }
SalidaError :
    IF BanderaSalidaError THEN BEGIN
      TRY
        IF CAFE_PosicionInfructuosoSintactico <> 0 THEN BEGIN
          RAISE CAFE_PipeCasillaException.
              Create( Fila, Columna, EjecutarErrorPECM,
                CAFE_PosicionInfructuosoSintactico,
                [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
        END ELSE BEGIN  { IF CAFE_PosicionInfructuosoSintactico <> 0 ELSE }
          RAISE CAFE_PipeCasillaException.
              Create( Fila, Columna, SintaxisErrorPECM,
                        CAFE_ErrorOrdenNoEntendida );
        END;            { IF CAFE_PosicionInfructuosoSintactico  <> 0 ELSE }
      EXCEPT
        ON MyError    : CAFE_PipeCasillaException
        DO BEGIN
          CAFE_MensajeInfructuoso.ClearMessage;
          WITH MyError DO BEGIN
            IF CAFE_Application.BanderaLoad
            THEN BEGIN
              RAISE CAFE_PipeException.
                Create( ErrorLoadREPO, CAFE_ErrorOrdenNoEntendida );
            END ELSE BEGIN
              Msg                       :=
                QuotedStr( Message )+' '+
                QuotedStr( 'Error casilla ('+
                        IntToStr( Succ( ColumnaReferencia ) )+','+
                        IntToStr( Succ( FilaReferencia ) )+')' );
              WriteLn( CAFE_Application.PipeStdErrText,
                        CAFE_GenerarMensajeOutputCodigoCasilla
                ( Msg, CAFE_Application.ConteoPrincipalRenglon,
                  CodigoAcumulado[ TypeException ],
                  TypeException, FilaReferencia, ColumnaReferencia,
                  Ord( EstiloMsgReferencia ), HelpContext ) );
              Inc( CodigoAcumulado[ TypeException ] );
            END;  { IF CAFE_Application.BanderaLoad }
          END;  { WITH MyError DO BEGIN }
        END;  { ON CAFE_PipeException }
      END;
      EjecutarOrdenEvaluarCasilla         := 'VarError';
      Exit;
    END;  { IF BanderaSalidaError }
    PivoteString                := CAFE_VariantToString( DatoResultado );
    EjecutarOrdenEvaluarCasilla := PivoteString;
    PivoteString                := QuotedStr( PivoteString );
    IF CAFE_TipoVariante( DatoResultado ) = varString
    THEN BEGIN
      EjecutarOrdenEvaluarCasilla       := PivoteString;
      PivoteString                      := QuotedStr( PivoteString );
    END;  { IF CAFE_TipoVariante( DatoResultado ) = varString }
    IF BanderaWritePipe THEN BEGIN
      WriteLn( CAFE_Application.PipeOutputText,
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( PivoteString, NumeroRenglon,
                CodigoAcumulado[ ResultREPO ], ResultREPO, 0 ) );
      Inc( CodigoAcumulado[ ResultREPO ] );
    END;  { IF BanderaWritePipe }
  END;  { WITH ManejadorActual }
END;   { PROCEDURE CAFE_NudoSintacticoString.EjecutarOrdenEvaluarCasilla }

  {$IFDEF       SILENCIAR       }
  {$HINTS       OFF             }
  {$ENDIF                       }
PROCEDURE   CAFE_NudoSintacticoString.EjecutarOrdenCopiaCasillaTemporal
  (       Fila, Columna, FilaTemporal, ColumnaTemporal  : LongInt;
          HaciaDesdeTemporal    : Boolean;
          NumeroRenglon         : LongInt;
    VAR   CodigoAcumulado       : CAFE_MatrizRenglonConteo;
          Manejador             : CAFE_InterfaceBasico          );
{ virtual; }
VAR
  VariantPivote                 : Variant;
  HojaOrigen,
  HojaDestino                   : CAFE_HojaCalculoBase;
  MyRec                         : CAFE_DatoExtendido;
  PivoteFila,
  PivoteColumna                 : LongInt;

BEGIN  { PROCEDURE ...EjecutarOrdenCopiaCasillaTemporal }
  //  Debe entar con numero de casilla valido y con posibilidad de
  //  lectura y escritura
  //  No copia formato
  IF CAFE_ManejadorTemporal = Manejador.Actual THEN
  RAISE CAFE_PipeException.Create
        ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoHojaTrabajo,
                [ QuotedStr( CAFE_NombreManejadorTemporal ) ] );
  IF HaciaDesdeTemporal THEN BEGIN
    HojaOrigen                  :=
                ( Manejador.Actual as CAFE_ManejadorBasico ).HojaDefault;
    HojaDestino                 :=
        ( CAFE_ManejadorTemporal as CAFE_ManejadorBasico ).HojaDefault;
  END ELSE BEGIN  { IF HaciaDesdeTemporal ELSE }
    HojaOrigen                  :=
        ( CAFE_ManejadorTemporal as CAFE_ManejadorBasico ).HojaDefault;
    HojaDestino                 :=
                ( Manejador.Actual as CAFE_ManejadorBasico ).HojaDefault;
    PivoteFila                  := FilaTemporal;
    FilaTemporal                := Fila;
    Fila                        := PivoteFila;
    PivoteColumna               := ColumnaTemporal;
    ColumnaTemporal             := Columna;
    Columna                     := PivoteColumna;
  END;            { IF HaciaDesdeTemporal ELSE }
  WITH HojaOrigen DO BEGIN
    VariantPivote               := LeerCasilla( MyRec, Fila, Columna );
    IF MyRec = NIL
    THEN HojaDestino.EscribirCasilla( VariantPivote,
                NIL, FilaTemporal, ColumnaTemporal )
    ELSE HojaDestino.EscribirCasilla( VariantPivote,
                MyRec.PeticionSimilar, FilaTemporal, ColumnaTemporal );
    // Formato no cambia
  END;  { WITH HojaOrigen }
END;   { PROCEDURE ...EjecutarOrdenCopiaCasillaTemporal }
  {$IFDEF       SILENCIAR       }
  {$HINTS       ON              }
  {$ENDIF                       }

FUNCTION    CAFE_NudoSintacticoString.LeerSelectorAlternativaObligatorio
  (       Manejador             : CAFE_InterfaceBasico;
          EquivalenteString     : TStringDynArray               ) : LongInt;
VAR
  PivoteStringPrevio,
  PivoteString                  : ShortString;
  ConteoInterno                 : LongInt;

BEGIN  { FUNCTION CAFE_NudoSintacticoString.LeerAlternativaObligatorio }
  IF CAFE_TipoVariante( DatoElemento ) = varString THEN BEGIN
      PivoteStringPrevio        := DatoElemento;
      PivoteString              :=
        ( Manejador.Actual as CAFE_ManejadorBasico ).
        PaqueteIdioma.Values[ PivoteStringPrevio ];
      IF PivoteString = ''
      THEN PivoteString         := PivoteStringPrevio
      ELSE DatoElemento         := PivoteString;
      FOR ConteoInterno := Low( EquivalenteString ) TO
                           High( EquivalenteString ) DO BEGIN
        IF EquivalenteString[ ConteoInterno ] = PivoteString THEN BEGIN
          LeerSelectorAlternativaObligatorio    := ConteoInterno;
          Exit;
        END;  { IF MyString = PivoteString }
      END;  { FOR ConteoInterno }
      RAISE CAFE_PipeException.
                Create( ErrorREPO,
                        CAFE_ErrorSelectorAlternativaPendiente );
  END ELSE BEGIN  { IF CAFE_TipoVariante( DatoElemento ) = varString ELSE }
    RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorSelectorAlternativaPendiente );
  END;            { IF CAFE_TipoVariante( DatoElemento ) = varString ELSE }
END;   { FUNCTION CAFE_NudoSintacticoString.LeerAlternativaObligatorio }

PROCEDURE   CAFE_NudoSintacticoString.LeerCasillaObligatorio
  ( OUT   Fila, Columna         : LongInt;
          Manejador             : CAFE_InterfaceBasico                  );
VAR
  DolarFila,
  DolarColumna                  : Boolean;

BEGIN  { PROCEDURE CAFE_NudoSintacticoString.LeerCasillaObligatorio }
  IF CAFE_TipoVariante( DatoElemento ) = varString THEN BEGIN
    WITH Manejador.Actual as CAFE_ManejadorBasico DO BEGIN
      IF HojaDefault = NIL
      THEN RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo );
      IF NOT( HojaDefault.IdentificadorValidoCasilla( DatoElemento,
                        DolarFila, Fila, DolarColumna, Columna ) )
      THEN RAISE CAFE_PipeException.
          Create( ErrorREPO, CAFE_ErrorDatoIdentificadorCasillaPendiente );
    END;  { WITH Manejador.Actual }
  END ELSE BEGIN  { IF CAFE_TipoVariante( DatoElemento ) = varString ELSE }
    RAISE CAFE_PipeException.
          Create( ErrorREPO, CAFE_ErrorDatoIdentificadorCasillaPendiente );
  END;            { IF CAFE_TipoVariante( DatoElemento ) = varString ELSE }
END;   { PROCEDURE CAFE_NudoSintacticoString.LeerCasillaObligatorio }

PROCEDURE   CAFE_NudoSintacticoString.LeerRangoCasillaObligatorio
  ( OUT   FilaI, ColumnaI       : LongInt;
    OUT   FilaF, ColumnaF       : LongInt;
          Manejador             : CAFE_InterfaceBasico                  );
VAR
  PivoteString                  : ShortString;
  PivoteNodo                    : CAFE_NudoSintacticoString;
  PivoteEntero                  : LongInt;

BEGIN  { PROCEDURE CAFE_NudoSintacticoString.LeerRangoCasillaObligatorio }
  IF CAFE_TipoVariante( DatoElemento ) = varString THEN BEGIN
    PivoteString                := DatoElemento;
    IF PivoteString = CAFE_SecuenciaRectangularHojaTraducidoOperadorBasico
    THEN BEGIN
      PivoteNodo                :=
                DescendienteVertical as CAFE_NudoSintacticoString;
      PivoteNodo.LeerCasillaObligatorio
                                ( FilaI, ColumnaI, Manejador );
      PivoteNodo                :=
        PivoteNodo.DescendienteHorizontal as CAFE_NudoSintacticoString;
      PivoteNodo.LeerCasillaObligatorio
                                ( FilaF, ColumnaF, Manejador );
      IF FilaI > FilaF THEN BEGIN
        PivoteEntero            := FilaI;
        FilaI                   := FilaF;
        FilaF                   := PivoteEntero;
      END;  { IF FilaI > FilaF }
      IF ColumnaI > ColumnaF THEN BEGIN
        PivoteEntero            := ColumnaI;
        ColumnaI                := ColumnaF;
        ColumnaF                := PivoteEntero;
      END;  { IF ColumnaI > ColumnaF }
    END ELSE BEGIN  { IF ...CAFE_SecuenciaRectangular... ELSE }
      LeerCasillaObligatorio( FilaI, ColumnaI, Manejador );
      FilaF                     := FilaI;
      ColumnaF                  := ColumnaI;
    END;            { IF ...CAFE_SecuenciaRectangular... ELSE }
  END ELSE BEGIN  { IF CAFE_TipoVariante( DatoElemento ) = varString ELSE }
    RAISE CAFE_PipeException.
          Create( ErrorREPO, CAFE_ErrorDatoIdentificadorCasillaPendiente );
  END;            { IF CAFE_TipoVariante( DatoElemento ) = varString ELSE }
END;   { PROCEDURE CAFE_NudoSintacticoString.LeerRangoCasillaObligatorio }

FUNCTION    CAFE_NudoSintacticoString.LeerLongIntObligatorio
  (       Manejador             : CAFE_InterfaceBasico  = NIL;
          EquivalenteString     : TStringDynArray       = NIL;
          EquivalenteValor      : TIntegerDynArray      = NIL   ) : LongInt;
VAR
  PivoteStringPrevio,
  PivoteString                  : ShortString;
  ConteoInterno                 : LongInt;

BEGIN  { FUNCTION CAFE_NudoSintacticoString.LeerLongIntObligatorio }
  CASE CAFE_TipoVariante( DatoElemento ) OF
    varString           : BEGIN
      TRY
        LeerLongIntObligatorio          := StrToInt( DatoElemento );
        Exit;
      EXCEPT
        ON EConvertError
        DO BEGIN
           END;
      END;  { TRY }
      IF EquivalenteString = NIL
      THEN CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorDatoEnteroPendiente );
      PivoteStringPrevio        := UpperCase( DatoElemento );
      PivoteString              :=
        ( Manejador.Actual as CAFE_ManejadorBasico ).
        PaqueteIdioma.Values[ PivoteStringPrevio ];
      IF PivoteString = ''
      THEN PivoteString         := PivoteStringPrevio
      ELSE DatoElemento         := PivoteString;
      PivoteString              := DatoElemento;
      FOR ConteoInterno := Low( EquivalenteString ) TO
                           High( EquivalenteString ) DO BEGIN
        IF EquivalenteString[ ConteoInterno ] = PivoteString THEN BEGIN
          LeerLongIntObligatorio        := EquivalenteValor[ ConteoInterno ];
          Exit;
        END;  { IF MyString = PivoteString }
      END;  { FOR ConteoInterno }
      RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorDatoEnteroPendiente );
                          END;  { CASE varString }
    varInteger,
    varByte             : LeerLongIntObligatorio        := DatoElemento;
    ELSE RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorDatoEnteroPendiente );
  END;  { CASE CAFE_TipoVariante( DatoElemento ) }
END;   { FUNCTION CAFE_NudoSintacticoString.LeerLongIntObligatorio }

FUNCTION    CAFE_NudoSintacticoString.LeerFloatObligatorio
  (       Manejador             : CAFE_InterfaceBasico  = NIL;
          EquivalenteString     : TStringDynArray       = NIL;
          EquivalenteValor      : TDoubleDynArray       = NIL   ) : Double;
VAR
  PivoteStringPrevio,
  PivoteString                  : ShortString;
  ConteoInterno                 : Integer;

BEGIN  { FUNCTION CAFE_NudoSintacticoString.LeerFloatObligatorio }
  CASE CAFE_TipoVariante( DatoElemento ) OF
    varString           : BEGIN
      IF EquivalenteString = NIL
      THEN CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorDatoRealPendiente );
      PivoteStringPrevio        := UpperCase( DatoElemento );
      PivoteString              :=
        ( Manejador.Actual as CAFE_ManejadorBasico ).
        PaqueteIdioma.Values[ PivoteStringPrevio ];
      IF PivoteString = ''
      THEN PivoteString         := PivoteStringPrevio
      ELSE DatoElemento         := PivoteString;
      PivoteString              := DatoElemento;
      FOR ConteoInterno := Low( EquivalenteString ) TO
                           High( EquivalenteString ) DO BEGIN
        IF EquivalenteString[ ConteoInterno ] = PivoteString THEN BEGIN
          LeerFloatObligatorio          := EquivalenteValor[ ConteoInterno ];
          Exit;
        END;  { IF ... = PivoteString }
      END;  { FOR ConteoInterno }
      RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorDatoRealPendiente );
                          END;  { CASE varString }
    varDecimal,
    varCurrency,
    varDate,
    varDouble,
    varInteger,
    varByte             : LeerFloatObligatorio          := DatoElemento;
    ELSE RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorDatoRealPendiente );
  END;  { CASE CAFE_TipoVariante( DatoElemento ) }
END;   { FUNCTION CAFE_NudoSintacticoString.LeerFloatObligatorio }

FUNCTION    CAFE_NudoSintacticoString.LeerStObligatorio
  (       BanderaProhibirNull   : Boolean       = FALSE ) : ShortString;
VAR
  PivoteString                  : ShortString;
  PivoteEntero                  : LongInt;

BEGIN  { FUNCTION CAFE_NudoSintacticoString.LeerStObligatorio }
  IF CAFE_TipoVariante( DatoElemento ) <> varString
  THEN RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorDatoStringPendiente );
  PivoteString                  := DatoElemento;
  IF PivoteString = CAFE_IdentificadorStringNull THEN BEGIN
    IF BanderaProhibirNull
    THEN RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorDatoStringPendiente );
    LeerStObligatorio           := '';
    Exit;
  END;  { IF PivoteString = CAFE_IdentificadorStringNull }
  IF PivoteString = CAFE_OperadorCHRSintactico THEN BEGIN
    IF DescendienteVertical = NIL
    THEN RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorFaltanParametrosEnOperador,
                        [ QuotedStr( PivoteString ) ] );
    TRY
      PivoteEntero              := DescendienteVertical.DatoElemento;
      LeerStObligatorio         := UpCase( Chr( PivoteEntero ) );
    EXCEPT
      ON EVariantError
      DO RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorStringMalDefinida );
    END;  { TRY }
    Exit;
  END;  { IF PivoteString = CAFE_OperadorCHRSintactico }
  IF PivoteString = CAFE_OperadorStringTraducidoOperadorBasico THEN BEGIN
    TRY
      PivoteEntero              := DescendienteVertical.DatoElemento;
      LeerStObligatorio         :=
                UpperCase( CAFE_DefaultListaString[ PivoteEntero ] );
    EXCEPT
      ON EVariantError
      DO RAISE CAFE_PipeException.
                Create( ErrorREPO, CAFE_ErrorStringMalDefinida );
    END;  { TRY }
    Exit;
  END;  { IF PivoteString = CAFE_OperadorStringTraducidoOperadorBasico }
  RAISE CAFE_PipeException.Create( ErrorREPO, CAFE_ErrorDatoStringPendiente );
END;   { FUNCTION CAFE_NudoSintacticoString.LeerStObligatorio }

FUNCTION    CAFE_NudoSintacticoString.
                LeerStIdentificadorObligatorio          : ShortString;
VAR
  PivoteString                  : ShortString;

BEGIN  { FUNCTION CAFE_NudoSintacticoString.LeerStIdentificadorObligatorio }
  PivoteString                  := LeerStObligatorio( TRUE );
  ImplementationSintactico.InsertarString( UpCase( PivoteString ) );
  IF NOT( ImplementationSintactico.VerificarIdentificadorBasico
          ( LeerStIdentificadorObligatorio,
            CAFE_PrimerByteIdentificadorSintactico,
            CAFE_MedioByteIdentificadorSintactico,
            CAFE_UltimoByteIdentificadorSintactico ) )
  THEN RAISE CAFE_PipeException.
        Create( ErrorREPO, CAFE_ErrorStringIdentificadorValido,
                        [ QuotedStr( PivoteString ) ]);
END;   { FUNCTION CAFE_NudoSintacticoString.LeerStIdentificadorObligatorio }

FUNCTION    CAFE_NudoSintacticoString.InProcesoLoad             : Boolean;
BEGIN  { FUNCTION CAFE_NudoSintacticoString.InProcesoLoad }
  InProcesoLoad                 := CAFE_Application.BanderaLoad;
END;   { FUNCTION CAFE_NudoSintacticoString.InProcesoLoad }

FUNCTION    CAFE_NudoSintacticoString.InProcesoVerbose          : Boolean;
BEGIN  { FUNCTION CAFE_NudoSintacticoString.InProcesoVerbose }
  InProcesoVerbose              :=
                CAFE_Application.BanderaConteoPrincipalRenglon;
END;   { FUNCTION CAFE_NudoSintacticoString.InProcesoVerbose }

CONSTRUCTOR CAFE_TCollectionManejadorString.Create;
{ override; }
BEGIN  { CONSTRUCTOR CAFE_TCollectionManejadorString.Create }
  inherited;
  InterfaceManejadorActivo              := NIL;
  ListaManejadoresLoad                  := TStringList.Create;
  ListaGruposLoadSave                   := CAFE_TCollectionSave.Create( NIL );
  GrupoSaveActivo                       := '';
  BanderaMantenerGrupoSave              := FALSE;
  WITH ListaManejadoresLoad DO BEGIN
    Sorted                              := TRUE;
    Duplicates                          := dupError;
    CaseSensitive                       := FALSE;
  END;  { WITH ListaManejadoresLoad }
END;   { CONSTRUCTOR CAFE_TCollectionManejadorString.Create }

DESTRUCTOR  CAFE_TCollectionManejadorString.Destroy;
{ override; }
BEGIN  { DESTRUCTOR CAFE_TCollectionManejadorString.Destroy }
  InterfaceManejadorActivo              := NIL;
  FreeAndNIL( ListaManejadoresLoad );
  FreeAndNIL( ListaGruposLoadSave );
  GrupoSaveActivo                       := '';
  BanderaMantenerGrupoSave              := FALSE;
  Inherited;
END;   { DESTRUCTOR CAFE_TCollectionManejadorString.Destroy }

  Class
PROCEDURE   CAFE_TCollectionManejadorString.Activar;
{ override; }
VAR
  MyManejadorInicial            : TCollectionItem;
  ItemSave                      : CAFE_TCollectionItemSave;
  MyHoja                        : CAFE_HojaCalculoBase;

BEGIN  { PROCEDURE CAFE_TCollectionManejadorString.Activar }
  Inherited;
  IF CAFE_ReferenciaApplication = CAFE_TriplePipeMemory THEN BEGIN
    CAFE_Application            := CAFE_TriplePipeMemory.Create( NIL );
    CAFE_RaizManejadores.GetInterfaceByStr
      ( CAFE_GUIDInterfacePipe, CAFE_Application.InterfaceEjecutora );
    CAFE_Application.Initialize;
  END;  { IF CAFE_ReferenciaApplication = CAFE_TriplePipeMemory }
  MyManejadorInicial            := CAFE_RaizManejadores.Add;
  WITH MyManejadorInicial as CAFE_ManejadorBasicoString DO BEGIN
    GetInterfaceByStr
        ( CAFE_GUIDInterfaceManejador,
                ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
                  InterfaceManejadorActivo );
    CAFE_ManejadorTemporal      :=
                ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
                InterfaceManejadorActivo.Actual as CAFE_Manejador0;
    MyHoja                      := CAFE_TipoHojaAsignado.
        Create( NIL, CAFE_TamanoFilaDefault, CAFE_TamanoColumnaDefault );
    ActivarModoBasico( MyHoja, CAFE_ModoQuimico );
    EstablecerNombrePaquete( CAFE_NombreManejadorTemporal );
    CAFE_ClaveManejadorTemporal := ID;
  END;  { WITH MyManejadorInicial }
  ItemSave                      :=
        ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
        ListaGruposLoadSave.Add as CAFE_TCollectionItemSave;
  WITH ItemSave DO BEGIN
    NombreItemSave              := CAFE_NombreGrupoTemporal;
    ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
        ListaGruposLoadSave.
        AgregarManejadorBasicoGrupoSave( CAFE_NombreGrupoTemporal,
                                MyManejadorInicial as CAFE_ManejadorBasico );
  END;  { WITH ItemSave }
  ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
        GrupoSaveActivo                 := CAFE_NombreGrupoTemporal;
  ( CAFE_RaizManejadores as CAFE_TCollectionManejadorString ).
        BanderaMantenerGrupoSave        := FALSE;
  // El Manejador temporal no deberia acumular elementos SAVE
END;   { PROCEDURE CAFE_TCollectionManejadorString.Activar }

  Class
PROCEDURE   CAFE_TCollectionManejadorString.Desactivar;
{  override; }
BEGIN  { PROCEDURE CAFE_TCollectionManejadorString.Desactivar }
  IF CAFE_ReferenciaApplication = CAFE_TriplePipeMemory THEN BEGIN
    FreeAndNil( CAFE_Application );
  END;  { IF CAFE_ReferenciaApplication = CAFE_TriplePipeMemory }
  Inherited;
END;   { PROCEDURE CAFE_TCollectionManejadorString.Desactivar }

FUNCTION    CAFE_TCollectionManejadorString.
                        ReadAdministrador               : TCustomApplication;
BEGIN  { FUNCTION CAFE_TCollectionManejadorString.ReadAdministrador }
  ReadAdministrador             := CAFE_Application;
END;   { FUNCTION CAFE_TCollectionManejadorString.ReadAdministrador }

PROCEDURE   CAFE_TCollectionManejadorString.EjecutarOrden
  (       Solicitud             : CAFE_PipeItem                         );
{ virtual; }
BEGIN  { PROCEDURE CAFE_TCollectionManejadorString.EjecutarOrden }
  RAISE CAFE_PipeHaltException.
        Create( 'Version CAFE 2011 no implementa toda la interface; orden '+
                QuotedStr( Solicitud.OrdenString )+' ignorada' );
END;   { PROCEDURE CAFE_TCollectionManejadorString.EjecutarOrden }

PROCEDURE   CAFE_TCollectionManejadorString.EjecutarRenglonCompleted
  ( CONST OrdenPipe             : String                                );
{ virtual; }
VAR
  PivoteMsg                     : ShortString;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  PivoteArbol                   : CAFE_Nudo2Sintactico;
  ConteoRenglonActual           : CAFE_MatrizRenglonConteo;
  BanderaSalidaError            : Boolean;

LABEL
  SalidaError;

BEGIN  { PROCEDURE CAFE_TCollectionManejadorString.EjecutarRenglonCompleted }
  BanderaSalidaError            := FALSE;
  IF InterfaceManejadorActivo = NIL
  THEN RAISE CAFE_PipeHaltException.
             Create( 'Interface ejecutora no definida...' )
  ELSE BEGIN
    InterfaceManejadorActivo.Actual.GetInterfaceByStr
      ( CAFE_GUIDInterfaceManejador, MyManejador );
    IF ( Administrador as CAFE_TriplePipeMemory ).
         BanderaConteoPrincipalRenglon THEN BEGIN
      ConteoRenglonActual       := CAFE_NulaMatrizRenglonConteo;
      PivoteMsg                 :=
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( '', ( Administrador as CAFE_TriplePipeMemory ).
                ConteoPrincipalRenglon,
          ConteoRenglonActual[ BeginREPO ], BeginREPO, 0 );
      WriteLn( ( Administrador as CAFE_TriplePipeMemory ).
                                        PipeOutputText, PivoteMsg );
      Inc( ConteoRenglonActual[ BeginREPO ] );
      PivoteMsg                 :=
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( '', ( Administrador as CAFE_TriplePipeMemory ).
                ConteoPrincipalRenglon,
          ConteoRenglonActual[ BeginStdErrREPO ], BeginStdErrREPO, 0 );
      WriteLn( ( Administrador as CAFE_TriplePipeMemory ).
                                        PipeStdErrText, PivoteMsg );
      Inc( ConteoRenglonActual[ BeginStdErrREPO ] );
      IF ( Administrador as CAFE_TriplePipeMemory ).BanderaEcho THEN BEGIN
        PivoteMsg               :=
          CAFE_GenerarMensajeOutputCodigoNumeral
          ( QuotedStr( OrdenPipe ),
            ( Administrador as CAFE_TriplePipeMemory ).ConteoPrincipalRenglon,
            ConteoRenglonActual[ EchoREPO ], EchoREPO, 0 );
        WriteLn( ( Administrador as CAFE_TriplePipeMemory ).
                                        PipeOutputText, PivoteMsg );
        Inc( ConteoRenglonActual[ EchoREPO ] );
      END;  { IF Administrador.BanderaEcho }
    END;  { IF Administrador.BanderaConteoPrincipalRenglon }
    WITH MyManejador DO BEGIN
      IF NOT( GramaticaCharByte.GramaticaOperadores( OrdenPipe ) )
      THEN BEGIN  { IF NOT( GramaticaCharByte.GramaticaOperadores ) }
        ImplementationIntentoInfructuosoNoPipe;
        BanderaSalidaError              := TRUE;
        GOTO SalidaError;
      END;        { IF NOT( GramaticaCharByte.GramaticaOperadores ) }
      IF GramaticaCharByte.Ocupado = 0 THEN BEGIN
        IF ( Administrador as CAFE_TriplePipeMemory ).
                        BanderaConteoPrincipalRenglon THEN BEGIN
          PivoteMsg               :=
            CAFE_GenerarMensajeOutputCodigoNumeral
            ( '', ( Administrador as CAFE_TriplePipeMemory ).
                        ConteoPrincipalRenglon,
              ConteoRenglonActual[ NullREPO ], NullREPO, 0 );
          WriteLn( ( Administrador as CAFE_TriplePipeMemory ).
                                        PipeOutputText, PivoteMsg );
          Inc( ConteoRenglonActual[ NullREPO ] );
        END;  { IF Administrador.BanderaConteoPrincipalRenglon }
      END ELSE BEGIN  { IF GramaticaCharByte.Ocupado = 0 ELSE }
        IF GramaticaCharByte.VerificarIdentificadorBasico
          ( PivoteMsg, CAFE_PrimerByteIdentificadorSintactico,
            CAFE_MedioByteIdentificadorSintactico,
            CAFE_UltimoByteIdentificadorSintactico )
        THEN BEGIN
          PivoteArbol                   := CAFE_MoldeManejadorArbol.Create
                                           as CAFE_NudoSintacticoString;
          PivoteArbol.DatoElemento      := GramaticaCharByte.ExtraerString;
        END ELSE BEGIN  { IF ...VerificarIdentificadorBasico ELSE }
          PivoteArbol                :=
                GeneradorArbolSintactico.NuevoArbol( GramaticaCharByte );
          IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
            BanderaSalidaError          := TRUE;
            GOTO SalidaError;
          END;  { IF ImplementationIntentoInfructuosoNoPipe }
        END;            { IF ...VerificarIdentificadorBasico ELSE }
        TRY
          ( PivoteArbol as CAFE_NudoSintacticoString ).
                EjecutarOrdenHoja( OrdenPipe,
                        ( Administrador as CAFE_TriplePipeMemory ).
                        ConteoPrincipalRenglon,
                        ConteoRenglonActual,
                        InterfaceManejadorActivo );
        EXCEPT
          ON MyError    : CAFE_PipeCasillaException
          DO BEGIN
            WITH MyError DO BEGIN
              PivoteMsg                 :=
                QuotedStr( Message )+' '+
                QuotedStr( 'Error casilla ('+
                        IntToStr( Succ( ColumnaReferencia ) )+','+
                        IntToStr( Succ( FilaReferencia ) )+')' );
              WriteLn( CAFE_Application.PipeStdErrText,
                        CAFE_GenerarMensajeOutputCodigoCasilla
                ( PivoteMsg, CAFE_Application.ConteoPrincipalRenglon,
                  ConteoRenglonActual[ TypeException ],
                  TypeException, FilaReferencia, ColumnaReferencia,
                  Ord( EstiloMsgReferencia ), HelpContext ) );
              // NOTA : Aqui no se prueba Administrador.
              //                BanderaConteoPrincipalRenglon
              // debio de consultarse antes, para determinar
              // si es un error de Load o similar
              Inc( ConteoRenglonActual[ TypeException ] );
            END;  { WITH MyError }
          END;  { ON CAFE_PipeCasillaException }
          ON MyError    : CAFE_PipeException
          DO BEGIN
            WITH MyError DO BEGIN
              PivoteMsg                 := QuotedStr( Message );
              WriteLn( ( Administrador as CAFE_TriplePipeMemory ).
                        PipeStdErrText,
                        CAFE_GenerarMensajeOutputCodigoNumeral
                ( PivoteMsg, ( Administrador as CAFE_TriplePipeMemory ).
                        ConteoPrincipalRenglon,
                  ConteoRenglonActual[ TypeException ],
                  TypeException, HelpContext ) );
              Inc( ConteoRenglonActual[ TypeException ] );
            END;  { WITH MyError }
          END;  { ON CAFE_PipeException }
        END;  { TRY }
        FreeAndNil( PivoteArbol );
      END;            { IF GramaticaCharByte.Ocupado = 0 ELSE }
    END;  { WITH MyManejador }
SalidaError :
    IF BanderaSalidaError THEN BEGIN
      TRY
        IF CAFE_PosicionInfructuosoSintactico <> 0 THEN BEGIN
          RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_PosicionInfructuosoSintactico,
                [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
        END ELSE BEGIN  { IF CAFE_PosicionInfructuosoSintactico <> 0 ELSE }
          RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_ErrorOrdenNoEntendida );
        END;            { IF CAFE_PosicionInfructuosoSintactico  <> 0 ELSE }
      EXCEPT
        ON MyError    : CAFE_PipeException
        DO BEGIN
          CAFE_MensajeInfructuoso.ClearMessage;
          WITH MyError DO BEGIN
            IF ( Administrador as CAFE_TriplePipeMemory ).BanderaLoad
            THEN RAISE CAFE_PipeException.
                Create( ErrorLoadREPO, CAFE_ErrorOrdenNoEntendida );
            PivoteMsg                   :=
              CAFE_GenerarMensajeOutputCodigoNumeral
              ( QuotedStr( Message ),
                      ( Administrador as CAFE_TriplePipeMemory ).
                              ConteoPrincipalRenglon,
                ConteoRenglonActual[ TypeException ],
                TypeException, HelpContext );
            WriteLn( ( Administrador as CAFE_TriplePipeMemory ).
                                              PipeStdErrText, PivoteMsg );
            Inc( ConteoRenglonActual[ TypeException ] );
          END;  { WITH MyError DO BEGIN }
        END;  { ON CAFE_PipeException }
      END;
    END;  { IF BanderaSalidaError }
    WHILE ( Administrador as CAFE_TriplePipeMemory ).
                StringsOutput.Count <> 0
    DO WriteLn( ( Administrador as CAFE_TriplePipeMemory ).PipeOutputText,
                ( Administrador as CAFE_TriplePipeMemory ).
                        StringsOutput.FIFOStrings );
    WHILE ( Administrador as CAFE_TriplePipeMemory ).
                StringsStdErr.Count <> 0
    DO WriteLn( ( Administrador as CAFE_TriplePipeMemory ).PipeStdErrText,
                ( Administrador as CAFE_TriplePipeMemory ).
                        StringsStdErr.FIFOStrings );
    IF ( Administrador as CAFE_TriplePipeMemory ).
                        BanderaConteoPrincipalRenglon THEN BEGIN
      PivoteMsg                 :=
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( '', ( Administrador as CAFE_TriplePipeMemory ).
                        ConteoPrincipalRenglon,
          ConteoRenglonActual[ EndStdErrREPO ], EndStdErrREPO, 0 );
      WriteLn( ( Administrador as CAFE_TriplePipeMemory ).
                                        PipeStdErrText, PivoteMsg );
      Inc( ConteoRenglonActual[ EndStdErrREPO ] );
      PivoteMsg                 :=
        CAFE_GenerarMensajeOutputCodigoNumeral
        ( '', ( Administrador as CAFE_TriplePipeMemory ).
                        ConteoPrincipalRenglon,
          ConteoRenglonActual[ EndREPO ], EndREPO, 0 );
      WriteLn( ( Administrador as CAFE_TriplePipeMemory ).
                                        PipeOutputText, PivoteMsg );
      Inc( ConteoRenglonActual[ EndREPO ] );
    END;  { IF Administrador.BanderaConteoPrincipalRenglon }
  END;  { IF InterfaceManejadorActivo = NIL }
  CAFE_MensajeInfructuoso.ClearMessage;
END;   { PROCEDURE CAFE_TCollectionManejadorString.EjecutarRenglonCompleted }

PROCEDURE   CAFE_TCollectionManejadorString.EjecutarRenglonLoad
  ( CONST OrdenPipe             : String;
    VAR   ConteoRenglonActual   : CAFE_MatrizRenglonConteo              );
{ virtual; }
VAR
  PivoteMsg                     : ShortString;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  MyManejador                   : CAFE_InterfaceManejador;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  PivoteArbol                   : CAFE_Nudo2Sintactico;
  BanderaSalidaError            : Boolean;

LABEL
  SalidaError;

BEGIN  { PROCEDURE CAFE_TCollectionManejadorString.EjecutarRenglonLoad }
  BanderaSalidaError            := FALSE;
  IF InterfaceManejadorActivo = NIL
  THEN RAISE CAFE_PipeHaltException.
             Create( 'Interface ejecutora no definida...' )
  ELSE BEGIN
    InterfaceManejadorActivo.Actual.GetInterfaceByStr
      ( CAFE_GUIDInterfaceManejador, MyManejador );
    ( Administrador as CAFE_TriplePipeMemory ).
         BanderaConteoPrincipalRenglon          := FALSE;
    WITH MyManejador DO BEGIN
      IF NOT( GramaticaCharByte.GramaticaOperadores( OrdenPipe ) )
      THEN BEGIN  { IF NOT( GramaticaCharByte.GramaticaOperadores ) }
        ImplementationIntentoInfructuosoNoPipe;
        BanderaSalidaError              := TRUE;
        GOTO SalidaError;
      END;        { IF NOT( GramaticaCharByte.GramaticaOperadores ) }
      IF GramaticaCharByte.Ocupado <> 0 THEN BEGIN
        IF GramaticaCharByte.VerificarIdentificadorBasico
          ( PivoteMsg, CAFE_PrimerByteIdentificadorSintactico,
            CAFE_MedioByteIdentificadorSintactico,
            CAFE_UltimoByteIdentificadorSintactico )
        THEN BEGIN
          PivoteArbol                   := CAFE_MoldeManejadorArbol.Create
                                           as CAFE_NudoSintacticoString;
          PivoteArbol.DatoElemento      := GramaticaCharByte.ExtraerString;
        END ELSE BEGIN  { IF ...VerificarIdentificadorBasico ELSE }
          PivoteArbol                :=
                GeneradorArbolSintactico.NuevoArbol( GramaticaCharByte );
          IF ImplementationIntentoInfructuosoNoPipe THEN BEGIN
            BanderaSalidaError          := TRUE;
            GOTO SalidaError;
          END;  { IF ImplementationIntentoInfructuosoNoPipe }
        END;            { IF ...VerificarIdentificadorBasico ELSE }
        ( PivoteArbol as CAFE_NudoSintacticoString ).
              EjecutarOrdenHoja( OrdenPipe,
                      ( Administrador as CAFE_TriplePipeMemory ).
                      ConteoPrincipalRenglon,
                      ConteoRenglonActual,
                      InterfaceManejadorActivo );
        FreeAndNil( PivoteArbol );
      END;  { IF GramaticaCharByte.Ocupado <> 0 }
    END;  { WITH MyManejador }
SalidaError :
    IF BanderaSalidaError THEN BEGIN
        IF CAFE_PosicionInfructuosoSintactico <> 0 THEN BEGIN
          RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_PosicionInfructuosoSintactico,
                [ QuotedStr( CAFE_MensajeInfructuosoSintactico ) ] );
        END ELSE BEGIN  { IF CAFE_PosicionInfructuosoSintactico <> 0 ELSE }
          RAISE CAFE_PipeException.
              Create( ErrorREPO, CAFE_ErrorOrdenNoEntendida );
        END;            { IF CAFE_PosicionInfructuosoSintactico <> 0 ELSE }
    END;  { IF BanderaSalidaError }
    WHILE ( Administrador as CAFE_TriplePipeMemory ).
                StringsOutput.Count <> 0
    DO WriteLn( ( Administrador as CAFE_TriplePipeMemory ).PipeOutputText,
                ( Administrador as CAFE_TriplePipeMemory ).
                        StringsOutput.FIFOStrings );
    WHILE ( Administrador as CAFE_TriplePipeMemory ).
                StringsStdErr.Count <> 0
    DO WriteLn( ( Administrador as CAFE_TriplePipeMemory ).PipeStdErrText,
                ( Administrador as CAFE_TriplePipeMemory ).
                        StringsStdErr.FIFOStrings );
  END;  { IF InterfaceManejadorActivo = NIL }
  CAFE_MensajeInfructuoso.ClearMessage;
END;   { PROCEDURE CAFE_TCollectionManejadorString.EjecutarRenglonLoad }

FUNCTION    CAFE_TCollectionManejadorString.ReadItemID
  (     Ide                     : String        ) : CAFE_InterfaceBasico;
VAR
  PivoteRespuesta,
  MyItem                        : TCollectionItem;

BEGIN  { PROCEDURE CAFE_TCollectionManejadorString.ReadItemID }
  PivoteRespuesta               := NIL;
  FOR MyItem IN Self DO BEGIN
    WITH MyItem as CAFE_ManejadorBasico DO BEGIN
      IF Ide = DisplayNombre
      THEN PivoteRespuesta              := MyItem;
    END;  { WITH MyItem as CAFE_ManejadorBasico }
  END;  { FOR MyItem }
  //  El ultimo...
  //  Pues en un archivo Load que repita un nombre ya existente
  //  se supone que se accesa al ultimo creado
  IF PivoteRespuesta = NIL THEN BEGIN
    ReadItemID                  := NIL;
  END ELSE BEGIN  { IF PivoteRespuesta = NIL ELSE }
    ( PivoteRespuesta as CAFE_ManejadorBasico ).GetInterfaceByStr
        ( CAFE_GUIDInterfaceManejador, ReadItemID );
  END;            { IF PivoteRespuesta = NIL ELSE }
END;   { PROCEDURE CAFE_TCollectionManejadorString.ReadItemID }

FUNCTION    CAFE_TCollectionManejadorString.Leer_Actual
                                                : TStreamCollectionItem;
BEGIN  { FUNCTION CAFE_TCollectionManejadorString.Leer_Actual }
  Leer_Actual                   := InterfaceManejadorActivo.Actual;
END;   { FUNCTION CAFE_TCollectionManejadorString.Leer_Actual }

PROCEDURE   CAFE_TCollectionManejadorString.SetDisplayNameI
  (       MyName                : String                                );
BEGIN  { PROCEDURE CAFE_TCollectionManejadorString.SetDisplayNameI }
  InterfaceManejadorActivo.DisplayNombre        := MyName;
END;   { PROCEDURE CAFE_TCollectionManejadorString.SetDisplayNameI }

FUNCTION    CAFE_TCollectionManejadorString.
                        GetDisplayNameI                         : String;
BEGIN  { FUNCTION CAFE_TCollectionManejadorString.GetDisplayNameI }
  GetDisplayNameI               := InterfaceManejadorActivo.DisplayNombre;
END;   { FUNCTION CAFE_TCollectionManejadorString.GetDisplayNameI }

CONSTRUCTOR CAFE_TCollectionItemSave.Create
  (       ACollection           : TCollection                           );
{ override; }
BEGIN  { CONSTRUCTOR CAFE_TCollectionItemSave.Create }
  Inherited Create( ACollection );
  NombreItemSave                := '';
  ListaManejadoresSave          := TFPList.Create;
END;   { CONSTRUCTOR CAFE_TCollectionItemSave.Create }

  {$IFDEF       SILENCIAR       }
  {$HINTS       OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_TCollectionItemSave.IsPrimerAislado
  (       Manejador             : CAFE_InterfaceBasico          ) : Boolean;
{ virtual; }
VAR
  MyObject                      : TObject;

LABEL
  SalidaFalsa;

BEGIN  { FUNCTION CAFE_TCollectionItemSave.IsPrimerAislado }
  FOR Pointer( MyObject ) IN ListaManejadoresSave DO BEGIN
    IF MyObject = NIL THEN Continue;
    IF NOT( MyObject is CAFE_ManejadorBasico ) THEN GOTO SalidaFalsa;
    WITH MyObject as CAFE_ManejadorBasico DO BEGIN
      IF HojaDefault = NIL THEN GOTO SalidaFalsa;
      IF NOT( HojaAisladaCVDH IN HojaDefault.DescriptoresHoja  )
      THEN GOTO SalidaFalsa;
      IsPrimerAislado           := TRUE;
      Exit;
    END;  { WITH MyObject as CAFE_ManejadorBasico }
  END;  { FOR Pointer( MyObject ) }
SalidaFalsa :
  IsPrimerAislado               := FALSE;
END;   { FUNCTION CAFE_TCollectionItemSave.IsPrimerAislado }
  {$IFDEF       SILENCIAR       }
  {$HINTS       ON              }
  {$ENDIF                       }

  {$IFDEF       SILENCIAR       }
  {$HINTS       OFF             }
  {$ENDIF                       }
FUNCTION    CAFE_TCollectionItemSave.ContieneNombresDuplicados
  ( OUT   NombreDuplicado       : ShortString                   ) : Boolean;
{ virtual; }
VAR
  MyObject                      : TObject;
  MyList                        : TStringList;

LABEL
  SalidaVerdadera;

BEGIN  { FUNCTION CAFE_TCollectionItemSave.ContieneNombresDuplicados }
  MyList                        := TStringList.Create;
  NombreDuplicado               := '';
  MyList.Sorted                 := FALSE;
  FOR Pointer( MyObject ) IN ListaManejadoresSave DO BEGIN
    IF MyObject = NIL THEN Continue;
    IF NOT( MyObject is CAFE_ManejadorBasico ) THEN Continue;
    WITH MyObject as CAFE_ManejadorBasico DO BEGIN
      IF DisplayNombre = '' THEN GOTO SalidaVerdadera;
      IF MyList.IndexOf( DisplayNombre ) >= 0 THEN BEGIN
        GOTO SalidaVerdadera;
        NombreDuplicado         := DisplayNombre;
      END;  { IF MyLIsta.IndexOf( DisplayNombre ) }
      MyList.Add( DisplayNombre );
    END;  { WITH MyObject as CAFE_ManejadorBasico }
  END;  { FOR Pointer( MyObject ) }
  FreeAndNIL( MyList );
  ContieneNombresDuplicados     := FALSE;
  Exit;
SalidaVerdadera :
  FreeAndNIL( MyList );
  IF NombreDuplicado = '' THEN NombreDuplicado  := '''''';
  ContieneNombresDuplicados     := TRUE;
END;   { FUNCTION CAFE_TCollectionItemSave.ContieneNombresDuplicados }
  {$IFDEF       SILENCIAR       }
  {$HINTS       ON              }
  {$ENDIF                       }

DESTRUCTOR  CAFE_TCollectionItemSave.Destroy;
{ override; }
BEGIN  { DESTRUCTOR CAFE_TCollectionItemSave.Destroy }
  FreeAndNil( ListaManejadoresSave );
  NombreItemSave                := '';
  Inherited;
END;   { DESTRUCTOR CAFE_TCollectionItemSave.Destroy }

CONSTRUCTOR CAFE_TCollectionSave.Create
  (       AOwner                : TPersistent                           );
{ virtual; }
BEGIN  { CONSTRUCTOR CAFE_TCollectionSave.Create }
  Inherited Create( AOwner, CAFE_TipoCollectionSave );
END;   { CONSTRUCTOR CAFE_TCollectionSave.Create }

FUNCTION    CAFE_TCollectionSave.GrupoVacio
  ( CONST NombreGrupo           : ShortString                   ) : Boolean;
VAR
  MyElemento                    : TCollectionItem;
  MyPuntero                     : Pointer;

BEGIN  { FUNCTION CAFE_TCollectionSave.GrupoVacio }
  FOR MyElemento IN Self DO BEGIN
    WITH MyElemento as CAFE_TCollectionItemSave DO BEGIN
      IF NombreGrupo = NombreItemSave THEN BEGIN
        FOR MyPuntero IN ListaManejadoresSave
        DO IF MyPuntero <> NIL THEN Exit( FALSE );
        Exit( TRUE );
      END;  { IF NombreGrupo = NombreItemSave }
    END;  { WITH MyElemento }
  END;  { FOR MyElemento }
  GrupoVacio                    := TRUE;
END;   { FUNCTION CAFE_TCollectionSave.GrupoVacio }

  { IMPLEMENTATION }
VAR
  ImplementationNumeroNuevoGrupo        : LongInt               = 0;
  // El numero no importa simplemente, se quiere identificadores diferentes
  { IMPLEMENTATION }

FUNCTION    CAFE_TCollectionSave.GenerarNuevoNombreGrupo        : ShortString;
VAR
  PivoteNombre                          : ShortString;

BEGIN  { FUNCTION CAFE_TCollectionSave.GenerarNuevoNombreGrupo }
  REPEAT
    Inc( ImplementationNumeroNuevoGrupo );
    PivoteNombre                        :=
                Format( 'GRUPO%.*d', [ 3, ImplementationNumeroNuevoGrupo ] );
  UNTIL BuscarNombreGrupoSave( PivoteNombre ) = NIL;
  GenerarNuevoNombreGrupo               := PivoteNombre;
END;   { FUNCTION CAFE_TCollectionSave.GenerarNuevoNombreGrupo }

FUNCTION    CAFE_TCollectionSave.BuscarNombreGrupoSave
  ( CONST NombreGrupo           : ShortString   ) : CAFE_TCollectionItemSave;
VAR
  PivoteRespuesta,
  MyElemento                    : TCollectionItem;

BEGIN  { FUNCTION CAFE_TCollectionSave.BuscarNombreGrupoSave }
  PivoteRespuesta               := NIL;
  FOR MyElemento IN Self DO BEGIN
    WITH MyElemento as CAFE_TCollectionItemSave DO BEGIN
      IF NombreGrupo = NombreItemSave
      THEN PivoteRespuesta      := MyElemento;
    END;  { WITH MyElemento }
  END;  { FOR MyElemento }
  BuscarNombreGrupoSave         :=
                        PivoteRespuesta as CAFE_TCollectionItemSave;
END;   { FUNCTION CAFE_TCollectionSave.BuscarNombreGrupoSave }

FUNCTION    CAFE_TCollectionSave.BuscarGrupoSaveManejador
  (       MyManejadorBasico     : CAFE_ManejadorBasico
                                                ) : CAFE_TCollectionItemSave;
VAR
  MyElemento                    : TCollectionItem;
  PivotePos                     : LongInt;

BEGIN  { FUNCTION CAFE_TCollectionSave.BuscarGrupoSaveManejador }
  FOR MyElemento IN Self DO BEGIN
    WITH MyElemento as CAFE_TCollectionItemSave DO BEGIN
      PivotePos                 := ListaManejadoresSave.
                                        IndexOf( Pointer( MyManejadorBasico ) );
      IF PivotePos >= 0 THEN BEGIN
        BuscarGrupoSaveManejador                :=
                        MyElemento as CAFE_TCollectionItemSave;
        Exit;
      END;  { IF PivotePos >= 0 }
    END;  { WITH MyElemento }
  END;  { FOR MyElemento }
  BuscarGrupoSaveManejador      := NIL;
END;   { FUNCTION CAFE_TCollectionSave.BuscarGrupoSaveManejador }

PROCEDURE   CAFE_TCollectionSave.AgregarManejadorBasicoGrupoSave
  ( CONST NombreGrupo           : ShortString;
          MyManejadorBasico     : CAFE_ManejadorBasico                  );
VAR
  MyElemento                    : TCollectionItem;

BEGIN  { PROCEDURE CAFE_TCollectionSave.AgregarManejadorBasicoGrupoSave }
  MyElemento                    := BuscarNombreGrupoSave( NombreGrupo );
  IF MyManejadorBasico = NIL
  THEN RAISE CAFE_PipeHaltException.Create( 'NIL no sirve como traductor' );
  IF MyElemento = NIL
  THEN RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorNombreGrupoSaveInexistente,
                                        [ QuotedStr( NombreGrupo ) ] );
  EliminarManejadorBasicoTodoGrupoSave( MyManejadorBasico );
  ( MyElemento as CAFE_TCollectionItemSave ).
      ListaManejadoresSave.Add( Pointer( MyManejadorBasico ) );
END;   { PROCEDURE CAFE_TCollectionSave.AgregarManejadorBasicoGrupoSave }

PROCEDURE   CAFE_TCollectionSave.AgregarManejadorBasicoGrupoSaveVinculado
  ( CONST NombreGrupo           : ShortString;
          MyManejadorBasico     : CAFE_ManejadorBasico                  );
VAR
  MyManejadorPivote             : TObject;
  MyElemento                    : TCollectionItem;

BEGIN  { PROCEDURE ...AgregarManejadorBasicoGrupoSaveVinculado }
  MyElemento                    := BuscarNombreGrupoSave( NombreGrupo );
  IF MyManejadorBasico = NIL
  THEN RAISE CAFE_PipeHaltException.Create( 'NIL no sirve como traductor' );
  IF MyElemento = NIL
  THEN RAISE CAFE_PipeException.Create
                ( ErrorREPO, CAFE_ErrorNombreGrupoSaveInexistente,
                                        [ QuotedStr( NombreGrupo ) ] );
  FOR Pointer( MyManejadorPivote ) IN
        ( MyElemento as CAFE_TCollectionItemSave ).ListaManejadoresSave
  DO BEGIN
    IF MyManejadorPivote <> NIL THEN BEGIN
      // NIL deberia ser imposible
      IF MyManejadorPivote is CAFE_ManejadorBasicoString
      THEN BEGIN
        IF ( ( MyManejadorPivote as CAFE_ManejadorBasicoString ).
               DisplayNombre = MyManejadorBasico.DisplayNombre )
        THEN RAISE CAFE_PipeException.Create
                        ( ErrorREPO,
                          CAFE_ErrorNombreDuplicadoHojaTrabajoEnGrupo,
                          [ QuotedStr( MyManejadorBasico.DisplayNombre ),
                            QuotedStr( NombreGrupo ) ] );
      END;  { IF MyManejadorPivote as MGGE_}
    END;  { IF MyManejadorPivote <> NIL }
  END;  { FOR Pointer( MyManejadorPivote ) IN... }
  EliminarManejadorBasicoTodoGrupoSaveVinculado( MyManejadorBasico );
  ( MyElemento as CAFE_TCollectionItemSave ).
      ListaManejadoresSave.Add( Pointer( MyManejadorBasico ) );
  FOR Pointer( MyManejadorPivote ) IN
      ( MyElemento as CAFE_TCollectionItemSave ).ListaManejadoresSave
  DO BEGIN
    IF ( MyManejadorPivote <> NIL ) AND
       ( MyManejadorPivote <> MyManejadorBasico ) THEN BEGIN
      // NIL deberia ser imposible
      IF MyManejadorPivote is CAFE_ManejadorBasicoString
      THEN BEGIN
        IF NOT( ( MyManejadorPivote as CAFE_ManejadorBasicoString ).
            VincularPaquete( MyManejadorBasico.DisplayNombre,
              MyManejadorBasico.ID ) )
        THEN RAISE CAFE_PipeException.Create
              ( ErrorREPO, CAFE_ErrorNoPudoVincularseHojasTrabajoEnGrupo,
                        [ QuotedStr( MyManejadorBasico.DisplayNombre ),
        QuotedStr( ( MyManejadorPivote as CAFE_ManejadorBasicoString ).
              DisplayNombre ), QuotedStr( NombreGrupo ) ] );
        IF NOT( MyManejadorBasico.VincularPaquete(
  ( MyManejadorPivote as CAFE_ManejadorBasicoString ).DisplayNombre,
  ( MyManejadorPivote as CAFE_ManejadorBasicoString ).ID ) )
        THEN RAISE CAFE_PipeException.Create
              ( ErrorREPO, CAFE_ErrorNoPudoVincularseHojasTrabajoEnGrupo,
        [ QuotedStr( ( MyManejadorPivote as CAFE_ManejadorBasicoString ).
                          DisplayNombre ),
                          QuotedStr( MyManejadorBasico.DisplayNombre ),
                          QuotedStr( NombreGrupo ) ] );
      END;  { IF MyManejadorPivote as MGGE_}
    END;  { IF MyManejadorPivote <> NIL }
  END;  { FOR Pointer( MyManejadorPivote ) IN ... ) }
END;   { PROCEDURE ...AgregarManejadorBasicoGrupoSaveVinculado }

PROCEDURE   CAFE_TCollectionSave.EliminarManejadorBasicoTodoGrupoSave
  (       MyManejadorBasico     : CAFE_ManejadorBasico                  );
VAR
  MyElemento                    : TCollectionItem;
  PivoteItem                    : LongInt;

BEGIN  { PROCEDURE CAFE_TCollectionSave.EliminarManejadorBasicoTodoGrupoSave }
  FOR MyElemento IN Self DO BEGIN
    WITH MyElemento as CAFE_TCollectionItemSave DO BEGIN
      PivoteItem                :=
                ListaManejadoresSave.IndexOf( Pointer( MyManejadorBasico ) );
      IF PivoteItem >= 0
      THEN ListaManejadoresSave.Delete( PivoteItem );
    END;  { FOR MyElemento as CAFE_TCollectionItemSave }
  END;  { FOR MyElemento }
END;   { PROCEDURE CAFE_TCollectionSave.EliminarManejadorBasicoTodoGrupoSave }

PROCEDURE   CAFE_TCollectionSave.EliminarManejadorBasicoTodoGrupoSaveVinculado
  (       MyManejadorBasico     : CAFE_ManejadorBasico                  );
VAR
  MyElemento                    : TCollectionItem;
  MyManejadorPivote             : TObject;
  PivoteItem                    : LongInt;

BEGIN  { PROCEDURE ...EliminarManejadorBasicoTodoGrupoSaveVinculado }
  FOR MyElemento IN Self DO BEGIN
    WITH MyElemento as CAFE_TCollectionItemSave DO BEGIN
      PivoteItem                :=
                ListaManejadoresSave.IndexOf( Pointer( MyManejadorBasico ) );
      IF PivoteItem >= 0 THEN BEGIN
        ListaManejadoresSave.Delete( PivoteItem );
        FOR Pointer( MyManejadorPivote ) IN ListaManejadoresSave DO BEGIN
          IF MyManejadorPivote <> NIL THEN BEGIN
            IF MyManejadorPivote is CAFE_ManejadorBasicoString THEN BEGIN
              ( MyManejadorPivote as CAFE_ManejadorBasicoString ).
                       DesVincularPaquete(
                         MyManejadorBasico.DisplayNombre,
                         MyManejadorBasico.ID );
            END;  { IF MyManejadorPivote is CAFE_ManejadorBasicoString }
          END;  { IF MyManejadorPivote <> NIL }
        END;  { FOR Pointer( MyManejadorPivote ) }
      END;  { IF PivoteItem >= 0 }
    END;  { FOR MyElemento as CAFE_TCollectionItemSave }
  END;  { FOR MyElemento }
  ( MyManejadorBasico as CAFE_ManejadorBasicoString ).DesvincularTodoPaquete;
END;   { PROCEDURE ...EliminarManejadorBasicoTodoGrupoSaveVinculado }

DESTRUCTOR  CAFE_TCollectionSave.Destroy;
{ override; }
BEGIN  { DESTRUCTOR CAFE_TCollectionSave.Destroy }
  Inherited;
END;   { DESTRUCTOR CAFE_TCollectionSave.Destroy }

FUNCTION    CAFE_ConstToString
  (       MyData        : ARRAY OF CONST                ) : TStringDynArray;
VAR
  PivoteDyn             : TStringDynArray;
  RecorreData           : LongInt;

BEGIN  { FUNCTION CAFE_ConstToString }
  SetLength( PivoteDyn, Length( MyData ) );
  FOR RecorreData := Low( MyData ) TO High( MyData ) DO BEGIN
    PivoteDyn[ RecorreData ]            :=
                        PChar( MyData[ RecorreData ].VString );
  END;  { FOR RecorreData }
  CAFE_ConstToString    := PivoteDyn;
END;   { FUNCTION CAFE_ConstToString }

CONSTRUCTOR CAFE_InterpreteSintacticoString.Create;
BEGIN  { CONSTRUCTOR CAFE_InterpreteSintacticoString.Create }
  Inherited Create;
  InterpreteReferencia          := CAFE_InterpreteSintacticoString;
END;   { CONSTRUCTOR CAFE_InterpreteSintacticoString.Create }

CONSTRUCTOR CAFE_InterpreteSintacticoString.Create
  ( CONST Nombre                : ShortString;
          NuevoValor            : Variant                               );
BEGIN  { CONSTRUCTOR CAFE_InterpreteSintacticoString.Create }
  Inherited Create( Nombre, NuevoValor );
  InterpreteReferencia          := CAFE_InterpreteSintacticoString;
END;   { CONSTRUCTOR CAFE_InterpreteSintacticoString.Create }

PROCEDURE   CAFE_InterpreteSintacticoString.
                        ReinicioPaquetePredefinido;
{ virtual; }
BEGIN  { PROCEDURE ...ReinicioPaquetePredefinido }
  IF ( [ PredefinidoNITI, ManejadorPrincipalNITI ]
                        *DescriptorInterprete ) = []
  THEN Exclude( DescriptorInterprete, ActivoNITI );
  IF SiguienteIdentificador <> NIL
  THEN ( SiguienteIdentificador as CAFE_InterpreteSintacticoString ).
                ReinicioPaquetePredefinido;
END;   { PROCEDURE ...ReinicioPaquetePredefinido }

PROCEDURE   CAFE_InterpreteSintacticoString.DefaultPredefinidos
  (       Manejador             : CAFE_InterfaceBasico;
          Quimico               : Boolean;
          Graficador            : Boolean       = FALSE         );
{ override; }
BEGIN  { PROCEDURE CAFE_InterpreteSintacticoString.DefaultPredefinidos }
  Inherited;
  WITH Manejador.Actual as CAFE_ManejadorBasico DO BEGIN
    PaqueteIdioma.Add( 'NEWSAVEGROUP'+
        CAFE_NameValueSeparator+CAFE_OrdenNuevoGrupoSave );
    PaqueteIdioma.Add( 'NEWSPREADSHEET()'+
        CAFE_NameValueSeparator+CAFE_OrdenCrearHojaTrabajo );
    PaqueteIdioma.Add( 'DELETESPREADSHEET()'+
        CAFE_NameValueSeparator+CAFE_OrdenDestruirHojaTrabajo );
    PaqueteIdioma.Add( 'DELETESAVEGROUP()'+
        CAFE_NameValueSeparator+CAFE_OrdenDestruirGrupoSave );
    PaqueteIdioma.Add( 'ACTIVATESPREADSHEET()'+
        CAFE_NameValueSeparator+CAFE_OrdenActivarHojaTrabajo );
    PaqueteIdioma.Add( 'ACTIVATESAVEGROUP()'+
        CAFE_NameValueSeparator+CAFE_OrdenActivarGrupoSave );
    PaqueteIdioma.Add( 'DESCRIBESHEET()'+
        CAFE_NameValueSeparator+CAFE_OrdenDescribirHoja );
    PaqueteIdioma.Add( 'CURRENTDESCRIBESHEET'+
        CAFE_NameValueSeparator+CAFE_OrdenActualDescriptorHoja );
    PaqueteIdioma.Add( 'SAVESHEET()'+
        CAFE_NameValueSeparator+CAFE_OrdenSaveHojaTrabajo );
    PaqueteIdioma.Add( 'LOADSHEET()'+
        CAFE_NameValueSeparator+CAFE_OrdenLoadHojaTrabajo );
    PaqueteIdioma.Add( 'CURRENTHANDLE'+
        CAFE_NameValueSeparator+CAFE_OrdenActualManejador );
    PaqueteIdioma.Add( 'CURRENTSAVEGROUP'+
        CAFE_NameValueSeparator+CAFE_OrdenActualGrupoSave );
    PaqueteIdioma.Add( 'LISTHANDLES()'+
        CAFE_NameValueSeparator+CAFE_OrdenListaManejadores );
    PaqueteIdioma.Add( 'LISTEVERYHANDLES'+
        CAFE_NameValueSeparator+CAFE_OrdenListaManejadoresTotal );
    PaqueteIdioma.Add( 'LISTEVERYSAVEGROUP'+
        CAFE_NameValueSeparator+CAFE_OrdenListaGruposSave );
    PaqueteIdioma.Add( 'ADDSHEET()'+
        CAFE_NameValueSeparator+CAFE_OrdenAgregarHojaGrupoSave );
    PaqueteIdioma.Add( 'SEEFUNCTION'+
        CAFE_NameValueSeparator+CAFE_OrdenVerFuncional );
    PaqueteIdioma.Add( 'SEEPROBEVALUE'+
        CAFE_NameValueSeparator+CAFE_OrdenVerValorPrueba );
    PaqueteIdioma.Add( 'EVERYCYCLEPROHIBITED'+
        CAFE_NameValueSeparator+CAFE_OrdenTodoCicloProhibido );
    PaqueteIdioma.Add( 'BLOCKCELLS'+
        CAFE_NameValueSeparator+CAFE_OrdenBloquearCasillas );
    PaqueteIdioma.Add( 'ISOLATEDSHEET'+
        CAFE_NameValueSeparator+CAFE_OrdenHojaAislada );
    PaqueteIdioma.Add( 'REQUESTCALCULUSOBLIGATED'+
        CAFE_NameValueSeparator+CAFE_OrdenPeticionCalculoObligatorio );
    PaqueteIdioma.Add( 'FORCECALCULUSPROPAGATED'+
        CAFE_NameValueSeparator+CAFE_OrdenForzarRecalculoTotal );
    PaqueteIdioma.Add( 'ISOLATED'+
        CAFE_NameValueSeparator+'AISLADO' );
    PaqueteIdioma.Add( 'VALUE'+
        CAFE_NameValueSeparator+'VALOR' );
    PaqueteIdioma.Add( 'RECURSIVE'+
        CAFE_NameValueSeparator+'RECURSIVA' );
    PaqueteIdioma.Add( 'EVALUATE'+
        CAFE_NameValueSeparator+'EVALUAR' );
    PaqueteIdioma.Add( 'RECURSIVEERROR'+
        CAFE_NameValueSeparator+'RECURSIVAERROR' );
    PaqueteIdioma.Add( 'ANYTYPE'+
        CAFE_NameValueSeparator+'CUALQUIERTIPO' );
    PaqueteIdioma.Add( 'COPYRANGE()'+
        CAFE_NameValueSeparator+CAFE_OrdenCopiarCasillas );
    PaqueteIdioma.Add( 'FASTTWIN'+
        CAFE_NameValueSeparator+CAFE_OrdenUndoSeguridad );
    PaqueteIdioma.Add( 'UNDO()'+
        CAFE_NameValueSeparator+CAFE_OrdenUndo );
    PaqueteIdioma.Add( 'UNDOLEVELS()'+
        CAFE_NameValueSeparator+CAFE_OrdenNivelesUndo );
    PaqueteIdioma.Add( 'UNDOLEVELSTOTAL'+
        CAFE_NameValueSeparator+CAFE_OrdenTotalNivelesUndo );
    PaqueteIdioma.Add( 'RECALCULATE'+
        CAFE_NameValueSeparator+CAFE_OrdenRecalculo );
    PaqueteIdioma.Add( 'RECALCULATEWITHERRORS()'+
        CAFE_NameValueSeparator+CAFE_OrdenRecalculoConErrores );
    PaqueteIdioma.Add( 'MODOSIMULATECALCULUS'+
        CAFE_NameValueSeparator+CAFE_OrdenModoSimularCalculo );
    PaqueteIdioma.Add( 'ENABLEONECYCLE'+
        CAFE_NameValueSeparator+CAFE_OrdenHabilitarUnCiclo );
    PaqueteIdioma.Add( 'POINTSPRELIMINARYSOLVE()'+
        CAFE_NameValueSeparator+CAFE_OrdenRaizPreliminar );
    PaqueteIdioma.Add( 'MAXINTEGRALCYCLES()'+
        CAFE_NameValueSeparator+CAFE_OrdenMaximoCiclosIntegral );
    PaqueteIdioma.Add( 'MAXINTERNALINTEGRALCYCLES()'+
        CAFE_NameValueSeparator+CAFE_OrdenMaximoCiclosIntegralInterna );
    PaqueteIdioma.Add( 'EPSILONZERO()'+
        CAFE_NameValueSeparator+CAFE_OrdenEpsilonZero );
    PaqueteIdioma.Add( 'EPSILONDETERMINANTZERO()'+
        CAFE_NameValueSeparator+CAFE_OrdenEpsilonZeroDeterminante );
    PaqueteIdioma.Add( 'GENERALVARIABLE()'+
        CAFE_NameValueSeparator+CAFE_OrdenVariableGeneral );
    PaqueteIdioma.Add( 'CURRENTGENERALVARIABLE()'+
        CAFE_NameValueSeparator+CAFE_OrdenActualVariableGeneral );
    PaqueteIdioma.Add( 'POINTSPRELIMINARYSOLVE'+
        CAFE_NameValueSeparator+'PUNTOSRAIZPRELIMINAR' );
    PaqueteIdioma.Add( 'MAXINTEGRALCYCLES'+
        CAFE_NameValueSeparator+'MAXIMOCICLOSINTEGRAL' );
    PaqueteIdioma.Add( 'MAXINTERNALINTEGRALCYCLES'+
        CAFE_NameValueSeparator+'MAXIMOCICLOSINTEGRALINTERNA' );
    PaqueteIdioma.Add( 'EPSILONZERO'+
        CAFE_NameValueSeparator+'EPSILONCERO' );
    PaqueteIdioma.Add( 'EPSILONDETERMINANTZERO'+
        CAFE_NameValueSeparator+'EPSILONDETERMINANTECERO' );
    PaqueteIdioma.Add( 'ROWSINSHEET'+
        CAFE_NameValueSeparator+'FILASENHOJA' );
    PaqueteIdioma.Add( 'COLUMNSINSHEET'+
        CAFE_NameValueSeparator+'COLUMNASENHOJA' );
    PaqueteIdioma.Add( 'INITIATIVERANGE()'+
        CAFE_NameValueSeparator+CAFE_OrdenCasillaIniciativa );
    PaqueteIdioma.Add( 'CYCLICRANGE()'+
        CAFE_NameValueSeparator+CAFE_OrdenCasillaCiclica );
    PaqueteIdioma.Add( 'FORMATRANGE()'+
        CAFE_NameValueSeparator+CAFE_OrdenFormatoCasilla );
    PaqueteIdioma.Add( 'NULLRANGE()'+
        CAFE_NameValueSeparator+CAFE_OrdenCasillaNull );
    PaqueteIdioma.Add( 'MOVERANGE()'+
        CAFE_NameValueSeparator+CAFE_OrdenMoverCasillas );
    PaqueteIdioma.Add( 'NULLLINE()'+
        CAFE_NameValueSeparator+CAFE_OrdenFilaNull );
    PaqueteIdioma.Add( 'DELETELINE()'+
        CAFE_NameValueSeparator+CAFE_OrdenEliminarFila );
    PaqueteIdioma.Add( 'INSERTLINE()'+
        CAFE_NameValueSeparator+CAFE_OrdenInsertarFila );
    PaqueteIdioma.Add( 'NULLCOLUMN()'+
        CAFE_NameValueSeparator+CAFE_OrdenColumnaNull );
    PaqueteIdioma.Add( 'DELETECOLUMN()'+
        CAFE_NameValueSeparator+CAFE_OrdenEliminarColumna );
    PaqueteIdioma.Add( 'INSERTCOLUMN()'+
        CAFE_NameValueSeparator+CAFE_OrdenInsertarColumna );
    PaqueteIdioma.Add( 'TO$TEMPORAL()'+
        CAFE_NameValueSeparator+CAFE_OrdenHaciaTemporal );
    PaqueteIdioma.Add( 'FROM$TEMPORAL()'+
        CAFE_NameValueSeparator+CAFE_OrdenDesdeTemporal );
    PaqueteIdioma.Add( 'SPREADSHEETRESET'+
        CAFE_NameValueSeparator+CAFE_OrdenHojaReinicio );
    PaqueteIdioma.Add( 'CELLTOSTRING()'+
        CAFE_NameValueSeparator+CAFE_OrdenCasillaATexto );
    PaqueteIdioma.Add( 'QUIT'+
        CAFE_NameValueSeparator+CAFE_OrdenSALIDA );
    PaqueteIdioma.Add( 'READRANGE()'+
        CAFE_NameValueSeparator+CAFE_OrdenLeerCasillas );
    PaqueteIdioma.Add( 'RANGETOARCHIVE()'+
        CAFE_NameValueSeparator+CAFE_OrdenCasillasAArchivo );
  END;  { WITH Manejador.Actual }
END;   { PROCEDURE CAFE_InterpreteSintacticoString.DefaultPredefinidos }

DESTRUCTOR  CAFE_InterpreteSintacticoString.Destroy;
BEGIN  { DESTRUCTOR CAFE_InterpreteSintacticoString.Destroy }
  Inherited Destroy;
END;   { DESTRUCTOR CAFE_InterpreteSintacticoString.Destroy }

INITIALIZATION
  CAFE_TipoCollectionSave       := CAFE_TCollectionItemSave;
  CAFE_MoldeManejadorArbol      := CAFE_NudoSintacticoString;
  CAFE_MoldeManejadorPaquete    := CAFE_InterpreteSintacticoString;
  CAFE_MoldeManejadorDatoCasilla                := CAFE_DatoNudilladoString;
  CAFE_TipoCollectionPrincipal  := CAFE_TCollectionManejadorString;
  CAFE_TipoManejadorAsignado    := CAFE_ManejadorBasicoString;
  CAFE_TipoHojaAsignado         := CAFE_HojaCalculoString;
  CAFE_ReferenciaApplication    := CAFE_TriplePipeMemory;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    OFF             }
  {$ENDIF                       }
  CAFE_4ErrorHojaTrabajoInactiva        := CAFE_ErrorHojaTrabajoInactiva;
  CAFE_4ErrorOrdenRequiereHojaTrabajo   := CAFE_ErrorOrdenRequiereHojaTrabajo;
  CAFE_4ErrorMecanismoUndoDesactivadoHojaTrabajo        :=
                CAFE_ErrorMecanismoUndoDesactivadoHojaTrabajo;
  CAFE_4ErrorPosibleIncompatibilidadVersion             :=
                CAFE_ErrorPosibleIncompatibilidadVersion;
  CAFE_4ErrorDatoFueraRangoAdmisible    := CAFE_ErrorDatoFueraRangoAdmisible;
  CAFE_4ErrorDeterminanteNulo           := CAFE_ErrorDeterminanteNulo;
  CAFE_4ErrorGramaticaOperadoresCadenaError             :=
                        CAFE_ErrorGramaticaOperadoresCadenaError;
  CAFE_4ErrorGramaticaOperadoresGeneral                 :=
                        CAFE_ErrorSintaxisGeneral;
  CAFE_2ErrorNudilladoGeneral                           :=
                        CAFE_ErrorSintaxisGeneral;
  CAFE_4ErrorAlEvaluarEnLugar                           :=
                        CAFE_ErrorAlEvaluarEnLugar;
  CAFE_4ErrorNudilladoGeneral                           :=
                        CAFE_ErrorSintaxisGeneral;
  CAFE_4ErrorExcesoParentesisCerrados                   :=
                        CAFE_ErrorExcesoParentesisCerrados;
  CAFE_4ErrorLlamadaCiclica                             :=
                        CAFE_ErrorLlamadaCiclica;
  CAFE_4ErrorMacroSinParametros                         :=
                        CAFE_ErrorMacroSinParametros;
  CAFE_4ErrorVarErrorEvaluar                            :=
                        CAFE_ErrorVarErrorEvaluar;
  CAFE_4ErrorEstiloRecursivoIndefinido                  :=
                        CAFE_ErrorEstiloRecursivoIndefinido;
  CAFE_4ErrorFinCicloPendiente                          :=
                        CAFE_ErrorFinCicloPendiente;
  CAFE_4ErrorVarErrorInterpretar                        :=
                        CAFE_ErrorVarErrorInterpretar;
  CAFE_4ErrorDescriptorDimensionalInconsistente         :=
                        CAFE_ErrorDescriptorDimensionalInconsistente;
  CAFE_4ErrorMatrizAnalisisNumericoMuyGrande            :=
                        CAFE_ErrorMatrizAnalisisNumericoMuyGrande;
  CAFE_4ErrorIntegralNoRealizada                        :=
                        CAFE_ErrorIntegralNoRealizada;
  CAFE_4ErrorDefinirSectorRectangular                   :=
                        CAFE_ErrorDefinirSectorRectangular;
  CAFE_4ErrorMacroRecibeArgumentosReales                :=
                        CAFE_ErrorMacroRecibeArgumentosReales;
  CAFE_4ErrorCopiaProvocaRangoNoPermitido               :=
                        CAFE_ErrorCopiaProvocaRangoNoPermitido;
  CAFE_4ErrorCopiaNoPermitidaGeneral                    :=
                        CAFE_ErrorCopiaNoPermitidaGeneral;
  CAFE_4ErrorNoPudoEvaluarValoresInicialesCopiaMacro    :=
                        CAFE_ErrorNoPudoEvaluarValoresInicialesCopiaMacro;
  CAFE_4ErrorIrregularAccesoCasilla                     :=
                        CAFE_ErrorIrregularAccesoCasilla;
  CAFE_4ErrorIntegralSuperoTotalCiclos                  :=
                        CAFE_ErrorIntegralSuperoTotalCiclos;
  CAFE_4ErrorMacroResultadoNoReal                       :=
                        CAFE_ErrorMacroResultadoNoReal;
  CAFE_4ErrorParametrosSubOrden                         :=
                        CAFE_ErrorParametrosSubOrden;
  CAFE_1ErrorFaltaFinComentario                         :=
                        CAFE_ErrorFaltaFinComentario;
  CAFE_1ErrorFaltaFinString                             :=
                        CAFE_ErrorFaltaFinString;
  CAFE_1ErrorStringGeneral                              :=
                        CAFE_ErrorStringGeneral;
  CAFE_3ErrorSintaxisAsignacionGeneral                  :=
                        CAFE_ErrorSintaxisAsignacionGeneral;

  CAFE_3ErrorSintaxisJustificadoresWrite                :=
                        CAFE_ErrorSintaxisJustificadoresWrite;
  CAFE_2ErrorNudilladoSubOrden                          :=
                        CAFE_ErrorNudilladoSubOrden;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorError,
                       CAFE_SError ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorStringMalDefinida,
                       CAFE_SStringMalDefinida ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorTipoVarianteIncompatible,
                       CAFE_STipoVarianteIncompatible ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorPosibleIncompatibilidadVersion,
                       CAFE_SPosibleIncompatibilidadVersion ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorFormatoIncompatiblePendiente,
                       CAFE_SFormatoIncompatiblePendiente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDescriptorCasillaIncompatible,
                       CAFE_SDescriptorCasillaIncompatible ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorVarErrorEvaluar,
                       CAFE_SVarErrorEvaluar ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorIdentificadorInvalido,
                       CAFE_SIdentificadorInvalido ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorVarErrorInterpretar,
                       CAFE_SVarErrorInterpretar ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorOrdenNoEntendida,
                       CAFE_SOrdenNoEntendida ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorFaltanParametrosEnOperador,
                       CAFE_SFaltanParametrosEnOperador ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorIdentificadorRequiereHojaTrabajo,
                       CAFE_SIdentificadorRequiereHojaTrabajo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorOrdenRequiereHojaTrabajo,
                       CAFE_SOrdenRequiereHojaTrabajo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorNombreHojaTrabajoPendiente,
                       CAFE_SNombreHojaTrabajoPendiente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorNombreGrupoSaveInexistente,
                       CAFE_SNombreGrupoSaveInexistente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDatoStringPendiente,
                       CAFE_SDatoStringPendiente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorTotalDatosEquivocadoOrden,
                       CAFE_STotalDatosEquivocadoOrden ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( FracasoREPO, CAFE_FracasoNoPudoAbrirArchivo,
                       CAFE_SFracasoNoPudoAbrirArchivo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( FracasoREPO, CAFE_FracasoNoPudoCrearArchivo,
                       CAFE_SFracasoNoPudoCrearArchivo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDatoEnteroPendiente,
                       CAFE_SDatoEnteroPendiente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorSelectorAlternativaPendiente,
                       CAFE_SSelectorAlternativaPendiente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( FracasoREPO, CAFE_FracasoArchivoTXTPendiente,
                       CAFE_SFracasoArchivoTXTPendiente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( FatalREPO, CAFE_FatalSuperoCapacidadErroresArchivo,
                       CAFE_SFatalSuperoCapacidadErroresArchivo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( FatalREPO, CAFE_FatalErroresNoPermitidosLoad,
                       CAFE_SFatalErroresNoPermitidosLoad ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( DescartadoLoadREPO, CAFE_DescartadoLoadInterrumpidoArchivo,
                       CAFE_SDescartadoLoadInterrumpidoArchivo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( FatalREPO, CAFE_FatalInterrumpidoLoadArchivo,
                       CAFE_SFatalInterrumpidoLoadArchivo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorStringIdentificadorValido,
                       CAFE_SStringIdentificadorValido ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDimensionesInaceptablesHojaTrabajo,
                       CAFE_SDimensionesInaceptablesHojaTrabajo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorNombreDuplicadoHojaTrabajoEnGrupo,
                       CAFE_SNombreDuplicadoHojaTrabajoEnGrupo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorNoPudoVincularseHojasTrabajoEnGrupo,
            CAFE_SNoPudoVincularseHojasTrabajoEnGrupo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorNombreHojaTrabajoInexistente,
            CAFE_SNombreHojaTrabajoInexistente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorNoConcordanciaNombreHojaTrabajoControl,
            CAFE_SNoConcordanciaNombreHojaTrabajoControl ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorHojaTrabajoCareceGrupoSaveAsignado,
            CAFE_SHojaTrabajoCareceGrupoSaveAsignado ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoHojaTrabajo,
            CAFE_SAccesoNoPermitidoHojaTrabajo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorAccesoNoPermitidoGrupoSave,
            CAFE_SAccesoNoPermitidoGrupoSave ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDatoIdentificadorCasillaPendiente,
            CAFE_SDatoIdentificadorCasillaPendiente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( ResultREPO, CAFE_ResultVarError,
                       CAFE_SResultVarError ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorHojaTrabajoInactiva,
            CAFE_SHojaTrabajoInactiva ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorCasillaBloqueadaHojaTrabajo,
            CAFE_SCasillaBloqueadaHojaTrabajo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorRangoSolicitadoNoPermitidoEnCopia,
            CAFE_SRangoSolicitadoNoPermitidoEnCopia ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( FatalREPO, CAFE_FatalProcesoCopiaCasillasInterrumpido,
              CAFE_SFatalProcesoCopiaCasillasInterrumpido ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorMecanismoUndoDesactivadoHojaTrabajo,
            CAFE_SMecanismoUndoDesactivadoHojaTrabajo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDatoFueraRangoAdmisible,
            CAFE_SDatoFueraRangoAdmisible ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensaje
          ( AlertaREPO, CAFE_AlertaMecanismoUndoRequiereHojaTrabajo,
              CAFE_SAlertaMecanismoUndoRequiereHojaTrabajo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDatoRealPendiente,
                       CAFE_SDatoRealPendiente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorTipoInadecuadoDatoVariableGlobal,
                       CAFE_STipoInadecuadoDatoVariableGlobal ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDeterminanteNulo,
                       CAFE_SDeterminanteNulo ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorGramaticaOperadoresCadenaError,
                       CAFE_SGramaticaOperadoresCadenaError ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorSintaxisGeneral,
                       CAFE_SSintaxisGeneral ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorAlEvaluarEnLugar,
                       CAFE_SAlEvaluarEnLugar ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorExcesoParentesisCerrados,
                       CAFE_SExcesoParentesisCerrados ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorLlamadaCiclica,
                       CAFE_SLlamadaCiclica ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorMacroSinParametros,
                       CAFE_SMacroSinParametros ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorEstiloRecursivoIndefinido,
                       CAFE_SEstiloRecursivoIndefinido ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorFinCicloPendiente,
                       CAFE_SFinCicloPendiente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDescriptorDimensionalInconsistente,
                       CAFE_SDescriptorDimensionalInconsistente ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorMatrizAnalisisNumericoMuyGrande,
                       CAFE_SMatrizAnalisisNumericoMuyGrande ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorIntegralNoRealizada,
                       CAFE_SIntegralNoRealizada ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorDefinirSectorRectangular,
                       CAFE_SDefinirSectorRectangular ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorMacroRecibeArgumentosReales,
                       CAFE_SMacroRecibeArgumentosReales ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorCopiaProvocaRangoNoPermitido,
                       CAFE_SCopiaProvocaRangoNoPermitido ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorCopiaNoPermitidaGeneral,
                       CAFE_SCopiaNoPermitidaGeneral ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorNoPudoEvaluarValoresInicialesCopiaMacro,
            CAFE_SNoPudoEvaluarValoresInicialesCopiaMacro ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorIrregularAccesoCasilla,
            CAFE_SIrregularAccesoCasilla ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorIntegralSuperoTotalCiclos,
            CAFE_SIntegralSuperoTotalCiclos ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorMacroResultadoNoReal,
            CAFE_SMacroResultadoNoReal ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorFaltaFinComentario,
            CAFE_SFaltaFinComentario ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorFaltaFinString,
            CAFE_SFaltaFinString ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorStringGeneral,
            CAFE_SStringGeneral ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorSintaxisAsignacionGeneral,
            CAFE_SSintaxisAsignacionGeneral ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorSintaxisJustificadoresWrite,
            CAFE_SSintaxisJustificadoresWrite ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( MensajeREPO, CAFE_MensajeGrupoSaveSinManejadores,
            CAFE_SMensajeGrupoSaveSinManejadores ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorNudilladoSubOrden,
            CAFE_SNudilladoSubOrden ) ) THEN Halt;
  IF NOT( CAFE_ListaMensajePipe.AgregarMensajeMultiple
          ( ErrorREPO, CAFE_ErrorParametrosSubOrden,
            CAFE_SParametrosSubOrden ) ) THEN Halt;
  {$IFDEF       SILENCIAR       }
  {$WARNINGS    ON              }
  {$ENDIF                       }
  ImplementationSintactico      :=
        CAFE_CharByte3Sintactico.Create( CAFE_DefaultTamanoInicialCharByte );
  ImplementationAlternativaHojaAislado   :=
                        CAFE_ConstToString( [ 'AISLADO' ] );
  ImplementationAlternativaCasillaCiclica               :=
        CAFE_ConstToString( [ 'VALOR', 'RECURSIVA', 'EVALUAR',
                'RECURSIVAERROR', 'CUALQUIERTIPO' ] );
  CAFE_AlternativaVariableGeneral                       :=
                CAFE_ConstToString( [ 'MODOSIMULARCALCULO',
                        'HABILITARUNCICLO', 'PUNTOSRAIZPRELIMINAR',
                        'MAXIMOCICLOSINTEGRAL',
                        'MAXIMOCICLOSINTEGRALINTERNA',
                        'EPSILONCERO', 'EPSILONDETERMINANTECERO',
                        'FILASENHOJA', 'COLUMNASENHOJA' ] );
FINALIZATION
  SetLength( ImplementationAlternativaHojaAislado, 0 );
  SetLength( ImplementationAlternativaCasillaCiclica, 0 );
  SetLength( CAFE_AlternativaVariableGeneral, 0 );
  FreeAndNil( ImplementationSintactico );
END.
