program xmlProdigy;
uses crt,dos;

{*: Significa que es utilizado por mas de un submodulo de un modulo}
{Por ejemplo: pantalla_nivel1 se ubica en ...desarrolla_menu*}
{porque es usado por mas de un submodulo de desarrolla_menu}

  procedure muestra_menu;
  {Ubicacion: PPrincipal > desarrolla_menu}
  {Muestra pantalla con las opciones del programa}
  begin
  clrscr;
  writeln;
  writeln('                     ºÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»');
  writeln('                     º                      º');
  writeln('                     º     XML Prodigy!     º');
  writeln('                     º                      º');
  writeln('                     ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͺ');
  writeln('                           Àversion 0.1b   ');
  writeln;
  writeln('                   Menu Principal del Programa:   ');
  writeln('                   ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ   ');
  writeln;
  writeln('          [1] Creaci¢n de un nuevo documento ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ ');
  writeln('              [ Creaci¢n e inserci¢n de nueva data           ] ');
  writeln;
  writeln('          [2] Trabajar con un archivo XML ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ ');
  writeln('              [ Edici¢n, verificaci¢n, borrado y exportaci¢n ] ');
  writeln;
  writeln('          [3] Activar el repositorio de datos ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ ');
  writeln('              [ Almacenamiento de datos en registros         ] ');
  writeln;
  writeln('          [0] Finalizar la ejecuci¢n del programa ÄÄÄÄÄÄÄÄÄÄÄÄ ');
  writeln('              [ Salir al sistema operativo                   ] ');
  writeln;
  write('              Elija su opcion: ')
  end;

  procedure barra_identidad;
  {Ubicacion: PPrincipal > desarrolla_menu* desarrolla_menu*}
  {Presente en todos los submodulos}
  {Indica al usuario que esta en uno de los modulos de XMLProdigy}
  begin
  clrscr;
  writeln;
  writeln('ÀxmlProdigy¿');
  writeln('ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ')
  end;

  function existe(name:string):boolean;
  {Ubicacion: PPrincipal > desarrolla_menu*}
  {Presente en todos los submodulos}
  {Permite probar si un archivo se encuentra grabado fisicamente}
  var ArchivoaProbar: TEXT;
  begin
  assign(ArchivoaProbar,name);
  {$I-}
  reset(ArchivoaProbar);
  {$I+}
  existe:=ioresult=0
  end;

  procedure barrera_si_existe(var name:string; var salida:boolean);
  {Ubicacion: PPrincipal > desarrolla_menu*}
  {Presente en todos los submodulos}
  {Recibe un nombre de archivo y lo verifica hasta que si exista}
  begin
  write(' ');
  readln(name);
  salida:=false;
  if name='0' then
    salida:=true;
  while (not existe(name)) and (not salida) do
    begin
    writeln(' El archivo especificado no existe');
    writeln;
    writeln(' Nueva ubicacion: (0: Cancelar y salir ) ');
    write(' ');
    readln(name);
    if name='0' then
      salida:=true
    end;
  writeln
  end;

  procedure barrera_no_existe(var name:string; var salida:boolean);
  {Ubicacion: PPrincipal > desarrolla_menu*}
  {Presente en todos los submodulos}
  {Recibe un nombre de archivo y lo verifica hasta que no exista}
  begin
  write(' ');
  readln(name);
  salida:=false;
  if name='0' then
    salida:=true;
  while (existe(name)) and (not salida) do
    begin
    writeln(' El archivo especificado ya existe');
    writeln;
    writeln(' Nueva ubicacion: (0: Cancelar y salir ) ');
    write(' ');
    readln(name);
    if name='0' then
      salida:=true
    end;
  writeln
  end;

  procedure recibe_si_no(var caracter:char);
  {Ubicacion: PPrincipal > desarrolla_menu*}
  {Presente en los modulos de creacion, edicion, repositorio}
  {Recibe correctamente un [S]i o un [N]o}
  begin
  caracter:=readkey;
  writeln(caracter);
  delay(500);
  while not (caracter in ['S','s','N','n']) do
    begin
    write('   Ingrese opcion correcta : ');
    caracter:=readkey;
    writeln(caracter);
    delay(500)
    end;
  writeln
  end;

  procedure copia_archivos(var arch1,arch2:text);
  {Ubicacion: PPrincipal > desarrolla_menu* }
  {Presente en los submodulos trabajar, repositorio}
  {Copia el archivo arch1 en el archivo arch2}
  var linea:string;
  begin
  reset(arch1);
  rewrite(arch2);
  while not eof(arch1) do
    begin
    readln(arch1,linea);
    if linea<>'' then
    writeln(arch2,linea)
    end
  end;

  procedure add_archivos(var arch1,arch2:text);
  {Ubicacion: PPrincipal > desarrolla_menu* }
  {Presente en los submodulos trabajar, repositorio}
  {A¤ade el archivo arch1 en el archivo arch2}
  var linea:string;
  begin
  reset(arch1);
  append(arch2);
  repeat
    readln(arch1,linea);
    writeln(arch2,linea);
  until eof(arch1)
  end;


  procedure crear;
  {Ubicaci¢n: PPrincipal > desarrolla_menu}
  {Crea f¡sicamente un archivo XML}

    procedure creayescribe(var archWork:text; name:string);
    {Ubicacion: PPrincipal > desarrolla_menu > crear}
    {Permite que el usuario con conocimientos de XML genere un archivo}
    const
      max_pila=80;
      enter=13;
      escape=27;
      alt_x=45;
      flecha_izq=75;
      i=33;
      f=126;
      eb=32;
    type
      t_pila=array[0..max_pila-1] of char;
    var
      t1,t2:char;
      pila:t_pila; cima:integer;
      n1,n2:integer; salir:boolean;

    procedure recibe_tecla;
    {Ubicacion: PPrincipal > desarrolla_menu > crear > creayescribe}
    {Recibe un caracter}
    begin
    t1:=readkey;
    if t1=chr(0) then
      t2:=readkey
    end;

    function apila(c:char):boolean;
    {Ubicacion: PPrincipal > desarrolla_menu > crear > creayescribe}
    {A¤ade un caracter recibido como parametro dentro de un arreglo}
    begin
    apila:=false;
    if cima<max_pila then
      begin
      pila[cima]:=C;
      cima:=cima+1;
      apila:=true
      end
    end;

    procedure desapila;
    {Ubicacion: PPrincipal > desarrolla_menu > crear > creayescribe}
    {Elimina el ultimo caracter a¤adido en un arreglo}
    begin
      cima:=cima-1
    end;

    procedure escribe_pila(var archWork:text);
    {Ubicacion: PPrincipal > desarrolla_menu > crear > creayescribe}
    {Escribe el arreglo de caracteres en una linea de un archivo}
    var i:integer;
    begin
    writeln;
    for i:=0 to cima-1 do
      write(archWork,pila[i])
    end;

    {Inicio de modulo PPrincipal > desarrolla_menu > crear > creayescribe}
    begin
    barra_identidad;
    writeln('                                       [1] Creaci¢n de un nuevo documento');
    writeln;
    writeln('Iniciando escritura en ',name);
    writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
    writeln('Puede empezar a escribir. El limite de caracteres por linea es de 80');
    writeln('Para eliminar el ultimo caracter escrito pulse fecha izquierda <-');
    writeln('Para salir de este proceso pulse ENTER y luego ESC');
    writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
    cima:=0;
    salir:=false;
    repeat
      recibe_tecla;
      n1:=ord(t1);
      n2:=ord(t2);
      case n1 of
      enter : begin
              escribe_pila(archWork);
              cima:=0;
              writeln(archWork)
              end;
      escape: salir:=true;
      0:      case n2 of
              flecha_izq: if cima>0 then
                          begin
                          gotoxy(wherex-1,wherey);
                          clreol;
                          desapila
                          end;
              alt_x: salir:=true
              end;
      i..f,eb: if apila(t1) then
               begin
               write(t1)
               end
      end;
    until salir;
    writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
    end;
    {Fin de modulo PPrincipal > desarrolla_menu > crear > creayescribe}

    procedure createmporal(var archWork:text);
    {Ubicacion: desarrolla_menu > crear }
    {Genera un archivo XML con lineas predeterminadas}
    begin
    writeln(archWork,'<?xml version="1.0"?>');
    writeln(archWork,'<etiqueta>contenido</etiqueta>');
    writeln(archWork,'<!-- comentario -->')
    end;

  {Inicio de modulo PPrincipal > desarrolla_menu > crear}
  var
    name:string;
    salida:boolean;
    archWork:text;
    escritura:char;
  begin
  barra_identidad;
  writeln('                                       [1] Creaci¢n de un nuevo documento');
  writeln;
  writeln(' Ingrese ubicaci¢n de archivo a crear');
  barrera_no_existe(name,salida);
  if not salida then
    begin
    assign(archWork,name);
    rewrite(archWork);
    writeln(' Archivo ',name,' creado satisfactoriamente');
    writeln;
    write(' Desea ingresar datos al archivo recien creado? [S]i o [N]o : ');
    recibe_si_no(escritura);
    case escritura of
    's','S': creayescribe(archWork,name);
    'n','N': createmporal(archWork)
    end;
    close(archWork);
    writeln(' El proceso de creacion ha finalizado exitosamente')
    end;
  writeln(' Regresando al menu principal...');
  delay(2500);
  end;
  {Fin de modulo PPrincipal > desarrolla_menu > crear}

  procedure trabajar;
  {Ubicaci¢n: PPrincipal > desarrolla_menu}
  {Procedimiento que permite manejar un archivo XML}

    procedure muestra_menu_trabajo;
    {Ubicaci¢n: PPrincipal > desarrolla_menu > muestra_menu_trabajo}
    {Muestra pantalla con opciones de trabajo}
    begin
    writeln('           Menu de opciones de trabajo:   ');
    writeln('           ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ   ');
    writeln;
    writeln('       [1] Editar el archivo de trabajo');
    writeln('       [2] Verificar sintaxis de documento');
    writeln('       [3] Borrar un archivo existente');
    writeln('       [4] Exportar archivo a formato CSV');
    writeln('       [5] Exportar archivo a formato HTML');
    writeln;
    writeln('       [0] Salir al menu principal');
    writeln;
    write('           Elija su opcion: ')
    end;

    procedure edicion(var archWork:text; name:string);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar}
    {Permite editar un archivo dado como parametro}
    label no_cambios;

    {submodulos utilizados en PPrincipal > desarrolla_menu > trabajar > edicion}
    procedure menu_cambios;
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > edicion }
    {Muestra el menu de cambios realizables en un bloque de lineas}
    begin
    writeln;
    writeln('ÄÄÄ Opciones de edicion ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
    writeln(' [C] Cambiar contenido de una linea [I] Insertar una nueva linea');
    writeln(' [E] Eliminar una linea existente   [N] No realizar cambios en el bloque');
    write('   Escriba la opcion escogida: ')
    end;

    procedure muestra_arch_orig(var archWork,archAux2:text; var conta_bloques:integer);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > edicion }
    {Muestra un bloque del archivo original}
    var
      conta_linea:integer;
      linea:string;
    begin
    rewrite(archAux2);
    inc(conta_bloques);
    write('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
    writeln(' Bloque de lineas ',conta_bloques,' : ',conta_bloques*5-4,' - ',conta_bloques*5); writeln;
    conta_linea:=0;
    repeat
      inc(conta_linea);
      readln(archWork,linea); writeln(archAux2,linea);
      writeln(' ',conta_linea,': ',linea); writeln;
    until ((conta_linea mod 5)=0) or eof(archWork)
    end;

    procedure muestra_lineas(var archAux2:text; conta_bloques:integer);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > edicion }
    {muestra el contenido de un archivo aux2}
    var
      linea:string;
      conta_linea_int:byte;
    begin
    reset(archAux2);
    conta_linea_int:=0;
    writeln;
    writeln('ÄÄÄ Mostrando version actualizada ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ bloque ',conta_bloques:3);
    repeat
      readln(archAux2,linea);
      inc(conta_linea_int);
      writeln(conta_linea_int,': ',linea);
    until eof(archAux2)
    end;

    procedure cambia_linea(var archAux2:text);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > edicion }
    {Modifica el contenido de aux2 usando un archivo temporal aux3}
    var
      nro_linea,conta_linea:integer;
      c:char;
      lineaux,linea:string;
      archAuxInt1:text;
    begin
    assign(archAuxInt1,'auxint1.txt');
    rewrite(archAuxInt1);
    writeln('  Ingrese el numero de linea a modificar,');
    writeln('  deje un espacio y escriba su contenido: ');
    write('  ');
    read(nro_linea,c,lineaux);
    conta_linea:=0;
    reset(archAux2);
    repeat
      inc(conta_linea);
      readln(archAux2,linea);
      if conta_linea<>nro_linea then
        writeln(archAuxInt1,linea)
      else
        writeln(archAuxInt1,lineaux)
    until eof(archAux2);
    copia_archivos(archAuxInt1,archAux2);
    erase(archAuxInt1);
    close(archAuxInt1)
    end;

    procedure inserta_linea(var archAux2:text);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > edicion }
    {Inserta una linea en aux2 usando un archivo temporal aux3}
    var
      nro_linea,conta_linea:integer;
      c:char;
      lineaux,linea:string;
      archAuxInt1:text;
    begin
    assign(archAuxInt1,'auxint1.txt');
    rewrite(archAuxInt1);
    writeln('  Ingrese el numero de linea donde se insertara una nueva linea,');
    writeln('  deje un espacio y escriba su contenido: ');
    write('  ');
    read(nro_linea,c,lineaux);
    conta_linea:=0;
    reset(archAux2);
    repeat
      inc(conta_linea);
      readln(archAux2,linea);
      if conta_linea<>nro_linea then
        writeln(archAuxInt1,linea)
      else
        begin
        writeln(archAuxInt1,lineaux);
        writeln(archAuxInt1,linea)
        end;
    until eof(archAux2) and (conta_linea>=nro_linea);
    copia_archivos(archAuxInt1,archAux2);
    erase(archAuxInt1);
    close(archAuxInt1)
    end;

    procedure elimina_linea(var archAux2:text);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > edicion}
    {Elimina una linea en aux2 usando un archivo temporal aux3}
    var
      nro_linea,conta_linea:integer;
      c:char;
      linea:string;
      archAuxInt1:text;
    begin
    reset(archAux2);
    assign(archAuxInt1,'auxint1.txt');
    rewrite(archAuxInt1);
    write(' Ingrese el numero de linea a eliminar: ');
    read(nro_linea);
    conta_linea:=0;
    repeat
      inc(conta_linea);
      readln(archAux2,linea);
      if conta_linea<>nro_linea then
        writeln(archAuxInt1,linea)
    until eof(archAux2);
    copia_archivos(archAuxInt1,archAux2);
    erase(archAuxInt1);
    close(archAuxInt1)
    end;

    procedure recibe_tecla_edi(var cambio:char);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > edicion}
    {Recibe correctamente opcion para realizar cambios en bloque}
    begin
    cambio:=readkey;
    writeln(cambio);
    delay(1000);
    while not (cambio in ['C','c','E','e','I','i','N','n']) do
      begin
      write('   Ingrese opcion correcta : ');
      cambio:=readkey;
      writeln(cambio);
      delay(1000)
      end;
    writeln
    end;

    var
      archAux1,archAux2:text;
      conta_bloques:integer;
      cambio,modifichar:char;
      modificando:boolean;

    {Inicio de modulo PPrincipal > desarrolla_menu > trabajar > edicion}
    begin
    assign(archAux1,'aux1.txt');
    rewrite(archAux1);
    assign(archAux2,'aux2.txt');
    conta_bloques:=0;
    reset(archWork);
    while not eof(archWork) do
      begin
      barra_identidad;
      writeln('                                          Edici¢n de un archivo existente');
      writeln;
      writeln(' Edicion del archivo ',name);
      muestra_arch_orig(archWork,archAux2,conta_bloques);
      modificando:=true;
      while modificando do
        begin
        menu_cambios;
        recibe_tecla_edi(cambio);
        case cambio of
        'C','c': cambia_linea(archAux2);
        'E','e': elimina_linea(archAux2);
        'I','i': inserta_linea(archAux2);
        'N','n': begin
                 modifichar:=cambio;
                 goto no_cambios
                 end
        end;
        muestra_lineas(archAux2,conta_bloques);
        writeln;
        write('  Desea continuar la edicion de este bloque? [S]i o [N]o : ');
        recibe_si_no(modifichar);
{label!}  no_cambios:
        if (modifichar='n') or (modifichar='n') then
          modificando:=false
        end;
      add_archivos(archAux2,archAux1)
      end;
    erase(archAux2); close(archAux2);
    copia_archivos(archAux1,archWork);
    erase(archAux1); close(archAux1);
    close(archWork);
    writeln('  El proceso de edicion ha concluido satisfactoriamente');
    writeln;
    writeln('  Regresando al menu principal...');
    delay(2500);
    end;
    {Fin de modulo PPrincipal > desarrolla_menu > trabajar > edicion}

    procedure verifica(var archXml:text; name:string);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar}

    procedure verifica_comillas_iguales(var archAux: text);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > verifica }
    {!!!verificacion de atributos}
    var
      incorrecto: boolean;
      c: char;
      cont_sing, cont_dobles, cont_igual: integer;
      total: real;
    begin
    cont_sing:=0;
    cont_dobles:=0;
    cont_igual:=0;
    incorrecto:= false;
    reset(archAux);
    while not eof(archAux) do
      begin
      read(archAux, c);
      if ord(c)=39 then
        inc(cont_sing);
      if c= '"' then
        inc(cont_dobles);
      if c= '=' then
        inc(cont_igual);
      end;
    total:=(cont_sing + cont_dobles) div 2;
    if ((cont_sing mod 2)<>0) and (total<>cont_dobles) then
      writeln('El archivo contiene mas comillas simples de lo debido');
    if ((cont_dobles mod 2)<>0) and (total<>cont_dobles) then
      writeln('El archivo contiene mas comillas dobles de lo debido');
    end;

    function saca_linea(var archWork:text):string;
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > verifica }
    {se necesita para el verifica atributos, la verificacion2}
    var
      c: char;
      linea: string;
    begin
    linea:='';
    c:=' ';
    while ((not eoln(archWork)) and (ord(c)<>62)) do
      begin
      read(archWork, c);
      if ord(c)<>62 then
        linea:= linea + c
      end;
    saca_linea:= linea
    end;


    procedure verifica_atributos(var archWork: text; var e:char);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > verifica }
    {este procedure se necesita para el captura_etiqueta}
    var
       c, ant: char;
       archAux: text;
       linea: string;
       incorrecto: boolean;
       cont_dobles,cont_simples:integer;
    begin
      assign(archAux, 'borra1.txf');
      rewrite(archAux);
      linea:=saca_linea(archWork);
      writeln(archAux,linea);
      verifica_comillas_iguales(archAux);
      incorrecto:= FALSE;
      reset(archAux);
      read(archAux,c);
      cont_dobles:=0;
      cont_simples:=0;
      while not eoln(archAux) do
        begin
        ant:=c;
        read(archAux, c);
        if (ord(c)=61) and (not ord(ant) in [65..90, 97..122]) then
          {es muy posible q falten chars permitidos}
          writeln('Hay un simbolo de = fuera de lugar');
          {incorrecto}
        if (ord(c) in [60,62]) and  (ord(ant)=61) then
          writeln('Hay un simbolo de = fuera de lugar');
          {incorrecto}
        if (ord(c) in [65..90, 97..122]) and (not ord(ant) in [65..90, 97..122]) then
          writeln('Hay un caracter no permitido dentro del atributo');
          {incorrecto}
        if (ord(ant) in [34,39]) and (not ord(c) in [ord(' '),13,62]) then
          {writeln('Hay mas de una comilla fuera de lugar');}
          incorrecto:=true;
        if (ord(c) in [34,39]) and not ((ord(ant) in [48..57,65..90, 97..122, 61])) then
          incorrecto:=true;
          {writeln('Hay mas de una comilla fuera de lugar')}

        if (ord(ant)=61) and (ord(c)=34) then
          inc(cont_dobles);
        if (ord(ant) in [48..57,65..90, 97..122]) and (ord(c)=34) then
          dec(cont_dobles);
        if (ord(ant)=61) and (ord(c)=39) then
          inc(cont_simples);
        if (ord(ant) in [48..57,65..90, 97..122]) and (ord(c)=39) then
          dec(cont_simples);
        end;
      if (cont_dobles<>0) or (cont_simples<>0) then
        incorrecto:=true;
      if incorrecto then
      writeln('El archivo tiene una o mas comillas fuera de lugar');
      e:=c;
      erase(archAux);
      close(archAux);
      end;

    procedure captura_etiqueta(d:char; var archWork,AuxEtiq:text);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > verifica }
    {parte directa del programa principal}
    var
      c,e:char;
      etiqueta:string;
      fin:boolean;
    begin
    e:=' ';
    etiqueta:=d;
    fin:=false;
    while not fin do
      begin
      read(archXML, c);
      if c in [' ', '>', '/'] then
        fin:= true
      else
       etiqueta:= etiqueta + c;
      end;
    append(auxEtiq);
    case c of
    ' ': begin
         verifica_atributos(archWork,e);
         if e<>'/' then
           writeln(AuxEtiq, etiqueta);
         end;
    '>': writeln(AuxEtiq, etiqueta);
    end;
    close(auxEtiq);
    reset(auxEtiq);
    end;

    procedure elimina_ultimo(var archEtiq:text);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > verifica }
    var
      archBorr:text;
      c:char;
      palabra: string;
    begin
    assign(archBorr,'borra1.txt');
    rewrite(archBorr);
    palabra:='';
    reset(archEtiq);
    read(archEtiq, c);
    while not (ord(c)=26) do
      begin
      palabra:=palabra + c;
      read(archEtiq,c);
      if (ord(c)=13) then
        begin
        read(archEtiq,c);
        read(archEtiq,c); {leo 2 veces para saltearme el #13 y #10}
        if not (ord(c)=26) then
          begin
          writeln(archBorr,palabra);
          palabra:= '';
          end
        end;
      end;
    reset(archBorr);
    rewrite(archEtiq);
    while not eof(archBorr) do
      begin
      readln(archBorr, palabra);
      writeln(archEtiq, palabra);
      end;
    erase(archBorr); close(archBorr);
    end;

    {tambien se necesita para el borra_etiqueta, borra la etiqueta en el auxiliar}
    function saca_ultimo(var archAux:text):string;
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > verifica }
    var
      c: char;
      palabra: string;
    begin
    reset(ArchAux);
    palabra:='';
    read(ArchAux, c);
    while not (ord(c)=26) do
      begin
      palabra:=palabra + c;
      read(ArchAux, c);
      if (ord(c)=13) then
        begin
        read(archAux,c);
        read(archAux,c); {leo 2 veces para saltearme el #13 y #10}
        if not (ord(c)=26) then
          palabra:= '';
        end;
      end;
    saca_ultimo:= palabra;
    end;

    procedure borra_etiqueta(d:char; var archXML,archEtiq:text);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > verifica }
    {parte directa del programa principal}
    var
      c: char;
      etiqueta, ultimo_aux: string;
      fin: boolean;
    begin
    read(archXML,d);
    etiqueta:=d;
    fin:=false;
    while not fin do
      begin
      read(archXml, c);
      If c in [' ', '>', '/'] then
        fin:= true
      else
        etiqueta:= etiqueta + c
      end;
    ultimo_aux:=saca_ultimo(archEtiq);
    if ultimo_aux=etiqueta then
      elimina_ultimo(archEtiq)
    else
      begin
      if ultimo_aux <> '' then
        begin
        writeln('Error entre las etiquetas <',etiqueta,'> y <',ultimo_aux,'>');
        writeln('La etiqueta ',etiqueta,' no ha sido abierta o');
        writeln('La etiqueta ',ultimo_aux,' no ha sido cerrada');
        elimina_ultimo(archEtiq);
        end
      else
        begin
        writeln('La etiqueta ',etiqueta,' no ha sido abierta');
        elimina_ultimo(archEtiq);
        end;
      end;
    end;

    procedure verifica_XML_inicio(var archXML:text);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > verifica }
    var
       linea, etiqueta:string;
       archAux:TEXT;
       c:char;
       cont: integer;
       fin:boolean;
    begin
    assign(archAux, 'borra1.txt');
    rewrite(archAux);
    linea:=saca_linea(archXML);
    writeln(archAux, linea);
    reset(archAux);
    verifica_comillas_iguales(archAux);
    reset(archAux);
    cont:=0;
    read(archAux,c);
    fin:=FALSE;
     while (not eof(archAux)) and (not fin) do
     begin
          etiqueta:='';
          inc(cont);
          if cont=1 then
             begin
                 repeat
                      c:=upcase(c);
                      etiqueta:=etiqueta+c;
                      read(archAux,c);
                 until c in [' ','?',#26];
                 if (etiqueta<>'XML') then writeln('Se encontro el siguiente error en el encabezado: ',etiqueta);
                 if c = '?' then fin:=TRUE;
                 read(archAux,c);
             if not (c in [#10,#13, #26]) and fin then writeln('Se encontraron caracteres despues del simbolo "?" ')
             end
          else
             begin
             if c <> '?' then
                repeat
                      c:=upcase(c);
                      etiqueta:=etiqueta+c;
                      read(archAux,c);
                      until c in [' ', '=', #26, '?'];
             if c = '?' then fin:=true;
             read(archAux,c);
             if not (c in [#10, #13, #26]) and (fin) then
                writeln('Se encontraron caracteres despues del simbolo "?" ');
             if not fin then
             begin
                   case cont of
                        2:begin
                                     if (etiqueta<>'VERSION') then
                                     writeln('Se encontro el siguiente error en el encabezado: ',etiqueta);
                          end;
                        3:begin
                                     if (etiqueta<>'ENCODING') then
                                     writeln('Se encontro el siguiente error en el encabezado: ',etiqueta);
                          end;
                   end;
                   repeat read(archAux,c) until c in [' ','?',#26];
             end;
          end;
              {if not fin then
              begin
                   repeat
                    read(archAux,c);
                    until (c<>' ') or (c='?');
                   if c='?' then fin:=TRUE;
              end;}

         end;
         if fin = FALSE then
            writeln('El encabezado no ha sido cerrado');
         erase(archAux);
    end;
    procedure verifica_doctype_comentario(var archXML: text);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar > verifica }
    var
       c:char;
       linea:string;
       archAux:TEXT;
    begin
         assign(archAux,'borra1.txt');
         rewrite(archAux);
         linea:=saca_linea(archXML);
         writeln(archAux,linea);
         reset(archAux);
         linea:='';
         while (not eof(archAux)) do
         begin
              read(archAux,c);
              linea:=linea+c;
              read(archAux,c);
              linea:=linea+c;
              if linea<>'--' then
              begin
                   reset(archAux);
                   readln(archAux,linea);
                   writeln('Se encontro un error en el comentario:', linea);
              end else
              linea:='';
              read(archAux,c);
              if (c='-') then
                begin
                 linea:=linea+c;
                 read(archAux,c);
                 linea:=linea+c;
                 if linea<>'--' then
                 begin
                   reset(archAux);
                   readln(archAux,linea);
                   writeln('Se encontro un error en el comentario:', linea);
                 end;
                end
              else begin
                     repeat
                           read(archAux,c);
                           until c='-';
                     linea:='';
                     linea:=linea+c;
                     read(archAux,c);
                     linea:=linea+c;
                     if linea<>'--' then
                     begin
                          reset(archAux);
                          readln(archAux,linea);
                          writeln('Se encontro un error en el comentario:', linea);
                     end;
                     read(archAux,c);{#13}
                     read(archAux,c);{#10}
                     read(archAux,c);{#26}
                     if not eof(archAux) then writeln('Se encontro un error en el comentario:', linea)
              end;
         end;
           erase(archAux);
    end;

    {Inicio de modulo PPrincipal > desarrolla_menu > trabajar > verifica}
    var
      c, d: char;
      auxEtiq: text;
      lineas:string;
      cont_mayor,cont_menor:integer;
    begin
    assign(auxEtiq,'archEtiq.txt');
    rewrite(auxEtiq);
    barra_identidad;
    writeln('                                               Verificaci¢n de un archivo');
    writeln;
    writeln(' Verificaci¢n del archivo ',name);
    writeln;
    reset(archXML);
    while not eof(archXML) do
      begin
      read(archXML, c);
      if ord(c)=60 then
        begin
        read(ArchXML, d);
        case ord(d) of
          65..90, 97..122: captura_etiqueta(d,archXML,AuxEtiq);
          {obtiene un auxiliar con todas las etiquetas}
          47:              borra_etiqueta(d,archXML,auxEtiq);
          {verifica que cada etiqueta se cierre}
          63:              verifica_xml_inicio(archXML);
          33:              verifica_Doctype_comentario(archXML);
          62:              begin
                           while not ord(d)=60 do
                           read(archXML,d);
                           end;
          13:              readln(archXML);
          {else
          if not (ord(d) in [13,10,26]) then
            writeln('El archivo contiene caracteres no validos');}
        end;
        end;
      end;
    close(archXML);
    close(auxEtiq);
    erase(auxEtiq);
    writeln(' La verificacion del archivo ha culminado.');
    writeln(' Pulse cualquier tecla para continuar.');
    readkey;
    writeln(' Regresando al menu de trabajo...');
    delay(2500);
    end;
    {Fin de modulo PPrincipal > desarrolla_menu > trabajar > edicion}

    procedure borrado(var archWork:text; name:string; var op_t:byte);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar}
    var
      confirma:char;
    begin
    barra_identidad;
    writeln('                                                Eliminaci¢n de un archivo');
    writeln;
    writeln(' Eliminaci¢n del archivo ',name);
    writeln;
    write(' Confirme Borrado: [S]i o [N]o: ');
    recibe_si_no(confirma);
    if confirma in ['S','s'] then
      begin
      writeln(' Archivo a borrar: ',name);
      erase(archWork);
      close(archWork);
      writeln(' Archivo eliminado satisfactoriamente');
      op_t:=0;
      end;
    end;

    procedure export_csv(var archXml:text; name:string);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar}
    procedure saca_comas(var archAux, archCsv:text);
    var
      linea, linea_sin_coma_final: string;
    begin
      reset(archAux);
      while not eof(archAux) do
        begin
        readln(archAux, linea);
        linea_sin_coma_final:= copy(linea, 1, length(linea)-1);
        writeln(archCsv, linea_sin_coma_final);
        end;
    end;

    {Inicio de modulo PPrincipal > desarrolla_menu > trabajar > export_csv}
    var
      archAux,archCsv:text;
      name2,linea,m:string;
      i,p:integer;
    begin
    barra_identidad;
    writeln('                                       Exportaci¢n de datos a formato CSV');
    writeln;
    writeln(' Exportaci¢n del archivo ',name);
    {Generacion del nombre de archivo CSV}
    if pos('.',name)<>0 then
      name2:=copy(name,1,pos('.',name))+'csv'
    else
      name2:=name+'.csv';
    {Comprueba existencia de nombre de archivo CSV}
    if existe(name2) then
      begin
      writeln(' Ingrese nombre de archivo donde se guardara el archivo CSV');
      writeln(' Distinto de : ',name2);
      write(' ');    readln(name2)
      end
    else
      begin
      writeln(' El archivo CSV se guardara en la siguiente ubicaci¢n: ');
      writeln(' ',name2)
      end;
    assign(archCSV,name2);
    rewrite(archCSV);
    assign(archAux,'auxiliar.txf');
    rewrite(archAux);
    while not eof(archXml) do
      begin
      readln(archXml,linea);
      if (linea<>'') then
        begin
        i:= pos('<',linea);
        while i<>0 do
          begin
          m:= copy(linea,1,i-1);
          if (m<>'') then
            write(archAux,m,',');
          if i<>0 then
            delete(linea,1,pos('>',linea));
          i:= pos('<',linea);
          end;
        writeln(archAux);
        end;
      end;
    saca_comas(archAux, archCsv);
    erase(archAux);
    close(archAux);
    close(archCsv);
    close(archXml);
    writeln;
    writeln(' Archivo convertido satisfactoriamente');
    writeln(' Pulse cualquier tecla para continuar.');
    readkey;
    writeln(' Regresando al menu de trabajo...');
    delay(2500);
    end;
    {Fin de modulo PPrincipal > desarrolla_menu > trabajar > export_csv}

    procedure export_html(var archXml:text; name:string);
    {Ubicacion: PPrincipal > desarrolla_menu > trabajar}

    procedure saca_br(var archAux, archHtml:text);
    var
      linea, linea_sin_br_final: string;
    begin
    reset(archAux);
    writeln(archHtml,'<html>');
    writeln(archHtml,'<head>');
    writeln(archHtml,'<title>Archivo exportado con XML Prodigy</title>');
    writeln(archHtml,'</head>');
    writeln(archHtml,'<body bgcolor="#F8ECD0" >');
    while not eof(archAux) do
    begin
      readln(archAux, linea);
      linea_sin_br_final:= copy(linea, 1, length(linea)-4);
      writeln(archHtml, linea_sin_br_final);
    end;
    writeln(archHtml,'</body>');
    writeln(archHtml,'</html>');
    end;

    {Inicio de modulo PPrincipal > desarrolla_menu > trabajar > export_html}
    var
      archAux,archHtml:text;
      name2,linea,m:string;
      i,p:integer;
    begin
    barra_identidad;
    writeln('                                      Exportaci¢n de datos a formato HTML');
    writeln;
    writeln(' Exportaci¢n del archivo ',name);
    if pos('.',name)<>0 then
      name2:=copy(name,1,pos('.',name))+'htm'
    else
      name2:=name+'.htm';
    if existe(name2) then
      begin
      writeln(' Ingrese nombre de archivo donde se guardara el archivo HTML');
      writeln(' Distinto de : ',name2);
      write(' ');
      readln(name2);
      end
    else
      begin
      writeln(' El archivo HTML se guardara en la siguiente ubicaci¢n: ');
      writeln(' ',name2);
      end;
    assign(archHtml,name2);
    rewrite(archHtml);
    assign(archAux,'auxiliar.txf');
    rewrite(archAux);
    while not eof(archXml) do
      begin
      readln(archXml,linea);
      if (linea<>'') then
        begin
        write(archAux,'<p>');
        i:= pos('<',linea);
        while i<>0 do
          begin
          m:= copy(linea,1,i-1);
          if (m<>'') then
            write(archAux,m,'<br>');
          if i<>0 then
            delete(linea,1,pos('>',linea));
          i:= pos('<',linea);
          end;
        writeln(archAux);
        end;
      end;
    saca_br(archAux,archHtml);
    erase(archAux);
    close(archAux);
    close(archHtml);
    close(archXml);
    writeln;
    writeln(' Archivo convertido satisfactoriamente');
    writeln(' Pulse cualquier tecla para continuar.');
    readkey;
    writeln(' Regresando al menu de trabajo...');
    delay(2500);
    end;
    {Fin de modulo PPrincipal > desarrolla_menu > trabajar > export_html}

  {Inicio de modulo PPrincipal > desarrolla_menu > trabajar}
  var
    name:string;
    salida:boolean;
    archWork:text;
    op_t:byte;
  begin
  barra_identidad;
  writeln('                                          [2] Trabajar con un archivo XML');
  writeln;
  writeln(' Ingrese ubicaci¢n de archivo de trabajo');
  writeln(' Por ejemplo C:\directorio\folder\archivo.xml');
  barrera_si_existe(name,salida);
  if not salida then
    begin
    repeat
      assign(archWork,name);
      reset(archWork);
      barra_identidad;
      writeln('                                          [2] Trabajar con un archivo XML');
      writeln;
      writeln(' Archivo de trabajo: ',name);
      writeln;
      writeln;
      muestra_menu_trabajo;
      {$I-}
      readln(op_t);
      {$I+}
      delay(500);
      if ioresult=0 then
        begin
        case op_t of
        1: edicion(archWork,name);
        2: verifica(archWork,name);
        3: borrado(archWork,name,op_t);
        4: export_csv(archWork,name);
        5: export_html(archWork,name);
        0: ;
        else
          begin
          writeln('              Confirme ingreso de opcion correcta');
          delay(1000);
          end;
        end;
        end
      else
        begin
        writeln('           Confirme ingreso de opcion correcta');
        delay(1000);
        end;
    until op_t=0;
    end;
  writeln;
  writeln(' Regresando al menu principal...');
  delay(2500);
  end;
  {Fin de modulo PPrincipal > desarrolla_menu > trabajar}

  procedure repositorio;
  {Ubicaci¢n: PPrincipal > desarrolla_menu}
  {Procedimiento que activa el repositorio de datos en XML}

    procedure muestra_menu_reposit;
    {Ubicaci¢n: PPrincipal > desarrolla_menu > repositorio}
    begin
    writeln;
    writeln('           Menu de opciones de repositorio:   ');
    writeln('           ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ   ');
    writeln;
    writeln('       [1] Definici¢n de estructura de datos');
    writeln('       [2] Generaci¢n de repositorio a partir de estructura');
    writeln('       [3] Operaciones con archivo de repositorio');
    writeln('           generado a partir de estructura');
    writeln;
    writeln('       [0] Salir al menu principal');
    writeln;
    write('           Elija su opcion: ')
    end;

    function es_estruct(var archEstruct:text):boolean;
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio}
    {Verifica si un archivo fue creado como estructura para repositorio}
    const verificador='<!-- Archivo Estructura para Repositorio de datos en XMLProdigy -->';
    var linea: string;
    begin
    reset(archEstruct);
    readln(archEstruct);
      readln(archEstruct,linea);
      if linea=verificador then
        es_estruct:=true
      else
        es_estruct:=false;
    end;

    function es_reposit(var archReposit:text):boolean;
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio }
    {Verifica si un archivo es un repositorio de datos de XMLProdigy}
    const verificador='<!-- Archivo de Repositorio de datos generado en XMLProdigy -->';
    var linea: string;
    begin
      reset(archReposit);
      readln(archReposit);
      readln(archReposit,linea);
      if linea=verificador then
        es_reposit:=true
      else
        es_reposit:=false;
    end;

    function si_fue_generado(var archEstruct,archReposit:text):boolean;
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio}
    {Verifica si un archivo de repositorio fue creado a partir de estructura dada}
    var
      generado:boolean;
      columna,campo:string;
      i:integer;
      archAuxInt1,archAuxInt2:text;
    begin
    generado:=true;
    assign(archAuxInt1,'auxi1.txf'); rewrite(archAuxInt1);
    assign(archAuxInt2,'auxi2.txf'); rewrite(archAuxInt2);
    {genera lista de campos del archivo de estructura}
    reset(archEstruct);
    for i:=1 to 4 do
      readln(archEstruct);
    readln(archEstruct,campo);
    repeat
      delete(campo,1,pos('"',campo));
      delete(campo,pos('"',campo),length(campo));
      writeln(archAuxInt1,campo);
      readln(archReposit,campo);
    until copy(campo,1,pos('"',campo))<>'    <campo nombre="';
    {genera lista de columnas del archivo de repositorio}
    reset(archReposit);
    for i:=1 to 4 do
      readln(archReposit);
    readln(archReposit,columna);
    repeat
      delete(columna,1,pos('"',columna));
      delete(columna,pos('"',columna),length(columna));
      writeln(archAuxInt2,columna);
      readln(archReposit,columna);
    until copy(columna,1,pos('"',columna))<>'    <dato columna="';
    {compara ambas listas}
    reset(ArchAuxInt1);
    reset(ArchAuxInt2);
    while (not eof(archAuxInt1)) and (generado) do
      begin
      readln(archAuxInt1,campo);
      readln(archAuxInt2,columna);
      if campo<>columna then
        generado:=false;
      end;
    si_fue_generado:=generado;
    erase(archAuxInt1);
    erase(archAuxInt2);
    close(archAuxInt1);
    close(archAuxInt2);
    end;

    function captura_numcampos(var archEstruct:text):integer;
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio}
    {Captura el numero de campos con los que cuenta una estructura de datos}
    var
      linea:string;
      aux1,aux2:integer;
    begin
    reset(archEstruct);
    readln(archEstruct);
    readln(archEstruct);
    readln(archEstruct,linea);
    delete(linea,1,pos('"',linea));
    delete(linea,pos('"',linea),length(linea));
    val(linea,aux1,aux2);
    captura_numcampos:=aux1;
    end;

    procedure captura_campos(var archEstruct:text; var nombre,tipo:string);
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio}
    {Captura el nombre y el tipo de campo que se encuentra en archEstruct}
    var
      linea:string;
      cantidad:integer;
      tip:string;
    begin
    readln(archEstruct,linea);
    delete(linea,1,pos('"',linea));
    nombre:=copy(linea,1,pos('"',linea)-1);
    delete(linea,1,pos('"',linea));
    delete(linea,1,pos('"',linea));
    tip:=copy(linea,1,1);
    cantidad:=0;
    if (tip='e') or (tip='E') then
      tipo:='Entero';
    if (tip='R') or (tip='r') then
      tipo:='Real';
    if (tip='C') or (tip='c') then
      tipo:='Caracter';
    if (tip='P') or (tip='p') then
      begin
      delete(linea,1,pos('"',linea));
      delete(linea,1,pos('"',linea));
      tipo:='Cadena de caracteres de tama¤o ' + copy(linea,1,pos('"',linea)-1);
      end;
    if (tip='L') or (tip='l') then
      tipo:='L¢gico';
    end;

    procedure def_estruct;
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio}
    {Posibilita la creacion de estructura base para la generacion del repositorio}

    procedure recibe_tecla_tipo(var op:char);
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > def_estruct}
    {Recibe correctamente opcion para tipo de dato}
    begin
    op:=readkey;
    writeln(op);
    delay(1000);
    while not (op in ['e','E','r','R','c','C','p','P','l','L']) do
      begin
      write('   Ingrese opcion correcta : ');
      op:=readkey;
      writeln(op);
      delay(1000);
      end;
    end;

    {Inicio del modulo PPrincipal > desarrolla_menu > repositorio > def_estruct }
    var
      archEstruct:text;
      nomb_campo, name:string;
      tipo_campo:char;
      nro_campos,i,cantidad:integer;
      salida:boolean;
    begin
    barra_identidad;
    writeln('                Creaci¢n del archivo Estructura de Datos para Repositorio');
    writeln;
    writeln(' Ingrese ubicaci¢n de archivo a crear');
    barrera_no_existe(name,salida);
    if not salida then
      begin
      assign(archEstruct,name);
      rewrite(archEstruct);
      writeln(' Archivo que almacenar  estructura: ',name);
      writeln;
      assign(archEstruct,name);
      rewrite(archEstruct);
      writeln(archEstruct,'<?xml version="1.0" encoding="UTF-8"?>');
      writeln(archEstruct,'<!-- Archivo Estructura para Repositorio de datos en XMLProdigy -->');
      writeln;
      write(' Especifique el numero de campos que desea para su repositorio : ');
      readln(nro_campos);
      writeln(archEstruct,'<estructura numcampos="',nro_campos,'">');
      writeln(archEstruct,'  <campos>');
      for i:=1 to nro_campos do
      begin
        writeln;
        write('  Nombre del campo ',i,' : ');
        readln(nomb_campo);
        writeln('  Tipos de campos soportados: ');
        writeln('  [e] Entero [r] Reales [c] caracter [p] cadena de caracteres [l] l¢gicos');
        write('  Tipo de campo ',i,' : ');
        recibe_tecla_tipo(tipo_campo);
        if tipo_campo in ['p','P'] then
          begin
          write('  Ingrese numero de caracteres permitidos: ');
          readln(cantidad);
          writeln(archEstruct,'    <campo nombre="',nomb_campo,'" tipo="',tipo_campo,'" cantidad="',cantidad,'"/>');
          end
        else
          writeln(archEstruct,'    <campo nombre="',nomb_campo,'" tipo="',tipo_campo,'"/>');
      end;
      writeln(archEstruct,'  </campos>');
      writeln(archEstruct,'</estructura>');
      close(archEstruct);
      writeln;
      writeln(' Archivo de estructura concluido satisfactoriamente');
      end;
    writeln(' Regresando al menu de repositorio...');
    delay(2500);
    end;
    {Fin del modulo PPrincipal > desarrolla_menu > repositorio > def_estruct }

    procedure gen_reposit;
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio}
    {Genera el repositorio de datos a partir de un archivo base de estructura}
    {Inicio del modulo PPrincipal > desarrolla_menu > repositorio > gen_reposit}
    var
      archEstruct,archReposit,archAlmacen:text;
      name1,name2,nombre,tipo,dato:string;
      num_campos,i,conta_registros:integer;
      op:char;
      salida:boolean;
    begin
    barra_identidad;
    writeln('             Generacion de repositorio a partir de estructura predefinida');
    writeln;
    writeln(' Ingrese ubicaci¢n de archivo que contiene la estructura');
    writeln(' Por ejemplo C:\directorio\carpeta\archivo.xml');
    barrera_si_existe(name1,salida);
    writeln(' Ingrese ubicaci¢n de archivo donde se almacenar  el repositorio');
    barrera_no_existe(name2,salida);
    if not salida then
      begin
      assign(archEstruct,name1);
      reset(archEstruct);
      if not es_estruct(archEstruct) then
        begin
        writeln(' El archivo que deberia contener la estructura');
        writeln(' no fue creado con tal fin en XMLProdigy');
        end
      else
        begin
        assign(archReposit,name2);
        rewrite(archReposit);
        writeln(archReposit,'<?xml version="1.0" encoding="UTF-8"?>');
        writeln(archReposit,'<!-- Archivo de Repositorio de datos generado en XMLProdigy -->');
        writeln(archReposit,'<datos>');
        assign(archAlmacen,'almacen.txf');
        rewrite(archAlmacen);
        num_campos:=captura_numcampos(archEstruct);
        readln(archEstruct);
        for i:=1 to num_campos do
          begin
          captura_campos(archEstruct,nombre,tipo);
          writeln(ArchAlmacen,nombre);
          writeln(ArchAlmacen,tipo);
          end;
        writeln;
        write('  Ingresar datos? [S]i o [N]o : ');
        recibe_si_no(op);
        conta_registros:=0;
        while op in ['s','S'] do
          begin
          inc(conta_registros);
          writeln(archReposit,'  <registro num="',conta_registros,'">');
          reset(archAlmacen);
          writeln('   Registro n£mero ',conta_registros);
          for i:=1 to num_campos do
            begin
            readln(archAlmacen,nombre);
            readln(archAlmacen,tipo);
            write('    ',nombre,' (',tipo,') : ');
            readln(dato);
            writeln(archReposit,'    <dato columna="',nombre,'">',dato,'</dato>');
            end;
          writeln(archReposit,'  </registro>');
          writeln;
          write('  Ingresar datos? [S]i o [N]o : ');
          recibe_si_no(op);
          end;
        writeln(archReposit,'</datos>');
        erase(archAlmacen);
        close(archEstruct);
        close(archReposit);
        end;
      end;
    writeln('  Regresando al menu de Repositorio ...');
    delay(2000);
    end;
    {Inicio del modulo PPrincipal > desarrolla_menu > repositorio > gen_reposit}

    procedure opera_reposit;
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio}
    {Utiliza archivos de estructura y de repositorio para hacer operaciones en este £ltimo}

    procedure muestra_menu_opera;
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit}
    {Muestra pantalla con opciones disponibles en el modulo de operaci¢n de repositorio}
    begin
    writeln;
    writeln('           Menu de operaci¢n de repositorio:   ');
    writeln('           ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ   ');
    writeln;
    writeln('       [1] Recuperaci¢n, Eliminaci¢n y Actualizaci¢n');
    writeln('           de datos por registros en repositorio');
    writeln('       [2] Recuperaci¢n, Eliminaci¢n y Actualizaci¢n');
    writeln('           de datos por condiciones de estructura');
    writeln('       [3] Exportaci¢n de datos de repositorio');
    writeln('           a formato Comma Separated Values (CSV)');
    writeln('       [4] Exportaci¢n de datos de repositorio');
    writeln('           a formato HyperText Mark-up Language (HTML)');
    writeln;
    writeln('       [0] Salir al menu principal');
    writeln;
    write('           Elija su opcion: ')
    end;

    procedure recibe_tecla_rea(var op:char);
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit}
    {Recibe correctamente opcion para realizar cambios en registro}
    begin
    op:=readkey;
    writeln(op);
    delay(1000);
    while not (op in ['A','a','E','e','N','n']) do
      begin
      write('   Ingrese opcion correcta : ');
      op:=readkey;
      writeln(op);
      delay(1000);
      end;
    writeln;
    end;

    procedure desempaqueta_repositorio(var archReposit,archAux1:text);
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit}
    {Extrae los datos guardados en archReposit y los guarda en un archAux1}
    var dato:string;
    begin
    reset(archReposit);
    rewrite(archAux1);
    while not eof(archReposit) do
      begin
      readln(archReposit,dato);
      if copy(dato,1,pos('"',dato))='    <dato columna="' then
        begin
        delete(dato,1,pos('>',dato));
        delete(dato,pos('<',dato),length(dato));
        writeln(archAux1,dato);
        end;
      end;
    end;

    procedure empaqueta_repositorio(var archAlmacen,archAux1,archAux0:text; num_campos:integer);
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit}
    {Regenera el archivo de repositorio a partir de archAux1, generado en el proceso de desempaquetado}
    var
      columna,dato:string;
      i,conta_registros:integer;
    begin
    conta_registros:=0;
    rewrite(archAux0);
    writeln(archAux0,'<?xml version="1.0" encoding="UTF-8"?>');
    writeln(archAux0,'<!-- Archivo de Repositorio de datos generado en XMLReader -->');
    writeln(archAux0,'<datos>');
    reset(archAux1);
    while not eof(archAux1) do
      begin
      inc(conta_registros);
      writeln(archAux0,'  <registro num="',conta_registros,'">');
      reset(archAlmacen);
      for i:=1 to num_campos do
        begin
        readln(archAlmacen,columna);
        readln(archAlmacen);
        readln(archAux1,dato);
        writeln(archAux0,'    <dato columna="',columna,'">',dato,'</dato>');
        end;
      writeln(archAux0,'  </registro>');
      end;
    writeln(archAux0,'</datos>');
    end;

    procedure rea_registro(name1,name2:string; var archEstruct,archReposit:text);
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit}
    {Posibilita la recuperaci¢n de datos de un repositorio, permitiendo tambien su modificaci¢n}
    label no_cambia1;

      procedure captura_bloque(var archAux1,archAux2:text; num_campos:integer);
      {Ubicaci¢n: PPrincipal > desarrolla_menu > repositorio > opera_reposit > rea_registro}
      {Captura 10 registros ya desempaquetados de archAux1 y los muestra y graba en archAux2}
      const limit=10;
      var
        i,a:integer;
        linea:string;
      begin
      rewrite(archAux2);
      a:=0;
      repeat
        inc(a);
        for i:=1 to num_campos do
          begin
          readln(archAux1,linea);
          writeln(archAux2,linea);
          end;
      until eof(archAux1) or (a=limit);
      end;

      procedure muestra_archivo(var aux2:text; c2,num_campos:integer);
      {Ubicacion: PPrincipal > desarrolla_menu > repositorio > rea_registro}
      {muestra el contenido actualizado de un archivo aux2}
      var
        linea:string;
        conta_linea,i:byte;
      begin
      reset(aux2);
      conta_linea:=c2+1;
      writeln;
      writeln(' Version actualizada');
      writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
      repeat
        write(conta_linea:5,': ');
        for i:=1 to num_campos do
          begin
          readln(aux2,linea);
          write(' [',linea,'] ');
          end;
        inc(conta_linea);
        writeln;
      until eof(aux2);
      end;

      procedure actualiza_dato(var archAux2,archAlmacen:text; num_campos:integer);
      {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit > rea_registro}
      {Permite la modificaci¢n de un grupo de datos}
      var
        i,j,num_registro:integer;
        nombre,tipo,dato:string;
        archAuxInt1:text;
      begin
      reset(archAux2);
      reset(archAlmacen);
      assign(archAuxInt1,'auxint1.txf');
      rewrite(archAuxInt1);
      write('Indique numero de registro a modificar : ');
      readln(num_registro);
      num_registro:=num_registro mod 10;
      if (num_registro=0) then
        num_registro:=10;
      for i:=1 to 10 do
        begin
        for j:= 1 to num_campos do
          begin
          readln(archAux2,dato);
          if i=num_registro then
            begin
            readln(archAlmacen,nombre);
            readln(archAlmacen,tipo);
            if nombre<>'' then
              begin
              write('  ',nombre,' [',tipo,'] : ');
              readln(dato);
              end;
            end;
          writeln(archAuxInt1,dato);
          end;
        end;
      copia_archivos(archAuxInt1,archAux2);
      erase(archAuxInt1);
      writeln;
      end;

      procedure elimina_regist(var archAux2:text; num_campos:integer);
      {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit > rea_registro}
      {Elimina totalmente un registro de datos}
      var
        i,j,num_registro:integer;
        dato:string;
        archAuxInt1:text;
      begin
      reset(archAux2);
      assign(archAuxInt1,'auxint1.txf');
      rewrite(archAuxInt1);
      write('Indique numero de registro a eliminar : ');
      readln(num_registro);
      num_registro:=num_registro mod 10;
      if (num_registro=0) then
        num_registro:=10;
      for i:=1 to 10 do
        begin
        for j:= 1 to num_campos do
          begin
          readln(archAux2,dato);
          if i<>num_registro then
            begin
            writeln(archAuxInt1,dato);
            end;
          end;
        end;
      copia_archivos(archAuxInt1,archAux2);
      erase(archAuxInt1);
      writeln;
      end;

    {Inicio del modulo PPrincipal > desarrolla_menu > repositorio > opera_reposit > rea_registro}
    var
      op,modifichar:char;
      modificando:boolean;
      num_campos,i,c2,conta_registros:integer;
      linea,nombre,tipo:string;
      archAlmacen,archAux0,archAux1,archAux2,archAux3:text;
    begin
      barra_identidad;
      writeln('                       Recuperaci¢n, eliminaci¢n y actualizaci¢n de datos');
      writeln;
      writeln(' Archivo donde se almacena el repositorio:');
      writeln(' ',name2);
      writeln;
      writeln(' Archivo que contiene la estructura del repositorio:');
      writeln(' ',name1);
      writeln;
      reset(archReposit);
      assign(archAux0,'aux0.txf'); rewrite(archAux0);
      assign(archAux1,'aux1.txf'); rewrite(archAux1);
      assign(archAux2,'aux2.txf'); rewrite(archAux2);
      assign(archAux3,'aux3.txf'); rewrite(archAux3);
      assign(archAlmacen,'almacen.txf'); rewrite(archAlmacen);
      {Cargo datos de archivo de estructura}
      num_campos:=captura_numcampos(archEstruct);
      reset(archEstruct);
      for i:=1 to 4 do
        readln(archEstruct);
      for i:=1 to num_campos do
        begin
        captura_campos(archEstruct,nombre,tipo);
        writeln(ArchAlmacen,nombre);
        writeln(ArchAlmacen,tipo);
        end;
      conta_registros:=0;
      desempaqueta_repositorio(archReposit,archAux1);
      reset(archAux1);
      while not eof(archAux1) do
        begin
        barra_identidad;
        writeln('                       Recuperaci¢n, eliminaci¢n y actualizaci¢n de datos');
        writeln;
        writeln(' Recuperacion del repositorio guardado en ',name2);
        writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
        captura_bloque(archAux1,archAux2,num_campos);
        write(' Registro: ');
        reset(archAlmacen);
        for i:=1 to num_campos do
          begin
          readln(archAlmacen,linea);
          readln(archAlmacen);
          write(' [',linea,'] ');
          end;
        writeln;
        writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
        reset(archAux2);
        c2:=conta_registros;
        while not eof(archAux2) do
          begin
          inc(conta_registros);
          write(conta_registros:5,' : ');
          for i:=1 to num_campos do
            begin
            readln(archAux2,linea);
            write(' [',linea,'] ');
            end;
          writeln;
          end;
        modificando:=true;
        while modificando do
          begin
          modifichar:=' ';
          writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
          write(' Opciones: [A]ctualizar datos [E]liminar registro [N]o modificar : ');
          recibe_tecla_rea(op);
          case op of
            'a','A': actualiza_dato(archAux2,archAlmacen,num_campos);
            'e','E': elimina_regist(archAux2,num_campos);
            'n','N': begin
                     modifichar:=op;
                     goto no_cambia1;
                     end;
            end;
          writeln;
          write('  Desea continuar la edicion de este bloque? [S]i o [N]o : ');
          recibe_si_no(modifichar);
{label!}  no_cambia1:
          if (modifichar='n') or (modifichar='N') then
            modificando:=false
          else
            muestra_archivo(archAux2,c2,num_campos);
          end;
            add_archivos(archAux2,archAux3);
        end;

    copia_archivos(archAux3,archAux1);
    empaqueta_repositorio(archAlmacen,archAux1,archAux0,num_campos);
    copia_archivos(archAux0,archReposit);
    erase(archAux3); close(archAux3);
    erase(archAux2); close(archAux2);
    erase(archAux1); close(archAux1);
    erase(archAux0); close(archAux0);
    erase(archAlmacen); close(archAlmacen);
    close(archReposit);
    close(archEstruct);
    writeln;
    writeln('  Archivo de repositorio recorrido satisfactoriamente');
    writeln('  Regresando al menu de operaci¢n de repositorio ...');
    delay(2000);
    end;
    {Fin del modulo PPrincipal > desarrolla_menu > repositorio > opera_reposit > rea_registro}

    procedure rea_condicion(name1,name2:string; var archEstruct,archReposit:text);
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit}
    {Recupera, elimina y actualiza grupo de datos que cumplen determinadas condiciones en base a estructura}
    var
      op:char;
      numreg2,cont,numregist,num_de_camp,num_campos,i:integer;
      new_conte,datow,datox,dato_p,tipox,campo_p,campox,nombre,tipo:string;
      archAlmacen,archAux0,archAux1,archAux2:text;
      stop2, stop: boolean;
    {Inicio del modulo PPrincipal > desarrolla_menu > repositorio > opera_reposit > rea_condicion}
    begin
      barra_identidad;
      writeln('                Recuperaci¢n, eliminaci¢n y actualizaci¢n por condiciones');
      writeln;
      writeln(' Archivo donde se almacena el repositorio:');
      writeln(' ',name2);
      writeln;
      writeln(' Archivo que contiene la estructura del repositorio:');
      writeln(' ',name1);
      writeln;
      reset(archReposit);
      assign(archAux0,'aux0.txf'); rewrite(archAux0);
      assign(archAux1,'aux1.txf'); rewrite(archAux1);
      assign(archAux2,'aux2.txf'); rewrite(archAux2);
      assign(archAlmacen,'almacen.txf'); rewrite(archAlmacen);
      {Cargo datos de archivo de estructura}
      num_campos:=captura_numcampos(archEstruct);
      reset(archEstruct);
      For i:=1 to 4 do
        readln(archEstruct);
      For i:=1 to num_campos do
        begin
        captura_campos(archEstruct,nombre,tipo);
        writeln(ArchAlmacen,nombre);
        writeln(ArchAlmacen,tipo);
        end;
      desempaqueta_repositorio(archReposit,archAux1);
      reset(archAux1);
      reset(ArchAlmacen);
      Writeln(' Los campos disponibles de acuerdo a la estructura son:');
      While not eof(ArchAlmacen) do
      Begin
       readln(ArchAlmacen, campox);
       readln(ArchAlmacen, tipox);
       writeln('  ',Campox,' [',tipox,'] ');
      End;
      writeln;
      write(' Elija el campo con el que desea trabajar: ');
      readln(campo_p);

      {Sacando el n£mero del campo pedido}
      reset(archAlmacen);
      stop:= false;
      num_de_camp:=0;
      While not (eof(ArchAlmacen)) and (stop=false) do
      Begin
      readln(ArchAlmacen, campox);
      readln(ArchAlmacen);
      inc(num_de_Camp);
      if campox= campo_p then stop:=true;
      End;
      write(' Ingrese el dato que desea recuperar: ');
      readln(Dato_p);
      barra_identidad;
      writeln('                  Recuperaci¢n, eliminaci¢n y actualizaci¢n por condici¢n');
      writeln;
      writeln('Recuperaci¢n del repositorio guardado en ',name2);
      writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
      {Imprimiendo nombre de columnas}
      write(' Registro: ');
      inc(cont);
      reset(ARchAlmacen);
      While not eof(ArchAlmacen) do
      Begin
       readln(ArchAlmacen, campox);
       readln(ArchAlmacen);
       write(' [',campox,'] ');
      End;
      writeln;
      writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');

       {Ahora buscando dato de campo en Arch1 y sacando el numero de registro }
         numregist:=0;
         reset(ArchAux1);

         While not eof(ARchAux1) do
         Begin
          inc(numregist);
          For i:=1 to num_campos do
          BEgin
           If i=num_de_camp then
           Begin
            readln(ArchAux1, Datox);
{Importante}If DAtox=dato_p then
            Begin
            {Imprimiendo DAtos}
             write(numregist:5,' : ');
             cont:=0;
             stop2:=false;
             reset(ArchAux1);
             While (stop2=false) do
             Begin
              inc(cont);
              if cont=numregist then
              Begin
               For i:=1 to num_campos do
               Begin
                readln(ArchAux1, datow);
                write(' [',datow,'] ');
               End;
               writeln;
               stop2:=true;
              End
              else For i:=1 to num_campos  do readln(ArchAux1);
             End;
            End;
           End
           else readln(ARchAux1);
          ENd;
          End;
          writeln('ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
          write(' Opciones: [A]ctualizar datos [E]liminar registro [N]o modificar : ');
          recibe_tecla_rea(op);
          case op of
             'A','a': Begin
                      {Sacando el n£mero de el campo pedido}
                        reset(archAlmacen);
                        stop:= false;
                        num_de_CAmp:=0;
                        While not (eof(ArchAlmacen)) and (stop=false) do
                        Begin
                          readln(ARchAlmacen, campox);
                          readln(ArchAlmacen);
                          inc(num_de_Camp);
                          if campox= campo_p then stop:=true;
                        End;
                       {ahora buscando dato de campo en ARch1
                        y sacando el numero de registro }
                        numregist:=0;
                        numreg2:=0;
                        reset(ArchAux1);
                        rewrite(ArchAux2);
                        While not eof(ARchAux1) do
                        Begin
                          inc(numregist);
                          For i:=1 to num_campos do
                          BEgin
                            If i=num_de_camp then
                            Begin
                              readln(ARchaux1, datox);
                 {Importante} If DAtox=dato_p then {hace la comparaci¢n}
                              Begin
                                cont:=1;
                                stop2:=false;
                                reset(ArchAux1);
                             {A continuaci¢n copia todo ArchAux1 en ArchAux2
                             con la modificaci¢n}
                                While (stop2=false) do
                                Begin
                                  While (numreg2<cont) and (cont<numregist) do
                                  Begin
                                    inc(cont);
                                    For i:=1 to num_campos do
                                    Begin
                                     readln(ARchAux1, datow);
                                     writeln(ArchAux2, datow);
                                    End;
                                  ENd;
                                  While cont<=numreg2 do
                                  Begin
                                    inc(cont);
                                    For i:=1 to num_campos do
                                    Begin
                                      readln(ArchAux1);
                                    End;
                                  End;
                                  While cont= numregist do
                                  Begin
                                    inc(cont);
                                    For i:=1 to num_campos do
                                    Begin
                                      readln(ARchAux1, datow);
                                      if i=num_de_camp then
                                      Begin
                                        write('  Registro: ',numregist:3,' / Dato nuevo [',campo_p,'] : ');
                                        readln(New_conte);
                                        writeln(ArchAux2,new_conte);
                                      End
                                      Else writeln(ArchAux2, datow);
                                    End;
                                    numreg2:=numregist;
                                    stop2:=true;
                                  End;
                                End;
                              End
                            End
                            Else readln(ArchAux1);
                          ENd;
                        End;
                    {Lo siguiente copia, en ArchAux2, lo que falta de ARchAux1}
                        Reset(ArchAux1);
                        numregist:=0;
                        While not eof(ArchAux1) do
                        Begin
                          inc(numregist);
                          If numregist>numreg2 then
                          begin
                            For i:=1 to num_campos do
                            Begin
                              Readln(ArchAux1,datow);
                              writeln(Archaux2, datow);
                            End;
                          end
                          Else
                          Begin
                            For i:=1 to num_campos do
                            BEgin
                              readln(ArchAux1);
                            End;
                          End;
                        End;
                      copia_archivos(ArchAux2, ArchAux1);
                      writeln;
                      writeln('  La actualizaci¢n se ha realizado con ‚xito');
                      End;

             'e','E': Begin
                        {Sacando el n£mero del campo pedido}
                        reset(archAlmacen);
                        stop:= false;
                        num_de_CAmp:=0;
                        While not (eof(ArchAlmacen)) and (stop=false) do
                        Begin
                          readln(ARchAlmacen, campox);
                          readln(ArchAlmacen);
                          inc(num_de_Camp);
                          if campox= campo_p then stop:=true;
                        End;

                   {Ahora buscando dato de campo en ARch1
                        y sacando el n£mero de el registro }
                        numregist:=0;
                        numreg2:=0;
                        reset(ArchAux1);
                        rewrite(ArchAux2);
                        While not eof(ARchAux1) do
                        Begin
                          inc(numregist);
                          For i:=1 to num_campos do
                          BEgin
                            If i=num_de_camp then
                            Begin
                              readln(ARchaux1, datox);
                 {Importante} If DAtox=dato_p then {hace la comparaci¢n}
                              Begin
                                cont:=1;
                                stop2:=false;
                                reset(ArchAux1);
                             {A continuaci¢n copia todo ArchAux1 en ArchAux2
                             hasta antes del ultimo registro encontrado}
                                While (stop2=false) do
                                Begin
                                  While (numreg2<cont) and (cont<numregist) do
                                  Begin
                                    inc(cont);
                                    For i:=1 to num_campos do
                                    Begin
                                     readln(ARchAux1, datow);
                                     writeln(ArchAux2, datow);
                                    End;
                                  ENd;
                                  While cont<=numreg2 do
                                  Begin
                                    inc(cont);
                                    For i:=1 to num_campos do
                                    Begin
                                      readln(ArchAux1);
                                    End;
                                  End;
                                  While cont= numregist do
                                  Begin
                                    inc(cont);
                                    For i:=1 to num_campos do
                                    Begin
                                      readln(ARchAux1);
                                    End;
                                    numreg2:=numregist;
                                    stop2:=true;
                                  End;
                                End;
                              End
                            End
                            Else readln(ArchAux1);
                          ENd;
                        End;
                        {Lo siguiente copia en
                         ArchAux2 lo que falta de ARchAux1}
                        Reset(ArchAux1);
                        numregist:=0;
                        While not eof(ArchAux1) do
                        Begin
                          inc(numregist);
                          if numregist>numreg2 then
                          begin
                            For i:=1 to num_campos do
                            Begin
                              Readln(ArchAux1,datow);
                              writeln(Archaux2, datow);
                            End;
                          end
                          Else
                          Begin
                            For i:=1 to num_campos do
                            BEgin
                              readln(ArchAux1);
                            End;
                          End;
                        End;
                      copia_archivos(ArchAux2, ArchAux1);
                      writeln;
                      writeln('  La eliminaci¢n se ha realizado con ‚xito');
                      End;
             End;
      writeln(' Pulse cualquier tecla para continuar.');
      readkey;
      empaqueta_repositorio(archAlmacen,archAux1,archAux0,num_campos);
      copia_archivos(archAux0,archReposit);
      erase(archAux2);
      erase(archAux1); close(archAux1);
      erase(archAux0); close(archAux0);
      erase(archAlmacen); close(archAlmacen);
      close(archReposit);
      close(archEstruct);
      writeln;
      writeln('  Archivo de repositorio recorrido satisfactoriamente');
      writeln('  Regresando al menu de operaci¢n de repositorio ...');
      delay(2000);
    end;
    {Fin del modulo PPrincipal > desarrolla_menu > repositorio > opera_reposit > rea_condicion}

    procedure export_csv_rep(name1,name2:string; var archEstruct,archReposit:text);
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit}
    {Convierte el grupo de datos almacenado en repositorio a un archivo CSV}
    var
      num_campos,i,conta_registros:integer;
      nombre,tipo,dato,name3:string;
      archAux1,archCSV:text;
    {Inicio del modulo PPrincipal > desarrolla_menu > repositorio > opera_reposit > export_csv_rep}
    begin
      barra_identidad;
      writeln('                                 Exportaci¢n de repositorio a formato CSV');
      writeln;
      writeln(' Archivo donde se almacena el repositorio:');
      writeln(' ',name2);
      writeln;
      writeln(' Archivo que contiene la estructura del repositorio:');
      writeln(' ',name1);
      writeln;
      if pos('.',name2)<>0 then
        name3:=copy(name2,1,pos('.',name2))+'csv'
      else
        name3:=name2+'.csv';
      {Comprueba existencia de nombre de archivo CSV}
      if existe(name3) then
        begin
        writeln(' Ingrese nombre de archivo donde se guardara el archivo CSV');
        writeln(' Distinto de : ',name3);
        write(' ');    readln(name3)
        end
      else
        begin
        writeln(' El archivo CSV se guardara en la siguiente ubicaci¢n: ');
        writeln(' ',name3)
        end;
      assign(archCsv,name3);
      rewrite(archCsv);
      write(archCsv,'Registro,');
      {Cargo datos de archivo de estructura}
      reset(archEstruct);
      num_campos:=captura_numcampos(archEstruct);
      reset(archEstruct);
      for i:=1 to 4 do
        readln(archEstruct);
      for i:=1 to num_campos do
        begin
        captura_campos(archEstruct,nombre,tipo);
        if i<>num_campos then
          write(ArchCSV,nombre,',')
        else
          writeln(ArchCSV,nombre)
        end;
      conta_registros:=0;
      assign(archAux1,'aux1.txf');
      desempaqueta_repositorio(archReposit,archAux1);
      reset(archAux1);
      while not eof(archAux1) do
        begin
        inc(conta_registros);
        write(archCsv,conta_registros,',');
        for i:=1 to num_campos do
          begin
          readln(archAux1,dato);
          if i<>num_campos then
            write(ArchCSV,dato,',')
          else
            writeln(ArchCSV,dato)
        end;
        end;
      erase(archAux1);
      close(archAux1);
      close(archCsv);
      writeln;
      writeln(' Archivo convertido satisfactoriamente');
      writeln(' Pulse cualquier tecla para continuar.');
      readkey;
      writeln(' Regresando al menu de operaci¢n de repositorio ...');
      delay(2500);
    end;
   {Fin del modulo PPrincipal > desarrolla_menu > repositorio > opera_reposit > export_csv_rep}

    procedure export_html_rep(name1,name2:string; var archEstruct,archReposit:text);
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit}
    {Convierte los datos almacendaos en un repositorio en un archivo de hipertexto}
    var
      num_campos,i,conta_registros:integer;
      nombre,tipo,dato,name3:string;
      archAux1,archHTML:text;
    {Ubicacion: PPrincipal > desarrolla_menu > repositorio > opera_reposit > export_html_rep}
    begin
      barra_identidad;
      writeln('                                Exportaci¢n de repositorio a formato HTML');
      writeln;
      writeln(' Archivo donde se almacena el repositorio:');
      writeln(' ',name2);
      writeln;
      writeln(' Archivo que contiene la estructura del repositorio:');
      writeln(' ',name1);
      writeln;
      if pos('.',name2)<>0 then
        name3:=copy(name2,1,pos('.',name2))+'htm'
      else
        name3:=name2+'.htm';
      {Comprueba existencia de nombre de archivo HTML}
      if existe(name3) then
        begin
        writeln(' Ingrese nombre de archivo donde se guardara el archivo HTML');
        writeln(' Distinto de : ',name3);
        write(' ');    readln(name3)
        end
      else
        begin
        writeln(' El archivo CSV se guardara en la siguiente ubicaci¢n: ');
        writeln(' ',name3)
        end;
      assign(archHtml,name3);
      rewrite(archHtml);
      writeln(archHtml,'<html>');
      writeln(archHtml,'<head>');
      writeln(archHtml,'<title>Repositorio exportado con XML Reader</title>');
      writeln(archHtml,'<STYLE type=text/css>');
      writeln(archHtml,'.techtext {font-family: Arial; font-size: 10pt; color: black; text-decoration: none }');
      writeln(archHtml,'.barra {font-family: Verdana; font-size: 10pt; color: #FFFFFF; text-decoration: none}');
      writeln(archHtml,'</STYLE>');
      writeln(archHtml,'</head>');
      writeln(archHtml,'<body>');
      writeln(archHtml,'<table width=400 border=1 cellspacing=1 class=techtext bgcolor="#F8ECD0" bordercolor=white>');
      {Cargo datos de archivo de estructura}
      reset(archEstruct);
      writeln(archHtml,' <tr align=center bgcolor="#5F5F7F" class=barra>');
      writeln(archHtml,'  <td>Registro</td>');
      num_campos:=captura_numcampos(archEstruct);
      reset(archEstruct);
      for i:=1 to 4 do
        readln(archEstruct);
      for i:=1 to num_campos do
        begin
        captura_campos(archEstruct,nombre,tipo);
        writeln(ArchHtml,'  <td>',nombre,'</td>');
        end;
      writeln(archHtml,' </tr>');
      conta_registros:=0;
      assign(archAux1,'aux1.txf');
      desempaqueta_repositorio(archReposit,archAux1);
      reset(archAux1);
      while not eof(archAux1) do
        begin
        inc(conta_registros);
        writeln(archHtml,' <tr align=center>');
        writeln(archHtml,'  <td>',conta_registros,'</td>');
        for i:=1 to num_campos do
          begin
          readln(archAux1,dato);
          writeln(ArchHtml,'  <td>',dato,'</td>');
          end;
        writeln(archHtml,' </tr>');
        end;
      writeln(archHtml,' </table>');
      writeln(archHtml,' </body>');
      writeln(archHtml,' </html>');
      erase(archAux1);
      close(archAux1);
      close(archHtml);
      writeln;
      writeln(' Archivo convertido satisfactoriamente');
      writeln(' Pulse cualquier tecla para continuar.');
      readkey;
      writeln(' Regresando al menu de operaci¢n de repositorio ...');
      delay(2500);
    end;
    {Fin del modulo PPrincipal > desarrolla_menu > repositorio > opera_reposit > export_html_rep}

    {Inicio del modulo PPrincipal > desarrolla_menu > repositorio > opera_reposit}
    var
      archReposit,archEstruct:text;
      name1,name2:string;
      salida:boolean;
      op_o:byte;
    begin
    barra_identidad;
    writeln('                                      [3] Activar el repositorio de datos');
    writeln;
    writeln(' Ingrese ubicaci¢n de archivo donde se almacena el repositorio');
    writeln(' Por ejemplo C:\directorio\carpeta\archivo.xml');
    barrera_si_existe(name2,salida);
    writeln(' Ingrese ubicaci¢n de archivo que contiene la estructura del repositorio');
    barrera_si_existe(name1,salida);
    if not salida then
      begin
      assign(archReposit,name2);
      assign(archEstruct,name1);
      if not (es_reposit(archReposit) and si_fue_generado(archEstruct,archReposit)) then
        begin
        writeln(' El archivo que deberia contener el Repositorio no fue creado con tal fin');
        writeln(' o el archivo de Repositorio no fue generado con el archivo de Estructura');
        end
      else
        begin
        repeat
          barra_identidad;
          writeln('                                      [3] Activar el repositorio de datos');
          writeln;
          writeln(' Archivo de repositorio: ',name2);
          writeln(' Archivo de estructura: ',name1);
          writeln;
          muestra_menu_opera;
          {$I-}
          readln(op_o);
          {$I+}
          delay(500);
          if ioresult=0 then
            begin
            case op_o of
            1: rea_registro(name1,name2,archEstruct,archReposit);
            2: rea_condicion(name1,name2,archEstruct,archReposit);
            3: export_csv_rep(name1,name2,archEstruct,archReposit);
            4: export_html_rep(name1,name2,archEstruct,archReposit);
            0: ;
            else
              begin
              writeln('           Confirme ingreso de opcion correcta');
              delay(1000);
              end;
            end;
            end
          else
            begin
            op_o:=10;
            writeln('           Confirme ingreso de opcion correcta');
            delay(1000);
            end;

        until op_o=0;
        end;
      end;
    writeln;
    writeln(' Regresando al menu principal...');
    delay(2500);
    end;
    {Fin del modulo PPrincipal > desarrolla_menu > repositorio > opera_reposit}

  {Inicio del modulo PPrincipal > desarrolla_menu > repositorio}
  var
    op_r:byte;
  begin
  repeat
    barra_identidad;
    writeln('                                      [3] Activar el repositorio de datos');
    writeln;
    muestra_menu_reposit;
    {$I-}
    readln(op_r);
    {$I+}
    delay(500);
    if ioresult=0 then
      begin
      case op_r of
        1: def_estruct;
        2: gen_reposit;
        3: opera_reposit;
        0: ;
      else
        begin
        writeln('          Confirme ingreso de opcion correcta');
        delay(1000);
        end;
      end;
      end
    else
      begin
      op_r:=10;
      writeln('           Confirme ingreso de opcion correcta');
      delay(1000);
      end;
  until op_r=0
  end;
  {Fin del modulo PPrincipal > desarrolla_menu > repositorio}


