#!/usr/bin/perl -I/usr/local/lib/simusol
use strict;
use warnings;
use Data::Dumper;
use Auxiliares;
use GlobalesSimusol;
use Ayudas;
#use locale;
#use POSIX;
#use POSIX qw(locale_h);

#----------------------------------------------------------------------------
use Getopt::Long;
use Pod::Usage;
use Algebraico;
$0 =~ m!/([^/]+)\s*$!;
$progname = $1;
my $largo = 60 - length($progname); 
my $opc_arg = paraimpr3puntos($largo,@ARGV);
$opt_hash{graf} = 3;
GetOptions(\%opt_hash, 'listar', 'impr', 'escala=i', 'graf=s', 'nosim',
              'notrad', 'noverb','todas=s' , 'd', 'help', 'version', 'backup',
              'comp','comocopia', 'cadena',#'png',
              'modelos=s@', 'elementos=s@', 'buscar=s','path=s',
              'patronno=s', 'patronsi=s' , 'reg=s')
      or pod2usage(2);
help() if defined $opt_hash{'help'};
version() if defined $opt_hash{'version'};
$Ayudas::presentacion = '*'x 3 . " S I M U S O L  " . `date`;
# --------------------------------------------------------------------------

$debug = $opt_hash{d}; #$debug está definida con our en Ayudas.pm
$noverb = $opt_hash{noverb};
# -----------------------------------------------------------------------------
my (@dirarray, @archivos, @sindia, %numarch, $ext); my $currentdir = `pwd`;
my $textoARGV = "@ARGV";
$ext = opciones_extension();my $maxi = 6; $maxi = 1 if $ext ne 'dia';
if (@ARGV == 0 or @ARGV >$maxi or $textoARGV =~ /[\*\?]/ or $opt_hash{buscar}
    or ($textoARGV =~ tr/ // > 0 and $opt_hash{notrad})
    or $textoARGV =~ tr/ // > $maxi) {
    if ($opt_hash{buscar}) {
         $imprlog = 1;
         open LOGPRIN, ">simusol.log";   
         print LOGPRIN 'Partimos de ' . scalar @ARGV . ' archivos ',`date`; 
    }; 
    @dirarray = elegir_archivos($ext);
    print LOGPRIN ' Quedan ', scalar @dirarray, `date` if $imprlog;
} else {
    @dirarray = ($textoARGV); 
};
@archivos = @dirarray; @archivos = split /\s+/, $dirarray[0] if @dirarray == 1;
@archivos >1 and abrir_LSS1('simusol',$progname,0);
if (@dirarray == @archivos) {
    @sindia = @dirarray; map (s/\.dia$//,@sindia);
    for (my $i = 0; $i < @dirarray; $i++) {
        $numarch{$sindia[$i]} = $i + 1;
        $numarch{"$sindia[$i].dia"} = $i + 1;
    };
} elsif (@dirarray < @archivos) {
    @sindia = @archivos; map (s/\.dia$//, @sindia);
    for (my $i = 0; $i < @archivos; $i++) {
        $numarch{$sindia[$i]} = 1;
        $numarch{"$sindia[$i].dia"} = 1;
    }; 
} elsif (@dirarray == 0) {
     print STDERR ' ' . '=' x70 . " 
     ==== En el directorio de trabajo 
	      $currentdir";
     print STDERR "             y subdirectorios ...\n" if $opt_hash{buscar};  
     print STDERR 
         "no queda ningun diagrama  preparado con Dia para ser simulado"; 
     if (@ARGV and $ARGV[0] ne '*') {
        print STDERR " que responda a \n  ", paraimpr3puntos(50,@ARGV),"\n";
     } else {print STDERR "\n"};
     if ($opt_hash{buscar}) {
       print STDERR "     Quizás pidió 
               -buscar *    
        en lugar de 
	       -buscar '*'\n";  
     };
     print STDERR ' ' . '=' x70 . "\n";
     die "\n";
};

# -----------------------------------------------------------------------------
if ($opt_hash{impr}) {
    explic("Por preparar archivos para inclusión en documentos (o impresión)");
    map(impre_diag($_),@dirarray);
    explic('=' x 70);
    exit 0;
};
if ($opt_hash{backup}) { 
   backupear(@dirarray);
   exit 0
}; 
if ($opt_hash{listar}) { 
   my @dirarraysindia = @dirarray;
   map (s/\.dia$//,@dirarraysindia);
   print  join ("\n",@dirarray), "\n";
   print 
   "Quiere hacer un comprimido de todo de nombre diagramas.tar.gz? (s|y|n)  ";
   my $resp =<STDIN>;
   lc($resp) =~ /[sy]/ or exit; 
   my @todos = @dirarray;
   for my $ext ('res','simul','caj','d','paraplot') {
       my @otros = @dirarray;
       map ($_ .= ".$ext",@otros); @otros = grep (do{-f $_},@otros); 
       push @todos,@otros;
   };
   my $todosstring = join ' ',@todos;
   system "tar -czvf diagramas.tar.gz $todosstring"; 
   exit 0
};
 
if ($opt_hash{comp}) {
    my @abackup = @sindia;
    @abackup = grep(do{ -e "$_.caj" and not -e "$_.caj1"}, @abackup);
    backupear(@abackup) if @abackup;	 
};
# --------------------------------------------------------------------------   
our ($codigo_s1, $codigo_sc, $codigo_s2, $codigo_s3) = ({}, {}, {}, {});
my ($paratrad, $parasim1, $soloelemod, $parasceptre, $para2, $solograficar
    , $mal, $scmal,$sinnada, $notradnod,$codigo_1mal)
      = ([], [], [], [], [], [], [], [], [], []);
map(do{$codigo_s1->{$_} = 99; $codigo_sc->{$_} = 99; 
       $codigo_s2->{$_} = 99; $codigo_s3->{$_} = 99}
       , @dirarray);
if ($ext eq 'd') {
    @$parasceptre = @dirarray; map (s/\.d$//,@$parasceptre);
} elsif ($ext eq 'paraplot') {
    @$solograficar = @dirarray; map (s/\.paraplot$//,@$solograficar);
} else {
    @$paratrad = @dirarray;  
};
if ($imprlog) {
    print LOGPRIN "Resultados de llamados por S I M U S O L
        por comando $progname $opc_arg";
};
# --------------------------------------------------------------------------   
if (@$paratrad and not $opt_hash{notrad}) {
    ($soloelemod,$parasceptre, $solograficar, $mal, $sinnada) = 
           traducir_diagramas($paratrad, \@dirarray, \%numarch, $imprlog);
    #en @$parasceptre vienen con su extension .d ; en @$mal sin extension
    #$codigo_s1
    #impr_debug(__LINE__.' sim0 $soloelemod ',Dumper $soloelemod);
    #impr_debug(__LINE__.' sim0 $parasceptre ',Dumper $parasceptre);
    #impr_debug(__LINE__.' sim0 $mal ',$mal);
    @$codigo_1mal = grep($codigo_s1->{$_}, keys %$codigo_s1);
    foreach my $archivo (@$codigo_1mal) {
        next if $archivo =~ /\s/;
        system "rm $archivo.res $archivo.simul 2>/dev/null";  
    };
};
#impr_debug(__LINE__.' sim0 $parasceptre ',$parasceptre);
# --------------------------------------------------------------------------  
if (@$parasceptre) {
    if ($opt_hash{nosim}) {
        explic(' Se ha pedido no simular diagramas con -nosim'); 
    } else {
         ($para2,$scmal)
            = simular_diagramas($parasceptre, \@dirarray, \%numarch, $imprlog);
        map (do{system "rm $_.simul 2>/dev/null"},@$mal);
    };
   
};

if (@$para2 and not $opt_hash{nosim}) {
     
#    my ($parag,$mal)
#      = interpretar_diagramas($para2, \@dirarray, \%numarch, $imprlog);
    push @$solograficar, @$para2;
};   
# --------------------------------------------------------------------------   

if (@$solograficar) {
    if (not $opt_hash{graf}){
        mensaje(' Se ha pedido no hacer ni preparar gráficos con -graf 0'); 
        parar0();
    };
    @$solograficar = sort {$numarch{$a} <=> $numarch{$b}} @$solograficar;
    my $mal
       = graficar_diagramas($solograficar, \@dirarray, \%numarch, $imprlog);
};
# --------------------------------------------------------------------------   
if (@dirarray and $opt_hash{comp}) {
    print LOGPRIN '   Hay ' , scalar @dirarray , ' archivos ',`date`
        if $imprlog;
    comparar_todo($codigo_s1, $codigo_sc, $codigo_s2, $codigo_s3
                  , @dirarray);
    print LOGPRIN `date` if $imprlog;
} elsif (not $opt_hash{comp}) {
    my $arch = $dirarray[0];
    my $archSINDIA = $arch; $archSINDIA =~ s/\.dia$//;
   
    if (-e "$archSINDIA.lss1") { 
        if (not system "grep 'ERROR GRAVE' $archSINDIA.lss1 >/dev/null") {
            if ($codigo_s1->{$arch} <250) {        
                explic(' ----------- REITERACION DE MENSAJES: -------');
                my @errores = `cat $archSINDIA.lss1`;
                @errores = grep(do{ $_!~/Mensajes de/ and $_ !~ /de fecha/}
                            , @errores);
                print @errores;
            } else {# hay .d que no se ejecuta
                explic(
                " Vuelva a ver los mensajes en $archSINDIA.lss1"); 
            };
        } elsif (not system "grep 'ERROR ' $archSINDIA.lss1 >/dev/null") {
            explic( " Hubo avisos; véalos en el archivo  $archSINDIA.lss1"); 
        };
    };
};  
parar0();

#fin principal         
# -----------------------------------------------------------------------------
sub opciones_extension{
  if ($opt_hash{reg}) {
      die "\"-reg\" es una opción obsoleta; se ha cambiado por \"buscar\"\n"; 
  };
  if ($opt_hash{modelos} or $opt_hash{elementos}) {
      die "\"-modelos\"  o \"-elementos\" son opciones obsoletas; 
      simplemente indique, los nombres de 
      todos los diagramas que quiera procesar juntos separados por espacios\n";
  };
  my $ext = 'dia';
  if ($opt_hash{impr}  or $opt_hash{escala} or $opt_hash{listar}
      or $opt_hash{todas}) {
      if ($opt_hash{notrad} or $opt_hash{nosim} ) {
          explic("Las opciones -notrad y -nosim no tienen sentido 
          si aparecen juntas con  -impr -escala o -listar");
          delete $opt_hash{notrad}; delete $opt_hash{nosim};
      };
  }; 
  if ($opt_hash{notrad}) {
      $ext = 'd';
      explic(' Se ha pedido no traducir diagramas ' . '-' x 15); 
  };
  if ($ext eq 'd' and $opt_hash{nosim}) {
      $ext = 'dirac';
      explic(' Se ha pedido no simular diagramas ' . '-' x 15); 
  }; 
  if (defined $opt_hash{graf} and $opt_hash{graf} == 4) {
      $ext = 'paraplot';
      explic(' Se ha pedido sólo graficar ' . '-' x 15);
  };
  return $ext;
} #tratar_opciones         
# -----------------------------------------------------------------------------
sub parar0{
  comfin('com parar0');
  comfin('fin parar0');
  exit 0;
}
# -----------------------------------------------------------------------------
sub traducir_diagramas{
  comfin('com traducir_diagramas', @_);
  my ($dirarr, $refdirarray, $refnumarch, $imprlog) = @_;
  #impr_debug(__LINE__.' sim0 $refdirarray ',Dumper $refdirarray);
  my $opciones_sim1 = '';  
  $opciones_sim1 = ' -d ' if $opt_hash{d};
  $opciones_sim1 .= ' -noverb  ' if $opt_hash{noverb};
  $opciones_sim1 .= " -todas $opt_hash{todas}" if $opt_hash{todas};
  $opciones_sim1 .= ' -comocopia' if $opt_hash{comocopia};
  $opciones_sim1 .= ' -cadena' if $opt_hash{cadena};
  my ($coderror, $soloelemod, $parasceptre, $solograficar, $mal)
        = ('',[],[],[]);
  #impr_debug(__LINE__.' sim0 $refdirarray ',Dumper $refdirarray);
  #impr_debug(__LINE__.' sim0 $refnumarch ',Dumper $refnumarch);
  #impr_debug(__LINE__.' sim0 $dirarr ',Dumper $dirarr);
  print LOGPRIN 'Quedan ' , scalar @dirarray , ' archivos ',`date`
      if $imprlog;
  # @$dirarray puede ser un soloarchivo multiple o uno o mas simles
  my $cuantos = ($dirarr->[0] =~ tr/[ ]//);
  my @listarchivossindia;
  $cuantos and #se trata de archivo multiple
  do {$imprlog = '';
      @listarchivossindia = split /\s+/, $dirarr->[0];
      map (s/\.dia$//,@listarchivossindia);
      map (do {system "rm $_.d $_.paraplot 2>/dev/null"}
          ,@listarchivossindia ); 
  };
 # impr_debug(__LINE__.' sim0 $dirarr ',Dumper $dirarr);
   
  foreach my $archivo (@$dirarr) {
     my $archivosindia = $archivo;
#impr_debug(__LINE__.' sim0 $archivosindia $cuantos',[$archivosindia,$cuantos]);
     $cuantos or 
	 do {$archivosindia =~ s/\.dia$//;
	     abrir_LSS1("$archivosindia",$progname,0);
          my $norden = $refnumarch->{$archivosindia};
	     my $archch = $refdirarray->[$norden-1];
	     eco("Por traducir $norden: $archch",1) if $imprlog;
	     system "rm $archivosindia.d $archivosindia.paraplot  2>/dev/null"; 
  };
#     impr_debug(__LINE__.' sim0 $archivo',$archivo);
      my $codigosim1 = system 
       "$SIMUSOLBINDIR/simusol1.pl $opciones_sim1 \"$archivo\"";
      $codigosim1 = $codigosim1/256;
      if ($cuantos) {
	  if ($codigosim1) {
              parar0();
	  } else {
              my @buenos 
                = grep (do{-e "$_.d" and 
                           system "grep MODEL.DESCRIPTION $_.d >/dev/null" or
			   -e "$_.paraplot"}
                       ,@listarchivossindia); 
              @buenos == 1 or error_progr(0,__LINE__.' simusol');
              $archivosindia = $buenos[0];
          }; 
      };
      $codigo_s1->{$archivo} = $codigosim1;
      if ($codigosim1 == 1) {
          push @$soloelemod, $archivosindia;
      } elsif ($codigosim1 == 2) {
          push @$solograficar, $archivosindia;
      } elsif ($codigosim1 == 3) {
          push @$sinnada, $archivosindia;;
      } elsif ($codigosim1 == 255) {exit 255; #por error_prog
      } elsif ($codigosim1 >3) {  
          push @$mal,$archivosindia; 
      } elsif ($codigosim1 == 0 and $opt_hash{todas} ) {
          # solo se usa para tratamiento individual
          my $archguardar = $archivo;
          $archguardar = "gnus/$archguardar"."_$opt_hash{todas}"; 
          $archguardar=~ s/\s+/_/g;
          $parasceptre = [$archguardar];            
      } else { #$codigosima1  0
          push @$parasceptre,$archivosindia;
      };
      #impr_debug(__LINE__.' sim0 @$parasceptre ',$parasceptre);
      next unless $imprlog;
      printf LOGPRIN  "sim1: %3i   %4i", $codigosim1,$numarch{$archivo};
      print LOGPRIN " $archivo\n" ;  
  };
  print LOGPRIN `date` if $imprlog;
  comfin('fin traducir_diagramas');
  return ($soloelemod, $parasceptre, $solograficar, $mal, $sinnada);
}  # traducir_diagramas
# ---------------------------------------------------------------------------
sub simular_diagramas{
  comfin('com simular_diagramas', @_);
  my ($parasceptre, $refdirarray, $refnumarch, $imprlog) = @_; 
  my $opciones_sceptre =''; 
  $opciones_sceptre .= ' -d ' if $opt_hash{d};
  $opciones_sceptre .= ' -noverb ' if $opt_hash{noverb};
  #$opciones_sceptre .= " -graf $opt_hash{graf} " if defined $opt_hash{graf};
  $opciones_sceptre .= ' -noverb'if  $opt_hash{noverb}; 


  #impr_debug(__LINE__.' sim0 $parasceptre ',$parasceptre);
  #impr_debug(__LINE__.' sim0 @$codigo_1mal ',$codigo_1mal);
  foreach my $archivosindia (@$codigo_1mal) {
      next if $archivosindia =~ /\s/;
      abrir_LSS1("$archivosindia", $progname,0) if $ext eq 'd';
      system "rm $archivosindia.res $archivosindia.simul 2>/dev/null";  
  };
  #impr_debug(__LINE__.' sim0 $parasceptre ',$parasceptre);
  if (@$parasceptre>1 and $opt_hash{graf} eq '2' and $opt_hash{d}) {
      my $resp; 
      if ($opt_hash{buscar}) {$resp = 2;
      } else { # no buscar
          print STDERR " Elija :
              0:   Terminar
              1:   Procesar parando para ver mensajes de error
              2:   Procesar sin detenerse (simusol.log, con res. de mensajes)
              (Enter o Return)  equivale a 2\n";simusol_sceptre implicit
          explic("\n ".'=' x 70);
          $resp = <STDIN>; chomp $resp;
      }; # if else buscar
          if ($resp eq '0') {
              explic('=' x 70 );
              exit 0;
          } elsif  ($resp eq '2' or $resp eq '') {
              $opciones_sceptre .= ' -nopausa '
          }; # if elsif  resp 
  } elsif (@$parasceptre>1) {
          pausaver('','simulando') if $opt_hash{d};
  }; # if else elsif not @parasceptre >1    
  my (@para2,@mal);
  #impr_debug(__LINE__.' sim0 $parasceptre ',[$ext,@$parasceptre]);
  #impr_debug(__LINE__.' sim0 $refnumarch ',Dumper $refnumarch);
  #impr_debug(__LINE__.' sim0 $refdirarray ',Dumper $refdirarray);
  print LOGPRIN 'Quedan ' , scalar @dirarray , ' archivos ',`date`
      if $imprlog;
  foreach my $archivosindia (@$parasceptre) {
      my $norden = $refnumarch->{$archivosindia};
      my $archch = $refdirarray->[$norden-1];
      system "rm $archivosindia.res $archivosindia.simul 2>/dev/null";
      abrir_LSS1("$archivosindia", $progname,0) if $ext eq 'd';
      eco("Por simular $norden: $archch",1) if $imprlog;
      impr_debug(__LINE__.' sims $archivosindia',$archivosindia); 
      my $coderr = system(
 "$SIMUSOLBINDIR/lolisol_sceptre.pl -noclas -o . -d $opciones_sceptre $archivosindia");
      $coderr and $coderr < 256 or $coderr = $coderr/256; 
      $codigo_sc->{$archch} = $coderr; 
      if ($coderr > 1) {
	  push @mal,$archivosindia;
      } else {
          push @para2, $archivosindia; 
      };
      next unless $imprlog;
      printf LOGPRIN  "scep: %3i   %4i", $coderr, $numarch{$archivosindia};
      print LOGPRIN " $archch\n";
  };
  print LOGPRIN `date` if $imprlog;
  comfin('fin simular_diagramas');
  return \@para2,\@mal;
};
# ---------------------------------------------------------------------------
sub interpretar_diagramas{
  comfin('com interpretar_diagramas', @_);
  my ($para2, $refdirarray, $refnumarch, $imprlog) = @_;
  my $opciones_sim2 = ''; my (@parag,@mal);
  $opciones_sim2 .= ' -d' if $opt_hash{d};
  $opciones_sim2 .= ' -noverb' if $opt_hash{noverb};
  print LOGPRIN 'Quedan ' , scalar @$para2 , ' archivos ',`date` if $imprlog;
  foreach my $archivo (@$para2) {
      my $archch;
      my $norden = $refnumarch->{$archivo};
      $archch= $refdirarray->[$norden-1];
      eco("Por interpretar resultados de  $norden: $archch",1) if $imprlog;
      my $coderr = system(
               "$SIMUSOLBINDIR/simusol2.pl $opciones_sim2 $archivo");
      $coderr = $coderr/256; $codigo_s2->{$archch} = $coderr;
      if ($coderr) {
	  push @mal,$archivo;
      } else {  
          push @parag, $archivo; 
      };
      next unless $imprlog;
      printf LOGPRIN  "sim2: %3i   %4i", $coderr ,$numarch{$archivo};
      print LOGPRIN " $archch\n" ; 
  };
  print LOGPRIN `date` if $imprlog;
  comfin('fin interpretar_diagramas');
  return \@parag,\@mal;  
};
# ---------------------------------------------------------------------------
sub graficar_diagramas{
    comfin('com graficar_diagramas', @_);
  my ($parag, $refdirarray, $refnumarch, $imprlog) = @_;
  my $opciones_sim3 = '';
  $opciones_sim3 .= '-d ' if $opt_hash{d};
  $opciones_sim3 .= "-g $opt_hash{graf} " if $opt_hash{graf}; 
  $opciones_sim3 .= '-noverb ' if $opt_hash{noverb};
  print LOGPRIN 'Quedan ' , scalar @$parag , ' archivos ', `date` if $imprlog;
  foreach my $archivosindia (@$parag) {
      my $archch;
      my $norden = $refnumarch->{$archivosindia};
      $archch= $refdirarray->[$norden-1];
      eco("Por graficar $norden: $archch",1) if $imprlog;
      abrir_LSS1("$archivosindia",$progname,0)  if $ext eq 'paraplot';        
      my $coderr 
        = system("$SIMUSOLBINDIR/simusol3.pl $opciones_sim3 $archivosindia");
      $coderr = $coderr/256; 
      $codigo_s3->{$archch} = $coderr;
      next unless $imprlog;
      printf LOGPRIN  "sim3: %3i   %4i", $coderr ,$numarch{$archivosindia};
      print LOGPRIN  " $archch\n";
  };
  print LOGPRIN `date` if $imprlog;
  comfin('fin graficar_diagramas');
};
# ---------------------------------------------------------------------------
sub impre_diag{
   my $archivo = $_[0];
   my $archivosindia = $archivo;
   $archivosindia =~ s/\.dia$//;
   
   #if ($opt_hash{png}) {
   #    print "Por preparar archivo $archivo.png\n";
   #    system "dia --nosplash -e $archivo.png $archivo"; 
   #    return;
   #};
   print STDERR "simusol -impr $archivo\n";
   my $mensaje = "
     (Error de instalación de Simusol). No puedo preparar el archivo
       gráfico para impresión $archivosindia.eps ni $archivosindia.png";
   my $mensajeextra = "        con la escala $opt_hash{impr} \%"; 
   my $mensajedia = "        Use Dia, directamente";
   my @orientacion;
   if ($opt_hash{escala} ) {
      my $escala = $opt_hash{escala};
      die "La escala debe consistir en digitos (porcentaje)\n"
              unless $escala =~ /\d+/;
      my $orie = "/$SIMUSOLLIBDIR/simusol/comPortrait"; 
      open IMPRE, $orie or  die 
        "No existe el archivo $orie\n$mensaje\n$mensajeextra\n$mensajedia\n";
      @orientacion = <IMPRE>;
      close IMPRE;
      my $ultimo = pop @orientacion; chomp $ultimo;
      $orie = "/$SIMUSOLLIBDIR/simusol/finPortrait"; 
      open IMPRE, $orie or die 
        "No existe el archivo $orie\n$mensaje\n$mensajeextra\n$mensajedia\n";
      my @restoorientacion = <IMPRE>; 
      $restoorientacion[0] = "$ultimo$escala$restoorientacion[0]";
      push (@orientacion, @restoorientacion);
   } else {
      my $orie ="/$SIMUSOLLIBDIR/simusol/Portrait";
      open IMPRE, $orie or die "$mensaje\n$mensajedia\n";
      @orientacion = <IMPRE>;
   };
   close IMPRE;
   chomp $orientacion[-1];
   -e 'gnus' or crear_gnus('./');
   -d 'gnus' and -w 'gnus' or die "Necesito trabajar con directior gnus\n"; 
   my $archivoleible = $archivo;
   if (not system "zcat $archivo >gnus/llll 2>/dev/null") {
       $archivoleible = "gnus/llll";
   };    
   open(DIA,$archivoleible);
   my @lista_dia = <DIA>; my $texto_dia = join ('',@lista_dia);
   close DIA;
   my ($texto_dia_comienzo,$dummy,$texto_dia_resto) =
       ($texto_dia =~ /^([\W\w\n]+)(<dia:attribute name="paper">)([\W\w\n]+)/);
   defined $texto_dia_comienzo 
       or die "$archivo no es un archivo preparado con Dia";
   my $abre = 1;
   # un archivo .xml de Dia  es una secuencia de cadenas separadas 
   # alternadamentye por < > 
   # los archivos de dia pueden estar o no "pretty printed"
   # entre > y < puede no haber nada; 
   # entre < y > siempre hay algo: dia:... o /dia:
    
   while ($abre and $texto_dia_resto) {
      $texto_dia_resto =~ s/^[^<>]*//; 
      if ($texto_dia_resto =~ s/^(<[^<>]+>)//){
         my $cadena = $1;
         if ($cadena =~ /<\/dia:attribute/){
           $abre --
         } elsif ($cadena =~ /<dia:attribute/){
           $abre ++
         };
      } else {
        exit 500
      }	
    };
    #$texto_dia_resto =~ s/^[^<>]+//;
   open PROVI,  ">gnus/llll";
   print PROVI $texto_dia_comienzo,  @orientacion, $texto_dia_resto; 
   close PROVI ;
   print "Preparando  archivo $archivosindia.eps\n";
  `dia --nosplash -e $archivosindia.eps gnus/llll`; 
        #no se acepta -nosplash pero si --nosplash
   print "Preparando  archivo $archivosindia.png\n";
  `dia --nosplash -e $archivosindia.png gnus/llll`;
} #impre_diag
#----------------------------------------------------------------------------
sub help{
my $nivel = 0;
    $nivel = $_[0] if @_;  
    pod2usage({-verbose => $nivel
	   ,-exit => 1
	   ,-message => "   $progname  $version
       es el script principal  de S I M U S O L
            más ayuda con   
	       man $progname
	    y luego salga con   q\n"   
	   });	   
}
#----------------------------------------------------------------------------
sub version{
    print "\n      $progname  $version\n\n";
    exit
}
__END__


=head1 NAME

simusol - facilita la descripcion de circuitos y su simulación numérica


=head1 SYNOPSIS

B<simusol> [I<opciones>]  [I<archivos>]

I<Opciones para obtener información sobre B<simusol>:> B<-help -version>

I<Opciones para modificar la información de ayuda durante la ejecución>:
B<-d -noverb>

I<Opciones para obtener un  funcionamiento parcial de B<simusol>:> 
B<-notrad -nosim -graf> 

I<Opciones para selección de archivos a tratar:>  B<-buscar -path -patronno 
-patronsi>

I<Opciones que no requieren interpretar los diagramas:> B< -listar -impr 
 -escala>. Si se utiliza una de ellas, se ignoran las demás opciones excepto
 -path y -buscar.

I<Opciones que afectan a la traducción:> B<-todas>

I<Opciones útiles para mantener un registro de los archivos con resultados:> 
B<-backup -comp>. 

En lugar del nombre completo de la opción se puede usar abreviaturas siempre 
que sean distinguibles entre ellas.

Para las opciones no importan mayúsculas o minúsculas; para nombres de
archivos sí importan. 


=head1 OPTIONS/ARGUMENTS

=over 15

=item B<-ba --backup>

Sólo hace un "backup" de los archivos supuestamente producidos durante 
simulaciones anteriores, agregándoles un dígito identificatorio al final. 
Se copian los archivos de extensión

    .d  .paraplot .caj  .res   .simul

=item B<-bu --buscar> I<'pat'>

Procesará los archivos de interés cuyo nombre propio contega el patrón de 
búsqueda (expresión regular para archivos) I<'pat'>. Los apostrofes
 pueden ser 
imprescindibles para evitar la expansión de I<'pat'> 
que hace el intérprete de comandos. La búsqueda se hace con el
 comando B<find>,
 buscando en todos los subdirectorios colgados de I<dir> usado en la opción 
B<-path> I<dir>.  
No haber usado  la opción B<-path> es equivalente a haberla usado para 
comenzar en el directorio de trabajo:   B<-path .> 

=item B<-c --comp>

Al final de la traducción, simulación y/o graficación solicitadas, se comparan 
los archivos de los que hay backup (si nunca se hizo uno, se hace ahora)
producidos anteriormente,  a partir 
de los diagramas seleccionados; el de extension B<.d> con los de 
extensión B<.d1> del mismo directorio, etc. 

=item B<-d>

Produce algunos mensajes para depuración de errores del programa. 
Si no se redirigen la salida estandard y/o la de errores, aparecerán 
repetidos algunos mensajes

=item B<-es  --escala> I<ee> 

Sólo se atiende si va acompañada de la opción B<-impr>. I<ee> indica la escala
deseada para la imresion: 50 por 50%, 85 por 85%, etc.;
 si no se usa la opción, la 
escala queda elegida para ajustarse a una página. 
(En realidad los archivos resultantes .png dan imágenes más pequeñas que
 los .eps)
    

=item B<-g  --graf> I<n>

Con el valor de I<n> se controla la preparación de archivos
relacionados con gráficos (con los resultados de la simulación)  y la
exhibición  de los mismos.

Con I<n> distinto de 4, atiende a las demás opciones y pasa esta  opción 
B<graf> I<n> a B<simusol_sceptre>.

Con I<n> igual a 4, no se realiza traducción ni simulación y sólo 
invoca a simusol3.pl para que haga la representación gráfica 
disponible de una simulación anterior.
 (no importa que se use o no B<--notrad> o B<--nosim>).

 
No usar la opción  B<graf>, con B<simusol>, es equivalente a B<-graf> 3.

=item B<-h  --help>

Muestra este mensaje de ayuda 

=item B<-i  --impr> 

En lugar de traducir, simular y/o graficar, produce un archivo 
postcript encapsulado, y otro de extensión .png aptos
 para incluirlo en documentos, con la 
impresión del circuito ajustada a una 
página (salvo que se use también la opción B<-escala> I<ee>, por ejemplo 
B<-escala> 50 en cuyo caso se usa la escala indicada en porcentaje).

El nombre del archivo postcript es el del archivo-diagrama
con la extension agregada ".eps". 

Para imprimir directamente el diagrama, o conseguir un archivo .ps  de 
impresión se puede usar directament Dia.

=item B<-l  --listar> 

En lugar de traducir, simular y/o graficar, envía a STDOUT  (que se podrá 
redirigir a algún archivo) la lista 
de todos los archivos de interés entre los supuestamente producidos por Dia, 
sin incluir los hechos por Dia como respaldo. Además, si se acepta la oferta, 
 produce un archivo comprimido, con el nombre del directorio de trabajo con 
extensión .tar.gz, con esos archivos así como los correspondientes de 
extensión .caj, .d, .res, .paraplot, .gnu, .lss1

=item B<-not  --notrad>

Simula usando el  archivo.d  ya existente: no hace nueva traducción.

=item B<-nos  --nosim>

No hace la simulación ni tampoco los gráficos (salvo B<--graf> 4)

=item B<-nov --noverb>

Disminuye la cantidad de información no esencial que se da al ususrio.

=item B<-p --path> I<dir>

No se atiende si no se usa la opción B<-buscar>; y entonces se ignoran los 
archivos nombrados al final del comando.

La búsqueda de archivos para simular se hace en todos los subdirectorios,
empezando en el directorio indicado por I<dir>; y se buscan los archivos que
 responden al patrón de búsqueda (expresión regular)  I<'pat'> de la opción 
 B<-buscar>. 

=item B<-patronn --patronno> I<listapat> 

(I<listapat>: lista, entre apóstrofes, 
de patrones de búsqueda separados por espacios)

Ignora todos los archivos que en su nombre relativo (no sólo el nombre propio),
contengan alguno de los patrones, para búsqueda por Perl, de la lista  
I<listapat>.

=item B<-patrons --patronsi> I<listapat > 

(I<listapat>: 	lista, entre apóstrofes, 
de patrones de búsqueda separados por espacios).

Sólo considera los archivos que en su nombre relativo 
(no sólo el nombre propio),
contengan alguno de los patrones, 
para búsqueda por Perl, de la lista  I<listapat>.

=item B<-t --todas> I<comi>  

Se  ignoran  los pedidos de 
resultados y de gráficos del diagrama y se sustituyen por el pedido de  
todas las variables cuyos nombres, para el sceptre, comienzan con  I<comi>
Si en I<comi> hay espacios habrá que usar comillas. 

Por ejemplo,  con  B<-t VC>  se tendrá, si es posible, el gráfico de 
voltajes de todos los condensadores; para circuitos térmicos 
corresponde a las temperaturas de todos los acumuladores, lo que tambien
 se puede pedir con  B<-t 'TEMP C'>.
Se acepta también B<-t TEMPN> o B<-t "TEMP N"> para referirse a las 
temperaturas de todos los nodos; o si en un circuito eléctrico hay tierra, 
B<-t VN> o B<-t "V N"> para referirse a los voltajes de todos los nodos.
  

=item B<-v  --version>

Muestra versión.

=item  I<archivos>

Sólo se atiende si no se ha usado la opción B<-buscar>.

Nombres de archivos separados por espacio. Pueden provenir de la expansión de 
comodines.  Buscará, entre esos archivos, cuáles corresponden a diagramas
preparados con B<Dia>
Aqui se admiten comodines.

Si se nombra más de un archivo, antes de la ejecución se pide confirmación, 
y se ofrece la posibilidad de "agrupar" archivos para procesarlos juntos. 

=back

=head1 DIRECTORIES 

Algunas convenciones:

=over 5

=item  B<$INSTALLDIR> 

representa el directorio a partir del cual Simusol está
 instalado, usualmente /usr/local

=item  B<$HOMEDIR>  

directorio "home" del usuario 

=item B<$SIMUSOLBINDIR> = $INSTALLDIR/bin> 

Directorio de los ejecutables que integran Simusol: 

=item B<$SIMUSOLLIBDIR = $INSTALLDIR/lib>

=item B<$SIMUSOLLIBDIR/simusol>

Directorio de los  módulos Perl que integran Simusol

=item B<$SIMUSOLLIBDIR/simusol/elementos> 

Directorio para definiciones (distribuídas con Simusol) de elementos: 

=item B<$SIMUSOLLIBDIR/simusol/modelos> 

Directorio previsto para definiciones (distribuídas con Simusol) de modelos:

=item  B<$HOMEDIR/.simusol/elementos>

Directorio previsto para que el usuario guarde sus definiciones de 
elementos: 

=item  B<$HOMEDIR/.simusol/modelos>
 
Directorio previsto para que el usuario guarde sus definiciones de 
modelos:

=back 

=head1 DESCRIPTION

Script principal de un  conjunto de scripts 

Facilita la  simulación  numérica,  con B<sceptre>,  de circuitos descriptos
usando  B<dia>; también facilita la  visualización de los resultados 
con B<gnuplot>


=head1 FILES

Los archivos con resultados los produce B<simusol> a través de 
 sus scripts  asociados: 

B<simusol1.pl>

B<simusol2.pl>

B<simusol3.pl>

B<simusol_sceptre>


Para comunicarse con el usuario B<simusol> utiliza STDOUT y STDERR; y además, 
cuando se han traducido y/o simulado más de un archivo, 
produce un archivo
B<simusol.log>;  y un archivo B<simusol.comp.log> con los reultados de 
comparaciones si se utilizó la opción B<-comp>.   

=head1 Examples

Son equivalentes para procesar todos los archivos posibles en el directorio 
de trabajo:

=over 5

=item B<simusol>

=item B<simusol *>

=back

También son equivalentes para procesar todos los archivos posibles del arbol 
a partir del directorio de trabajo
 
=over 5

=item B<simusol -buscar  '*' -path  .>

=item B<simusol -buscar  '*'  > 

=item B<simusol -path . -buscar '*'>

=back

Para hacer "bakups" de los resultados para un diagrama "tanque"; y posteriormente 
comparar con los resultados luego de algunas modificaciones del diagrama:

=over 5

=item B<simusol -back tanque>

=item (... modificaciones ...)

=item B<simusol -comp> tanque

=back

=head1 AUTHORS

Dolores Alia de Saravia <loli@unsa.edu.ar>

Luis R. Saravia <saravia@unsa.edu.ar>

Diego Saravia <dsa@unsa.edu.ar> 