procedure desarrolla_menu;
{Ubicacion: PPrincipal}
{SubPrograma Principal}
var op:byte;
begin
repeat
  muestra_menu;
  {$I-}
  readln(op);
  {$I+}
  delay(500);
  if ioresult=0 then
    begin
    case op of
      1: crear;
      2: trabajar;
      3: repositorio;
      0: ;
    else
      begin
      writeln('              Confirme ingreso de opcion correcta');
      delay(1000);
      end;
    end;
    end
  else
    begin
    op:=10;
    writeln('              Confirme ingreso de opcion correcta');
    delay(1000);
    end;
until op=0
end;

{programa principal}
begin
desarrolla_menu;
clrscr;
barra_identidad;
writeln('                                  [0] Finalizar la ejecuci¢n del programa');
writeln;
writeln;
writeln(' ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
writeln('  Pontificia Universidad Cat¢lica del Per£');
writeln('  Estudios Generales Ciencias             ');
writeln(' ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
writeln('  XML Prodigy en un programa desarrollado ');
writeln('          en el marco del curso de        ');
writeln('  T‚cnicas de programaci¢n - INF1440433   ');
writeln('                Ciclo 2004-I              ');
writeln;
writeln('       Gracias por usar este software     ');
writeln(' ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ');
delay(3500);
end.