#!/bin/bash
# author: wrn 24/11/21
# paso 3 del PLAN (sceptre2novender): opciones de linea de comando.
# uso: sc1 [opciones] CASO[.d]
#   -h, --help              esta ayuda
#   -v, --version           version
#   -o, --outdir DIR        directorio que recibe las salidas (por defecto .)
#   -m, --modellib ARCHIVO  biblioteca de modelos (lib/modellib.dat)
#   -u, --usrlib ARCHIVO    biblioteca de usuario para el enlace (lib/usrlib.a)
#   --sin-modelos           sin los modelos propios: corre con la biblioteca
#                           instalada sola. Los propios salen de
#                           ~/.config/sceptre/modelos/*.dat (SCEPTRE_MODELOS_DIR
#                           lo elige) y un deck que use uno que solo esta ahi
#                           no corre con esta opcion, que es para eso: ver si
#                           el circuito depende de un modelo mio
#   --sin-funciones         no armar ni enlazar la biblioteca de funciones
#                           propias (~/.config/sceptre/funciones/*.f90)
#   -nosim                  no deja el texto .simnativo
#   --parar 1|2             1 sigue mientras se pueda (defecto), 2 para en
#                           el primer error
#   --verbose 1|2|3         cuanto escribe en el listado (defecto 2)
#   --lector propio|slex|tokens  con que se lee el deck en la fase 1: slex
#                           (defecto, el manual (agregados/32-lector-slex-por-dentro.tex)) o el propio, el de siempre
#   --tablas tabular2|sceptre  con que se interpolan las TABLE del deck en la
#                           fase 2: tabular2 (defecto, pasos/tablas-tabular2.diff;
#                           en una x repetida da el promedio) o la de SCEPTRE
#   --modelos sceptre|c     quien expande los MODEL del deck: la fase 1, como
#                           siempre (defecto), o d2datdinc antes de la fase 1
#                           (--d-expandido, el manual (agregados/33-modelos-en-c.tex)), con lo que
#                           sceptreM lee un circuito plano. D2DATDINC,
#                           D2DATDINC_BIB y D2DATDINC_CONF eligen el programa,
#                           su biblioteca y sus reglas de slex
#   ARCHIVO.ds / .ds2       YA NO ENTRA (04/11/2026, PLAN-SIN-DS paso 5): se
#                           convierte una vez a su par .dsa con
#                           slex/viejos/dsa-python/traducir.py y entra el par
#   -nombre NOMBRE          como se llama esta corrida: nombra el .log, el
#                           .sim y todo lo demas. Sin esto, el nombre sale
#                           del archivo del deck, y en el modo filtro se
#                           inventa corrida-aaaammdd-hhmmss
#   -continuar              conserva pgmsave.for, datasave.dat y plotsave.dat
#                           de la corrida anterior (decks CONTINUE/RE-OUTPUT)
#   -estatico               enlaza el circuito en un ejecutable propio, como
#                           siempre (sin esto, el circuito se compila a CASO.so
#                           y lo carga bin/sceptreDU; si no esta, es un error)
#   -sodir DIR              donde dejar CASO.so y CASO.datasave (CASO-MODELO.so
#                           si el deck declara OBSERVABLES, VARIABLES o
#                           LINEALIZADO: un .so por modelo, pasos/MODELOS-
#                           DECLARADOS) (por defecto,
#                           junto al .d; si no se puede escribir, en -o)
#   -rehacer                no reutilizar CASO.so aunque este (sin esto se
#                           reutiliza si CASO.huella coincide con el md5 del
#                           programa que la fase 1 genero hoy, el de x2 y el de
#                           la biblioteca: cambiar datos o usos no recompila)
#   -sinlatido              sin tiempo de corte: ninguna fase se corta aunque
#                           pase mucho sin avanzar (para el que sabe que su
#                           corrida es larga; sin esto, si una fase no
#                           avanza en SCEPTRE_SIN_AVANCE segundos --300--
#                           sale con 118, la 2 guardando lo hecho, y la fase
#                           1 sale con 118 tambien si pasa
#                           SCEPTRE_FASE1_TOPE segundos en total --1800--)
#   -                       lee el deck por la entrada estandar, deja el .sim
#                           en la salida estandar y lo demas en la de error
#   -lote CASO1.d CASO2.d ... corre varios decks con UN SOLO bin/sceptreDU que
#                           queda corriendo (sceptreDU --servidor, el manual (agregados/36-so-y-servidor.tex)):
#                           cada deck es una corrida comun de sc1, con las
#                           opciones de antes de -lote, y la fase 2 la hace el
#                           servidor. La fase 1 de todos la hace antes un solo
#                           sceptreM --lote: cada renglon con el deck adelante
#                           ('CASO| ...') y 'CASO: FIN tipo codigo' (el que
#                           reutiliza su .so o continua, en su turno). Al
#                           final, un renglon 'CASO CODIGO' por deck; sale
#                           con el primer codigo que no sea 0
# Codigos de salida propios de sc1 (los mismos que el guion del viejo; el resto
# es el de la fase que fallo): 106 uso u opcion desconocida; 107 el deck o el
# directorio de salida no existen; 108 falta una pieza del arbol (modellib,
# libsceptreDU.a, bin/sceptreDU...) o el temporal; 109 fallo la cadena: el generado no
# compilo o no quedo pgmsave.for sin que la fase 1 diera codigo.
# sin opciones deja, como salidas de datos, CASO.dirac y CASO.simnativo.
# tambien se lee ~/.config/sceptre/sceptre.conf; las opciones le ganan.

# --- paso 6 del PLAN: launcher REUBICABLE ---------------------------------
# No hay ninguna ruta escrita a mano: cada pieza se busca a partir de donde
# esta ESTE guion, de modo que el mismo archivo sirve en los tres layouts:
#   a) el arbol de trabajo o un paquete autocontenido:  BASE/bin, BASE/lib
#   b) un directorio de compilacion de autotools:       BASE/sceptreM, BASE/sceptreDU
#   c) una instalacion:  BASE/bin, BASE/lib/PAQUETE, BASE/share/PAQUETE
# SCEPTRE_HOME, si esta puesta, manda sobre todo lo demas.
PAQUETE=sceptresimusol

PRG=$0
case "$PRG" in
  */*) : ;;
  *)   PRG=`command -v "$PRG" 2>/dev/null || printf '%s' "$0"` ;;
esac
# un enlace simbolico se sigue hasta el archivo real
while [ -h "$PRG" ]; do
   DESTINO=`ls -ld "$PRG" | sed 's/^.*-> //'`
   case "$DESTINO" in
     /*) PRG=$DESTINO ;;
     *)  PRG=`dirname "$PRG"`/$DESTINO ;;
   esac
done
BINDIR=`CDPATH= cd -- "\`dirname -- "$PRG"\`" && pwd`
BASEDIR=${SCEPTRE_HOME:-`CDPATH= cd -- "$BINDIR/.." && pwd`}

# busca el archivo $1 en los lugares que siguen; deja la ruta en la salida
# EL DECK QUE LEE LA FASE 1 (29/10/2026, pasos/modelos-c.diff): tal cual, o
# con --modelos c los MODEL expandidos por d2datdinc --d-expandido (la
# expansion en el lector de .d de slex, el manual (agregados/33-modelos-en-c.tex)). La biblioteca que
# se le pasa es la de d2datdinc (libraryori.siru, rk.siru) con la modellib de
# ESTE SCEPTRE como modellib.siru, para que los MODEL ... (PERM) sean los
# mismos que expandiria la fase 1. Un deck sin MODEL va tal cual. Lo que
# d2datdinc dice va al listado; si rechaza el deck (un MODEL sin definir, por
# ejemplo) conserva su 101; si no hay d2datdinc, o no sabe --d-expandido, el 108.
expande_deck () {   # expande_deck DESTINO
   # Procedencia por trabajo, no estado global del servidor. No contiene
   # ecuaciones: permite volver del input.dat privado al archivo del usuario.
   printf '%s\n' "$ORIGEN_USUARIO" > "$1.origen" || return 108
   # un .dsa va tal cual: sus modelos ya estan en su dato y su PARAPLOT ya
   # salio (la rama .dsa)
   if [ -n "${DSA_CASO:-}" ]; then
      printf '%s\n' "$MODO_ORIGEN" >> "$1.origen"
      cp "$DECK" "$1" || return 108
      test -f "$CASO.graficos.ds" || : > "$CASO.graficos.ds"
      return 0
   fi
   if [ "${SCEPTRE_MODELOS:-sceptre}" != c ] || ! grep -q -i -E '= *MODEL ' "$DIR/$CASO.d"; then
      printf '%s\n' "$MODO_ORIGEN" >> "$1.origen"
      cp "$DIR/$CASO.d" "$1" || return 108
      separar_dibujo "$1"; return $?
   fi
   printf '%s\n' expandido >> "$1.origen"
   D2D=${D2DATDINC:-d2datdinc}
   if ! command -v "$D2D" >/dev/null 2>&1 || ! "$D2D" --help 2>&1 | grep -q -- '--d-expandido'; then
      echo "sc1: --modelos c necesita d2datdinc con --d-expandido ($D2D no lo tiene; D2DATDINC lo elige)" | tee -a "$CASO.log" >&2
      return 108
   fi
   BIBD=${D2DATDINC_BIB:-/usr/share/slex/biblioteca}
   BIBT=`mktemp -d "${TMPDIR:-/tmp}/sc1-bib.XXXXXX"` || return 108
   for f in libraryori.siru rk.siru; do
      if ! test -f "$BIBD/$f"; then echo "sc1: --modelos c: falta $BIBD/$f (D2DATDINC_BIB la elige)" | tee -a "$CASO.log" >&2; rm -f "$BIBT"/*.siru; rmdir "$BIBT"; return 108; fi
      ln -s "$BIBD/$f" "$BIBT/$f"
   done
   ln -s "$MODELLIB" "$BIBT/modellib.siru"
   CONFX=""; if [ -n "${D2DATDINC_CONF:-}" ]; then CONFX="-c $D2DATDINC_CONF"; fi   # las reglas de slex de d2datdinc
   "$D2D" $CONFX -b "$BIBT" --d-expandido "$1" "$DIR/$CASO.d" > "$1.d2d" 2>&1; RCX=$?
   rm -f "$BIBT/libraryori.siru" "$BIBT/rk.siru" "$BIBT/modellib.siru"; rmdir "$BIBT"
   { echo "sc1: --modelos c: d2datdinc --d-expandido (codigo $RCX)"; cat "$1.d2d"; } >> "$CASO.log"
   rm -f "$1.d2d"
   if [ $RCX -ne 0 ] || ! test -s "$1"; then
      echo "sc1: --modelos c: d2datdinc no pudo expandir los modelos de $DIR/$CASO.d (ver $CASO.log)" >&2
      case $RCX in
         101|107|108) return "$RCX" ;;
         *) return 109 ;;
      esac
   fi
   separar_dibujo "$1"
}
# El motor numerico recibe el deck sin PARAPLOT. Se conserva aparte hasta
# componer la salida con su tabla; las ordenes nunca se evaluan aqui.
separar_dibujo () {
   local deck=$1 lector=${D2DATDINC:-d2datdinc}
   if grep -q -E '^[[:space:]]*PARAPLOT([[:space:]]|$)' "$deck"; then
      "$lector" "$deck" --separar-paraplot "$CASO.graficos.ds" -o "$deck.sin-graficos" || return $?
      mv "$deck.sin-graficos" "$deck" || return 108
   elif [ -n "${PARAPLOT_DSA:-}" ]; then
      cp "$PARAPLOT_DSA" "$CASO.graficos.ds" || return 108
   else
      : > "$CASO.graficos.ds"
   fi
}
busca () {
   cual=$1; shift
   for d in "$@"; do
      if [ -f "$d/$cual" ]; then printf '%s\n' "$d/$cual"; return 0; fi
   done
   printf '%s\n' "NO-ENCONTRADO:$cual"; return 1
}
DIRBIN="$BASEDIR/bin $BINDIR $BASEDIR/sceptreM"
# el lib/ de una instalacion Debian es multiarch (lib/x86_64-linux-gnu/...),
# de ahi el comodin: no se puede escribir la arquitectura a mano
DIRLIB="$BASEDIR/lib $BASEDIR/lib/$PAQUETE $BASEDIR/sceptreDU $BINDIR/../lib/$PAQUETE "`echo "$BASEDIR"/lib/*/"$PAQUETE"`
DIRDAT="$BASEDIR/lib $BASEDIR/share/$PAQUETE $BINDIR/../share/$PAQUETE"
# los .mod de la fase 2: el Fortran generado los usa, hay que compilarlo con
# -I al directorio que los tenga
DIRMOD="$BASEDIR/sceptreDU $BASEDIR/include/$PAQUETE $BINDIR/../include/$PAQUETE $BASEDIR/lib/$PAQUETE $BASEDIR/lib "`echo "$BASEDIR"/lib/*/"$PAQUETE"`

LIBDU=`busca libsceptreDU.a      $DIRLIB`
SCEPTREM=`busca sceptreM        $DIRBIN`
SCEPTREDU=`busca sceptreDU.o      $DIRLIB`
EXEC2BIN=`busca sceptreDU     $DIRBIN`    # la fase 2 ejecutable, modo dinamico (paso 9)
USRLIB=`busca usrlib.a    $DIRLIB`
USRLIB_ARBOL=$USRLIB                  # la de sceptreDU; otra (-u, sceptre.conf) es 'propia' (DEFECTOS 44)
MODELLIB=`busca modellib.dat $DIRDAT`
MODDU=`busca common_tapes_2.mod $DIRMOD`
HUELLAX2=`busca sceptreDU.huella     $DIRLIB`     # la huella de x2 (paso 9, tanda 4)
MODDU=`dirname "$MODDU"`
# usrlib.a YA NO ES OBLIGATORIA (05/11/2026): las funciones que antes traia
# --FMOS, FTABL1, FSAT, FC11, las de SPICE...-- son fuentes del proyecto y se
# compilan con la fase 2 (extras/, ../extras/objetos/LEEME.md). usrlib.a queda
# para la biblioteca PROPIA del usuario, que es opcional y se elige con -u o
# con USRLIB en sceptre.conf. Si no hay ninguna, no se enlaza nada y listo.
case "$USRLIB" in NO-ENCONTRADO:*) USRLIB=; USRLIB_ARBOL= ;; esac
# LOS MODELOS PROPIOS DEL USUARIO: los .dat de su directorio de modelos --el
# que le crea sceptre-user-setup--, que van ANTES de la biblioteca instalada,
# asi un modelo propio le gana al de igual nombre (ver inserta_modelos).
MODELOSDIR=${SCEPTRE_MODELOS_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/sceptre/modelos}
MODELOSPROPIOS=
if [ -d "$MODELOSDIR" ]; then MODELOSPROPIOS=`ls "$MODELOSDIR"/*.dat 2>/dev/null || true`; fi
for pieza in "$LIBDU" "$SCEPTREM" "$SCEPTREDU" "$MODELLIB"; do
   case "$pieza" in NO-ENCONTRADO:*)
      echo "sc1: no encuentro ${pieza#NO-ENCONTRADO:} (probe en $BASEDIR); poner SCEPTRE_HOME" >&2
      exit 108 ;;
   esac
done
test "$(which less)" = "" && alias less='more'

# compiler and options for the SC1-run

# -fallow-argument-mismatch ya no hace falta: el defecto 9 (AC1 emitia Q y H
# escalares donde AGDIM/LSDIM los esperan arreglo) esta arreglado y todo el
# corpus compila sin tolerancias. Ver pasos/DEFECTOS punto 9.
FC='gfortran -std=gnu'
# SI A GFORTRAN LO MATA UNA SENAL --el codigo del shell es 128 mas la senal;
# el caso tipico es el OOM del sistema, que manda KILL (9) cuando se queda
# sin memoria compilando un generado grande-- decirlo con todas las letras,
# en vez del 109 pelado que obligaba a adivinar leyendo CASO.compila
# (pedido de Diego, 02/11/2026; el OOM de resescalera1200).
# EL SO CAMBIO Y EL PAQUETE QUEDO VIEJO (05/11/2026, docs/AUTOINSTALACION.md):
# los .mod que instala el paquete los lee SOLO el gfortran que los escribio, y
# la biblioteca estatica es de ese compilador y esa libc. Cuando el usuario
# actualiza el sistema, el primer compilado del generado falla con "Cannot read
# module file ... created by a different version of GNU Fortran" y eso no se
# arregla recompilando el deck: hay que rehacer el paquete.
#
# Como el paquete binario se trae sus fuentes (share/PAQUETE/fuentes), el aviso
# dice el comando exacto. No cuesta nada en la corrida normal: se llama SOLO
# cuando el compilado fallo.
#
# La huella es share/PAQUETE/gfortran-mod, la version de los .mod con que se
# construyo; se compara con la del gfortran de esta maquina, que se lee del
# encabezado de un .mod de prueba.
aviso_so_cambio () {   # aviso_so_cambio ARCHIVO.compila
   grep -q -E "Cannot read module file|created by a different version of GNU Fortran|Wrong module version" "$1" 2>/dev/null || return 0
   HUELLA=`busca gfortran-mod $DIRDAT 2>/dev/null`
   VIEJA=; case "$HUELLA" in NO-ENCONTRADO:*) ;; *) VIEJA=`cat "$HUELLA" 2>/dev/null`;; esac
   NUEVA=
   TMPMOD=`mktemp -d "${TMPDIR:-/tmp}/sc1-mod.XXXXXX"` && {
      printf 'module conftest_mod\nend module\n' > "$TMPMOD/conftest_mod.f90"
      ( cd "$TMPMOD" && ${FC} -c conftest_mod.f90 ) > /dev/null 2>&1 &&
        NUEVA=`(gzip -dc "$TMPMOD/conftest_mod.mod" 2>/dev/null || cat "$TMPMOD/conftest_mod.mod") 2>/dev/null |
               sed -n "s/.*GFORTRAN module version .\([0-9][0-9]*\).*/\1/p" | head -1`
      rm -rf "$TMPMOD"
   }
   FUENTES=; for d in $DIRDAT; do test -d "$d/fuentes" && FUENTES=$d/fuentes && break; done
   {
   echo "sc1: EL COMPILADOR DE ESTA MAQUINA NO PUEDE LEER LOS .mod DEL PAQUETE"
   echo "sc1:   los .mod instalados son de gfortran-mod-${VIEJA:-?} y este gfortran escribe gfortran-mod-${NUEVA:-?}"
   echo "sc1:   paso tipicamente al actualizar el sistema operativo: el paquete hay que rehacerlo,"
   echo "sc1:   no alcanza con volver a correr el deck."
   if [ -n "$FUENTES" ]; then
      echo "sc1:   el paquete trae sus fuentes en $FUENTES, asi que se rehace aca mismo:"
      echo "sc1:     sp --para $FUENTES install $PAQUETE"
   else
      echo "sc1:   este paquete no trae sus fuentes: hay que instalar una version construida para este sistema."
   fi
   } | tee -a "$1" ${SCEPTRE_LOG:+-a "$SCEPTRE_LOG"} >&2
}
gfortran_asesinado () {   # gfortran_asesinado CODIGO ARCHIVO.compila
   if [ "$1" -lt 128 ]; then return; fi
   SEN=`expr "$1" - 128`
   MSJ="sc1: a gfortran lo mato la senal $SEN"
   if [ "$SEN" = 9 ]; then MSJ="$MSJ (KILL): si fue el sistema sin memoria, journalctl -k lo dice (Out of memory: Killed process ... f951)"; fi
   echo "$MSJ" | tee -a "$2" ${SCEPTRE_LOG:+-a "$SCEPTRE_LOG"} >&2
}
# REENTRANCIA DEL GENERADO (21/10/2026, pasos/reentrancia-generado.diff): el
# generado ya no se compila con -fno-automatic; lo que SIMTR recuerda lo dice
# un SAVE que emite XF90. -finit-local-zero deja las locales en cero al entrar,
# como estaban siempre las estaticas.
FFLAGS='-finit-local-zero -ggdb -fbacktrace -fdollar-ok -Wno-line-truncation'


# --- paso 6: configuracion por usuario (XDG) ------------------------------
# Si el usuario tiene su propia biblioteca de modelos o de usuario, no hace
# falta tocar la instalacion: alcanza con ~/.config/sceptre/sceptre.conf
# (lo arma "sceptre --init-user"). Las opciones de la linea de comando ganan,
# porque se procesan DESPUES. SCEPTRE_NO_CONF=1 saltea la lectura, que es lo
# que hacen hacer-patron y el make check para que el corpus sea reproducible
# aunque el usuario tenga una configuracion propia.
CONFDIR=${XDG_CONFIG_HOME:-$HOME/.config}/sceptre
if [ "${SCEPTRE_NO_CONF:-0}" = 0 ] && [ -r "$CONFDIR/sceptre.conf" ]; then
   while IFS='=' read -r clave valor; do
      case "$clave" in
         ''|\#*) continue ;;
         MODELLIB) test -f "$valor" && MODELLIB=$valor ;;
         USRLIB)   test -f "$valor" && USRLIB=$valor ;;
         OUTDIR)   CONF_OUTDIR=$valor ;;
         FC)       FC=$valor ;;
         FFLAGS)   FFLAGS=$valor ;;
      esac
   done < "$CONFDIR/sceptre.conf"
fi

# LOS MODELOS ENTRAN EN EL TEXTO DEL DECK (05/11/2026, pedido del autor). Antes
# la biblioteca de modelos era un archivo que la fase 1 abria por nombre
# --modellib.dat, con un indice al principio-- y sc1 le ponia un symlink. Eso
# dejaba lugar para UNA sola: la instalada o la copia del usuario, y el que
# agregaba un modelo propio se quedaba sin los que trajera una actualizacion
# del paquete.
#
# Ahora hay dos lugares --la instalada, en share, y la del usuario, en su
# directorio de modelos-- y es sc1 el que resuelve: mira que modelos USA el
# deck y no define, los saca de donde esten (gana el del usuario) y los manda
# EN EL TEXTO del deck, como una seccion de modelos, que es como un deck trae
# sus modelos desde siempre. La fase 1 no se entera de que habia dos archivos.
# En el listado queda anotado de que archivo salio cada modelo.
#
# Dos cosas al pasarlos:
#  - (PERM) pasa a (TEMP). En un deck, (PERM) quiere decir 'guardalo en la
#    biblioteca permanente', y si el nombre ya esta da el error 39, REDUNDANT
#    MODEL SPECIFIED. (TEMP) es un modelo de esta corrida, que es lo que
#    queremos.
#  - un modelo que el deck ya define no se manda: el del deck manda.
#
# Probado sobre samples/a08.d: el mismo circuito por la biblioteca y por el
# texto da el datasave, el plotsave, el acsave y el listado numerico
# IDENTICOS; solo cambian la hora y las huellas.
#
# El awk va con LC_ALL=C: el indice dice 1.5000E+01 y en una locale con coma
# decimal eso se lee como 1.
AWK_MODELOS='
# modelos.awk: elige los modelos que el deck usa y no define, los saca de las
# bibliotecas (en el orden en que se pasan: gana la primera) y los escribe como
# una seccion de modelos lista para entrar en el texto del deck.
#   awk -f modelos.awk DECK BIBLIOTECA...
# Por la salida estandar sale el texto a insertar; por la de errores, de donde
# salio cada modelo (eso va al listado). Codigo 0 siempre: que un modelo no
# este es cosa de la fase 1, que lo dira en el listado como siempre.
function nom_tras(s, k,   r) {        # el nombre que sigue a la palabra MODEL
   r = substr (s, k)
   sub (/^[ \t]+/, "", r)
   if (match (r, /^[A-Z0-9_]+/)) return substr (r, 1, RLENGTH)
   return ""
}
function esmodel(l,   u) { u = toupper (l); sub (/^[ \t]+/, "", u); return substr (u, 1, 6) == "MODEL " }
function usados_de(s,   u, k, n) {    # los "= MODEL NOMBRE" de un renglon
   u = toupper (s); k = 1
   while (match (substr (u, k), /=[ \t]*MODEL[ \t]+[A-Z0-9_]+/)) {
      mt = substr (substr (u, k), RSTART, RLENGTH)
      n = nom_tras(mt, index (mt, "MODEL") + 5)
      if (n != "") pedido[n] = 1
      k = k + RSTART + RLENGTH - 1
   }
}
FNR == 1 { nf++; nombrearch[nf] = FILENAME }
{ nl[nf]++; L[nf, nl[nf]] = $0 }
END {
   # 1. EL DECK (el primer archivo): que modelos usa y cuales define el mismo
   for (i = 1; i <= nl[1]; i++) {
      usados_de(L[1, i])
      if (esmodel(L[1, i])) {
         u = toupper (L[1, i]); sub (/^[ \t]+/, "", u)
         n = nom_tras(u, 6)
         if (n != "" && n != "DESCRIPTION" && n != "EDIT") propio[n] = 1
      }
   }
   # 2. CADA BIBLIOTECA: con indice (nombre y cantidad de tarjetas) o solo los
   #    MODEL, contando nosotros los renglones
   for (f = 2; f <= nf; f++) parsea(f)
   # 3. LA CLAUSURA: un modelo puede usar otro modelo
   for (m in pedido) if (!(m in propio)) cola[++nc] = m
   for (c = 1; c <= nc; c++) {
      m = cola[c]
      if (m in tengo) continue
      tengo[m] = 1
      hallado = ""
      for (f = 2; f <= nf; f++) {
         if (!((f, m) in cuerpo)) continue
         if (hallado == "") {
            hallado = nombrearch[f]
            printf "%s", cuerpo[f, m]
            printf "sc1: modelo %s <- %s\n", m, nombrearch[f] > "/dev/stderr"
            k = split (cuerpo[f, m], renglones, "\n")
            for (j = 1; j <= k; j++) {
               antes = nc
               usados_de(renglones[j])
               for (mm in pedido) if (!(mm in propio) && !(mm in tengo) && !(mm in encolado)) { cola[++nc] = mm; encolado[mm] = 1 }
            }
         } else {
            printf "sc1: el modelo %s tambien esta en %s: gana el de %s\n", m, nombrearch[f], hallado > "/dev/stderr"
         }
      }
      if (hallado == "") printf "sc1: el modelo %s no esta en ninguna biblioteca\n", m > "/dev/stderr"
   }
}
# parsea(f): deja en cuerpo[f, NOMBRE] el texto del modelo, con (PERM) -> (TEMP)
function parsea(f,   i, prim, ni, nom, cant, p, k, j, u, n, ini, fin, txt) {
   prim = 0
   for (i = 1; i <= nl[f]; i++) if (esmodel(L[f, i])) { prim = i; break }
   if (prim == 0) { printf "sc1: %s no tiene ningun MODEL: no es una biblioteca de modelos\n", nombrearch[f] > "/dev/stderr"; return }
   ni = 0
   for (i = 1; i < prim; i++) {
      if (L[f, i] ~ /^[ \t]*$/) continue
      nom = substr (L[f, i], 1, 18); gsub (/^[ \t]+|[ \t]+$/, "", nom)
      if (nom == "") continue                       # el renglon de la cantidad
      ni++; inom[ni] = toupper (nom); iren[ni] = substr (L[f, i], 19) + 0
   }
   if (ni > 0) {                                    # trae indice: los cuerpos van en ese orden
      p = prim
      for (k = 1; k <= ni; k++) {
         txt = ""
         for (j = 0; j < iren[k] && p + j <= nl[f]; j++) txt = txt perm_a_temp(L[f, p + j]) "\n"
         cuerpo[f, inom[k]] = txt
         p += iren[k]
      }
      return
   }
   k = 0                                            # sin indice: cortamos en cada MODEL
   for (i = prim; i <= nl[f]; i++) if (esmodel(L[f, i])) { k++; ini[k] = i }
   for (j = 1; j <= k; j++) {
      fin = (j < k) ? ini[j+1] - 1 : nl[f]
      while (fin > ini[j] && L[f, fin] ~ /^[ \t]*$/) fin--
      u = toupper (L[f, ini[j]]); sub (/^[ \t]+/, "", u)
      n = nom_tras(u, 6)
      txt = ""
      for (i = ini[j]; i <= fin; i++) txt = txt perm_a_temp(L[f, i]) "\n"
      if (n != "") cuerpo[f, n] = txt
   }
}
# en un deck, (PERM) quiere decir "guardalo en la biblioteca permanente", y si
# ya esta da el error 39 REDUNDANT MODEL. Un modelo de esta corrida es (TEMP).
function perm_a_temp(l,   r) { r = l; if (esmodel(l)) sub (/\([Pp][Ee][Rr][Mm]/, "(TEMP", r); return r }
'
inserta_modelos () {   # inserta_modelos DECK
   if [ -n "${DSA_CASO:-}" ]; then return 0; fi   # un .dsa trae sus modelos en su dato
   # --sin-modelos: la instalada sola, sin mirar el directorio del usuario.
   # No hay una 'ruta vieja' a la que volver: la fase 1 ya no abre ninguna
   # biblioteca por nombre, asi que un deck que use un modelo que solo esta
   # entre los propios NO corre con esta opcion, que es justo para lo que
   # sirve: ver si el circuito depende de un modelo mio o no.
   _propios=${MODELOSPROPIOS:-}
   if [ "${SINMOD:-0}" = 1 ]; then _propios=; fi
   _bibs=
   for _b in $_propios "$MODELLIB"; do
      if test -f "$_b"; then _bibs="$_bibs $_b"; fi
   done
   if [ -z "$_bibs" ]; then return 0; fi
   LC_ALL=C awk "$AWK_MODELOS" "$1" $_bibs > "$1.modelos" 2> "$1.modelos.log"
   if test -s "$1.modelos.log"; then cat "$1.modelos.log" >> "$CASO.log"; fi
   if test -s "$1.modelos"; then
      if grep -qiE '^[[:space:]]*MODEL[[:space:]]+DESCRIPTION' "$1"; then
         # ya tiene seccion de modelos: los de la biblioteca van arriba, asi
         # los que el deck define pueden usarlos
         LC_ALL=C awk -v f="$1.modelos" 'BEGIN { while ((getline l < f) > 0) m[++n] = l }
            { print }
            !puesto && toupper($0) ~ /^[ \t]*MODEL[ \t]+DESCRIPTION/ { for (i = 1; i <= n; i++) print m[i]; puesto = 1 }' "$1" > "$1.con" || return 108
      else
         { echo "MODEL DESCRIPTION"; cat "$1.modelos"; cat "$1"; } > "$1.con" || return 108
      fi
      mv "$1.con" "$1" || return 108
   fi
   rm -f "$1.modelos" "$1.modelos.log"
}

ayuda() { sed -n '4,/^$/p' "$0" | sed 's/^# \{0,1\}//'; }

ARGS_ORIG=("$@")      # para -lote: las opciones se repiten en cada deck
LOTE=0
OUTDIR=${CONF_OUTDIR:-.}
OUTDIR_DADO=0
NOSIM=0
CONTINUAR=0
ESTATICO=0
REHACER=0
SODIR=
while [ $# -gt 0 ]; do
  case "$1" in
    -h|--help)    ayuda; exit 0 ;;
    -v|--version) echo "SC1-SD2 2026.131 (sceptresimusol) en ${BASEDIR}"; exit 0 ;;
    -o|--outdir)   OUTDIR=$2; OUTDIR_DADO=1; shift 2 ;;
    -m|--modellib) MODELLIB=$2; shift 2 ;;
    -u|--usrlib)   USRLIB=$2; shift 2 ;;
    --sin-funciones) SINFUN=1; shift ;;
    --sin-modelos)   SINMOD=1; shift ;;
# DE LAS CUATRO OPCIONES QUE HABIA PARA ESTO QUEDA UNA, -nosim (decision del
# autor, 18/10/2026). Eran -a/--ascii, -t/--text-only, -nodirac y -nosim, y
# las cuatro hacian lo mismo: decidir si el .dirac y el .sim nativo se borran
# o se conservan al terminar. Las tres primeras estaban al vicio --el -a era
# el default puesto a mano y el -t un segundo nombre del -nodirac-- y el
# .dirac ahora se conserva siempre: el que no lo quiera lo borra el.
    -nosim)   NOSIM=1; shift ;;
    -estatico) ESTATICO=1; shift ;;
    -rehacer)  REHACER=1; shift ;;
    -sodir)    SODIR=$2; shift 2 ;;
# -nombre NOMBRE: COMO SE LLAMA ESTA CORRIDA (paso 10). Sirve para dos cosas:
# ponerle un nombre entendible a un deck que entra por la tuberia --donde no
# hay nombre de archivo de donde sacarlo-- y hacer REPRODUCIBLE el nombre,
# que es lo que hace falta para armar patrones: sin esto, el modo filtro
# inventa corrida-aaaammdd-hhmmss y cambia en cada corrida.
    -nombre)  NOMBRE_DADO=$2; shift 2 ;;
# LOS DOS CONTROLES DE CORRIDA (paso 10, ver el manual (apendice de codigos)). Van al entorno y
# los leen las dos fases, que no parsean argumentos.
#   --parar 1   seguir mientras se pueda: una corrida, todos los problemas
#               (el DEFECTO)
#   --parar 2   parar rapido, en el primer error
#   --verbose 1 solo las salidas y los errores
#   --verbose 2 el listado completo (el DEFECTO)
#   --verbose 3 con el detalle interno
    --parar)   SCEPTRE_PARAR=$2; export SCEPTRE_PARAR; shift 2 ;;
    --verbose) SCEPTRE_VERBOSE=$2; export SCEPTRE_VERBOSE; shift 2 ;;
# --lector propio|slex|tokens (26/10/2026; el dato el 18/11/2026): el lector
# del deck de la fase 1. Va al entorno como los otros dos; sceptreM lee
# SCEPTRE_LECTOR. 'slex' es la omision y lee el deck POR EL DATO --d2datdinc
# lo lee a su estructura en memoria y libd la recorre item por item a las
# hojas, el mismo camino que un .dsa; con el, los modelos los expande el
# lector de C, como --modelos c--. 'tokens' es lo que 'slex' queria decir
# antes (el deck cortado en tokens) y queda para comparar un camino con el
# otro. 'propio' es el lector de siempre, entero.
    --lector)  case "$2" in propio|slex|tokens) ;; *) echo "sc1: --lector $2: tiene que ser propio, slex o tokens" >&2; exit 106 ;; esac
               SCEPTRE_LECTOR=$2; export SCEPTRE_LECTOR; shift 2 ;;
# --modelos sceptre|c (29/10/2026, pasos/modelos-c.diff): quien expande los
# MODEL. Va al entorno como --lector, asi tambien vale para cada deck de -lote.
    --modelos) case "$2" in sceptre|c) ;; *) echo "sc1: --modelos $2: tiene que ser sceptre o c" >&2; exit 106 ;; esac
               SCEPTRE_MODELOS=$2; export SCEPTRE_MODELOS; shift 2 ;;
# --tablas tabular2|sceptre (29/10/2026, pasos/tablas-tabular2.diff): con que
# interpola la fase 2 las TABLE del deck. Va al entorno; sceptreDU lee SCEPTRE_TABLAS.
    --tablas)  case "$2" in tabular2|sceptre) ;; *) echo "sc1: --tablas $2: tiene que ser tabular2 o sceptre" >&2; exit 106 ;; esac
               SCEPTRE_TABLAS=$2; export SCEPTRE_TABLAS; shift 2 ;;
    -continuar) CONTINUAR=1; shift ;;
# -sinlatido (21/10/2026, pasos/latido-fase2.diff): apaga el corte de la fase
# 2 trabada. Va al entorno, como --parar y --verbose: sceptreDU lee
# SCEPTRE_SIN_AVANCE en los dos modos, y 0 es 'sin corte'.
    -sinlatido) SCEPTRE_SIN_AVANCE=0; export SCEPTRE_SIN_AVANCE; shift ;;
    -lote) LOTE=1; NOPC=$(( ${#ARGS_ORIG[@]} - $# )); shift; break ;;
    -)   break ;;    # el deck viene por la entrada estandar: lo ve el modo filtro
    -*)  echo "sc1: opcion desconocida $1" >&2; ayuda >&2; exit 106 ;;
    *)   break ;;
  esac
done
FILTRO=0
RCSCEPTRE=0
# --- modo LOTE: sc1 [opciones] -lote CASO1.d CASO2.d ... (21/10/2026) -----
# UN SOLO sceptreDU PARA TODOS LOS DECKS (paso 9, el manual (agregados/36-so-y-servidor.tex)). Se levanta
# 'sceptreDU --servidor' con dos FIFO (pedidos y respuestas, en los descriptores 8
# y 9) y se vuelve a llamar a sc1 por cada deck, con las mismas opciones y
# SC1_SERVIDOR=1: ese sc1 hace todo como siempre --fase 1, el .so con su
# cache por huella, los archivos de salida-- salvo la fase 2, que en lugar de
# correr bin/sceptreDU la pide al servidor y espera su codigo. Los decks van uno
# atras del otro, en este directorio, como si se corrieran a mano.
if [ $LOTE = 1 ]; then
   OPCS=("${ARGS_ORIG[@]:0:$NOPC}")
   if [ $# = 0 ]; then echo "sc1: -lote sin decks" >&2; exit 106; fi
   if [ $ESTATICO = 1 ]; then echo "sc1: -lote es del modo dinamico (sin -estatico)" >&2; exit 106; fi
   case "$EXEC2BIN" in NO-ENCONTRADO:*)
      echo "sc1: falta bin/sceptreDU para el modo dinamico (make -C sceptreDU sceptreDU; make sync)" >&2; exit 108 ;;
   esac
   for D in "$@"; do
      if [ "$D" = "-" ]; then echo "sc1: -lote no lee decks por la entrada estandar" >&2; exit 106; fi
   done
   LOTEDIR=`mktemp -d "${TMPDIR:-/tmp}/sc1lote.XXXXXX"` || { echo "sc1: no pude crear el directorio temporal" >&2; exit 108; }
   mkfifo "$LOTEDIR/pedidos" "$LOTEDIR/respuestas" || exit 108
   "$EXEC2BIN" --servidor < "$LOTEDIR/pedidos" > "$LOTEDIR/respuestas" &
   PIDSERV=$!
   # el mismo orden que el servidor (primero pedidos, despues respuestas): si
   # no, cada uno espera al otro al abrir
   exec 8> "$LOTEDIR/pedidos" 9< "$LOTEDIR/respuestas"
   # LA FASE 1 DE TODOS LOS DECKS JUNTOS (22/10/2026, pasos/sc1-lote-sceptreM.diff):
   # cada deck tiene un directorio en el del lote, con su nombre, que arma sc1
   # con SC1_PREPARA (input.dat, la modellib, y en sceptreM.entorno sus huellas y
   # su listado); un solo 'sceptreM --lote' corre la fase 1 de todos, cada uno en
   # un hijo, con el deck adelante de cada renglon y 'CASO: FIN tipo codigo' al
   # terminar (sceptreM/lote.f90). Despues sc1 sigue deck por deck desde lo que dejo
   # su directorio (SC1_FASE1_DIR). El que reutiliza su .so o continua una
   # corrida (-continuar) no entra: hace la fase 1 en su turno, como siempre.
   # el nombre de cada caso: CASO de CASO.d, CASO.dsa o CASO.M.dsa (17/11/2026)
   nombre_caso () { local n=${1##*/}; n=${n%.d}; n=${n%.dsa}; n=${n%.M}; echo "$n"; }
   NOMS=(); LISTA1=()
   for D in "$@"; do
      N=$(nombre_caso "$D"); while [ -e "$LOTEDIR/$N" ]; do N=$N.otro; done
      mkdir "$LOTEDIR/$N"; NOMS+=("$N")
      SC1_PREPARA="$LOTEDIR/$N" "$0" "${OPCS[@]}" "$D" > /dev/null 2>&1
      if [ "`cat "$LOTEDIR/$N/modo" 2>/dev/null`" = lote ]; then LISTA1+=("$N"); fi
   done
   if [ ${#LISTA1[@]} -gt 0 ]; then
      ( cd "$LOTEDIR" && "$SCEPTREM" --lote "${LISTA1[@]}" < /dev/null )
   fi
   RCLOTE=0; RESUMEN=; i=0
   for D in "$@"; do
      F1=; if test -f "$LOTEDIR/${NOMS[$i]}/sceptreM.fin"; then F1=$LOTEDIR/${NOMS[$i]}; fi
      i=$((i+1))
      SC1_SERVIDOR=1 SC1_FASE1_DIR="$F1" "$0" "${OPCS[@]}" "$D"; RC=$?
      RESUMEN="$RESUMEN$(nombre_caso "$D") $RC
"
      if [ $RCLOTE = 0 ] && [ $RC != 0 ]; then RCLOTE=$RC; fi
   done
   exec 8>&-                 # sin pedidos, el servidor termina
   cat <&9 > /dev/null
   exec 9<&-
   wait $PIDSERV
   rm -f "$LOTEDIR/pedidos" "$LOTEDIR/respuestas"
   # los directorios de la fase 1: solo si LOTEDIR es el temporal que se hizo
   # arriba (nunca un rm -rf de una ruta que pudiera venir vacia)
   case "$LOTEDIR" in "${TMPDIR:-/tmp}"/sc1lote.??????) rm -rf -- "$LOTEDIR" ;; esac
   echo "sc1 -lote:"
   printf '%s' "$RESUMEN"
   exit $RCLOTE
fi
# --- modo FILTRO: sc1 - ---------------------------------------------------
# "sc1 -" lee el deck por la ENTRADA ESTANDAR, deja el .sim en la SALIDA
# ESTANDAR y manda TODO lo demas (listados, avisos, errores) a la salida de
# error: asi sc1 se puede usar en una tuberia. Se trabaja en un directorio
# temporal, que se borra al salir; con -o DIR las salidas quedan tambien ahi.
if [ "${1:-}" = "-" ]; then
   FILTRO=1
   shift
   TEMPORAL=`mktemp -d "${TMPDIR:-/tmp}/sc1.XXXXXX"` || { echo "sc1: no pude crear el directorio temporal" >&2; exit 108; }
   # sin -o, las salidas se quedan en el temporal y se van con el: un filtro
   # no tiene que ensuciar el directorio de quien lo llama
   if [ "${OUTDIR_DADO:-0}" = 1 ]; then
      case "$OUTDIR" in /*) : ;; *) OUTDIR=`CDPATH= cd -- "$OUTDIR" && pwd` ;; esac
   else
      OUTDIR=.
   fi
# EL NOMBRE DE LA CORRIDA, cuando el deck entra por la tuberia. Antes el caso
# se llamaba 'stdin' SIEMPRE, asi que dos corridas por tuberia no se
# distinguian: ni sus listados, ni su .sim, ni su .log. Ahora se le inventa
# uno con la fecha y la hora --corrida-aaaammdd-hhmmss-- que ademas ordena
# bien alfabeticamente, y es el MISMO para las dos fases y para todos los
# archivos que deja, que es lo que importa: una corrida, un nombre.
#
# El nombre lo pone EL LANZADOR y no el Fortran, a proposito: que archivos
# quedan y como se llaman es cosa de aca (paso 10, ver el manual (apendice de codigos)).
   NOMBRE_FILTRO=${NOMBRE_DADO:-corrida-$(date +%Y%m%d-%H%M%S)}
   cat > "$TEMPORAL/$NOMBRE_FILTRO.d"
   trap 'cd /; rm -rf "$TEMPORAL"' 0 1 2 3 15
   cd "$TEMPORAL"
   set -- "$NOMBRE_FILTRO.d"
   exec 3>&1 1>&2      # el .sim va al 3 (el stdout de verdad); todo lo demas, a stderr
   exec < /dev/null    # el deck ya se leyo: que los "press ENTER" no se lo coman
   less () { cat "$@"; }      # nada de paginador en una tuberia
fi

if [ -z "${1:-}" ]; then ayuda >&2; exit 106; fi
ORIGEN_USUARIO=$1; MODO_ORIGEN=original
if [ -f "$1" ]; then
   ORIGEN_USUARIO="$(CDPATH= cd -- "$(dirname "$1")" && pwd)/$(basename "$1")"
fi
if [ "${FILTRO:-0}" = 1 ]; then ORIGEN_USUARIO='<stdin>'; fi
# LO QUE ENTRA (04/11/2026, el manual (agregados/31, "La politica de la entrada") y PLAN-SIN-DS paso 5): un
# .d de SCEPTRE, el par .d partido (X.M.d + X.DU.d) o el par .dsa (X.M.dsa +
# X.DU.dsa). Un .ds de siru ya NO entra: se convierte una vez a su par .dsa
# con slex/viejos/dsa-python/traducir.py y queda versionado, en vez de traducirlo en cada
# corrida.
case "$1" in
# UN .dsa A LA ENTRADA (03/11/2026, paso 11 etapa 9, PLAN-SEPARAR-MODELO-
# DATOS-USOS.md): el archivo partido en MODELO / DATOS / USOS. 'sc1 X.dsa' es
# el archivo reunido; 'sc1 X.M.dsa' es el modelo solo y busca sus DATOS y
# USOS en X.DU.dsa, al lado.
#
# LO LEE d2datdinc, EN C (04/11/2026, PLAN-DSA-EN-C.md etapa 4): 'd2datdinc
# X.M.dsa --d' da el deck de la fase 1 sin python en el camino, que es lo que
# pidio el autor (el paquete instalado no debe necesitar python3 ni el
# traductor para correr). El lector del .dsa es libdsa, en slex, el mismo que
# enlaza sceptreDU para los DU. A diferencia del .ds, un rechazo CORTA con el
# 107: el diagnostico dice exactamente que construccion falta, y seguir tal
# cual lo taparia con los errores de READIN. D2DATDINC, D2DATDINC_CONF y
# D2DATDINC_BIB eligen el programa, sus reglas y la biblioteca.
  *.dsa)
     DSA=$1; DSADIR=$(dirname "$DSA"); DSABASE=$(basename "$DSA" .dsa); DU=
     case "$DSABASE" in
       *.DU) echo "sc1: $DSA es solo DATOS y USOS: el que entra es el modelo (sc1 ${DSA%.DU.dsa}.M.dsa lo busca al lado)"; exit 107 ;;
       *.M)  DSABASE=${DSABASE%.M}; DU=$DSADIR/$DSABASE.DU.dsa
             if [ ! -f "$DU" ]; then echo "sc1: $DSA es un modelo (M) y faltan sus DATOS y USOS: $DU"; exit 107; fi ;;
     esac
     # LA FASE 1 LEE EL .dsa (16/11/2026, el manual (agregados/31-lectura-slex-y-dsa.tex) paso
     # 4; el autor: "es la fase 1 la que debe leer el .dsa"). sc1 ya no lo
     # traduce a un .d: arma el .dsa REUNIDO --el modelo y, si esta, su DU,
     # uno detras del otro, que es la forma corta-- sin el PARAPLOT (que es
     # del lanzador, CASO.graficos.ds), y ese es el input.dat de la fase 1,
     # que lo reconoce por su primer renglon y lo carga directo a sus
     # variables (sceptreM/lector_dsa.c).
     D2D=${D2DATDINC:-d2datdinc}
     if ! command -v "$D2D" >/dev/null 2>&1; then
        echo "sc1: $DSA es un .dsa y no hay d2datdinc para separar su PARAPLOT ($D2D; D2DATDINC lo elige)"
        exit 108
     fi
     # La extensión ya identifica la entrada. La marca de transporte que
     # reconoce la fase 1 se agrega al reunirla: MOTOR puede ser la primera
     # sentencia de un modelo escrito a mano o normalizado por otro programa.
     DSA_CASO=${NOMBRE_DADO:-$DSABASE}
     DSA_DIR=$DSADIR
     DSA_JUNTO=$PWD/$DSA_CASO.entrada.dsa
     printf '# dsa entrada reunida por sc1\n' > "$DSA_JUNTO.todo" || exit 107
     if [ -n "$DU" ]; then cat "$DSA" "$DU" >> "$DSA_JUNTO.todo" || exit 107
     else cat "$DSA" >> "$DSA_JUNTO.todo" || exit 107
     fi
     "$D2D" "$DSA_JUNTO.todo" --separar-paraplot "$DSA_CASO.graficos.ds" -o "$DSA_JUNTO" || exit $?
     rm -f "$DSA_JUNTO.todo"
     PARAPLOT_DSA=$DSA_CASO.graficos.ds
     echo "sc1: $DSA${DU:+ + $DU} a la fase 1 como .dsa (sin traducir a .d)"
     shift; set -- "$DSA_JUNTO" "$@"
     ;;
# UN .d PARTIDO EN MODELO / DATOS-USOS (03/11/2026, pedido del autor: el
# corpus queda dividido en CASO.M.d + CASO.DU.d): 'sc1 X.M.d' busca X.DU.d
# al lado y los junta por cat en X.d (la division es un corte de lineas:
# el junto es byte a byte el deck de siempre), avisando. Si ya hay un X.d
# identico lo reutiliza; distinto, corta sin pisarlo. 'sc1 X.DU.d' no
# entra solo, como el .DU.dsa.
  *.M.d)
     MD=$1; MDDIR=$(dirname "$MD"); MDBASE=$(basename "$MD" .M.d)
     DU=$MDDIR/$MDBASE.DU.d
     if [ ! -f "$DU" ]; then echo "sc1: $MD es un modelo (M) y faltan sus DATOS y USOS: $DU"; exit 107; fi
     JUNTO=$MDDIR/$MDBASE.d
     if [ -e "$JUNTO" ]; then
        if cat "$MD" "$DU" | cmp -s - "$JUNTO"; then
           echo "sc1: $MD + $DU ya estan juntos en $JUNTO: se reutiliza"
        else
           echo "sc1: ya hay un $JUNTO distinto de $MD + $DU y no se pisa"; exit 107
        fi
     else
        cat "$MD" "$DU" > "$JUNTO" || exit 107
        echo "sc1: $MD + $DU juntados en $JUNTO"
     fi
     shift; set -- "$JUNTO" "$@"
     ;;
  *.DU.d)
     echo "sc1: $1 es solo DATOS y USOS: el que entra es el modelo (sc1 ${1%.DU.d}.M.d lo busca al lado)"; exit 107 ;;
  *.ds|*.ds2)
     # EL .ds YA NO ENTRA (04/11/2026, PLAN-SIN-DS paso 5). Hasta hoy sc1 lo
     # traducia con 'd2datdinc --d' en cada corrida; el .ds dejo de existir en
     # el arbol --cada deck quedo como su par .dsa (MODELO / DATOS y USOS)-- y
     # traducir en cada corrida tapaba de que archivo sale lo que corre. La
     # conversion se hace UNA vez y queda versionada.
     echo "sc1: $1 es un .ds y ya no entra (PLAN-SIN-DS paso 5): convertilo una vez a su par .dsa"
     echo "sc1:   python3 slex/viejos/dsa-python/traducir.py $1      # escribe ${1%.ds*}.M.dsa y ${1%.ds*}.DU.dsa"
     echo "sc1:   sc1 ${1%.ds*}.M.dsa             # el modelo, con su DU al lado"
     echo "sc1: si el traductor rechaza alguna construccion, su diagnostico dice cual"
     exit 107
     ;;
esac
# UN SOLO HILO DE OpenBLAS si no viene puesto (paso 5, el manual (07-algebra)):
# con el algebra LAPACK (el por omision; SCEPTRE_ALGEBRA=propia la apaga) los hilos cambian el orden de las sumas entre
# corridas; la biblioteca lee el entorno al cargarse, asi que lo exporta el
# lanzador. Sin lapack no cambia nada: nadie mas la usa.
export OPENBLAS_NUM_THREADS=${OPENBLAS_NUM_THREADS:-1}

CASO=$(basename "$1" .d)
# EL DECK QUE ENTRA: el .d, o el .dsa reunido que armo la rama .dsa
DECK=$(dirname "$1")/$CASO.d
if [ -n "${DSA_CASO:-}" ]; then DECK=$1; CASO=$DSA_CASO; fi
# con -nombre, la corrida se llama como se pidio y no como el archivo
if [ -n "${NOMBRE_DADO:-}" ]; then CASO=$NOMBRE_DADO; fi
DIR=$(dirname "$1")
if [ -n "${DSA_CASO:-}" ]; then DIR=$DSA_DIR; fi
if [ ! -d "$OUTDIR" ]; then echo "sc1: $OUTDIR no es un directorio" >&2; exit 107; fi
if [ ! -f "$MODELLIB" ]; then echo "sc1: no existe la modellib $MODELLIB" >&2; exit 108; fi

if test -f "$DECK"
then
# NO se borran ${CASO}.datasave ni ${CASO}.acsave: cuando el .d esta en este
# directorio son el PAR que se reutiliza (paso 9); si se regeneran, se
# sobreescriben. Lo que se borra es lo de la corrida anterior.
  rm -f "$OUTDIR/$CASO.origen.json" "$OUTDIR/$CASO.singularidad.matriz" "$CASO.origen-error" singularidad.matriz
  rm -vf ${CASO}.datasave-final ${CASO}_pgmsave.f ${CASO}.plotsave $CASO.ls[12]
# con -continuar se conserva lo heredado de la corrida base, que CONTINUE y
# RE-OUTPUT necesitan (pgmsave.for, datasave.dat, plotsave.dat): defecto 22
  if [ $CONTINUAR = 0 ]; then rm -vf datasave.dat acsave.dat matsave.dat pgmsave.for plotsave.dat; fi
# EL CIRCUITO COMO .so (paso 9, tanda 3; ver el manual (agregados/36-so-y-servidor.tex)). Sin -estatico, el
# programa generado se compila con -fPIC -shared a $SODIR/CASO.so y lo carga
# bin/sceptreDU (SCEPTRE_SO), que esta enlazado una sola vez; junto al .so queda
# CASO.datasave, el de la fase 1, que es lo que hace falta para repetir la
# corrida. Decision del autor: el par vive JUNTO AL .d. Si el par esta y
# CASO.huella coincide con las huellas de hoy (tanda 4), no se corre la fase
# 1 ni gfortran: se reutiliza (-rehacer lo fuerza).
#
# OJO, paso el 19/10/2026: este bloque quedo DUPLICADO por un guion de parche
# que lo reinserto con la regla vieja ("el .so mas nuevo que el .d"), y la
# segunda copia ganaba: desde el lanzador, que copia el .d en cada corrida,
# nunca reutilizaba. Si se vuelve a parchar, mirar que haya UN solo REUSA=.
  SODIR=${SODIR:-$DIR}
# Sin bin/sceptreDU no hay modo dinamico, y es un ERROR, no un cambio de modo a
# escondidas (decision del autor): el sc1 que sabe de -estatico es de la misma
# version que el Makefile que construye bin/sceptreDU, asi que faltar solo puede
# ser un arbol a medio construir.
  if [ $ESTATICO = 0 ]; then
     case "$EXEC2BIN" in NO-ENCONTRADO:*)
        echo "sc1: falta bin/sceptreDU para el modo dinamico (make -C sceptreDU sceptreDU; make sync), o -estatico" >&2; exit 108 ;;
     esac
  fi
  if [ $ESTATICO = 0 ] && [ ! -w "$SODIR" ]; then
     echo "sc1: en $SODIR no se puede escribir: CASO.so y CASO.datasave van a $OUTDIR" >&2
     SODIR=$OUTDIR
  fi
# LAS HUELLAS (tanda 4): md5 del .d, de la modellib y de x2 (lib/sceptreDU.huella,
# del Makefile de x2). Van al entorno para que la fase 1 las emita en
# SC1_ORIGEN y la fase 2 las compare (85 si no coinciden), y a CASO.huella
# junto al par: se reutiliza solo si las tres son las de hoy (y la de sceptreM).
  HD=`md5sum < "$DECK" | cut -c1-32`
# LA HUELLA DE LOS MODELOS (HM) es la de TODAS las bibliotecas, no la de un
# archivo: los modelos que entran en el texto pueden venir de la instalada o
# del directorio del usuario, y el .d no cambia cuando el usuario cambia un
# modelo suyo. Sin esto, sc1 reutilizaria el .so viejo sin avisar, que es el
# error peligroso (05/11/2026).
  HM=`cat "$MODELLIB" ${MODELOSPROPIOS:-} 2>/dev/null | md5sum | cut -c1-32`
  case "$HUELLAX2" in NO-ENCONTRADO:*) HX=sin-huella ;; *) HX=`cut -c1-32 < "$HUELLAX2"` ;; esac
# y la de la fase 1 (20/10/2026): el .so es lo que sceptreM genero, asi que si
# cambia sceptreM el par viejo no sirve. Antes no estaba, y despues de cambiar la
# fase 1 sc1 reutilizaba un programa generado por la anterior, sin avisar.
# Solo va a CASO.huella (la fase 2 no la compara: no la conoce).
  H1=`md5sum < "$SCEPTREM" | cut -c1-32`
# LAS FUNCIONES PROPIAS DEL USUARIO (05/11/2026, pedido del autor): si hay
# .f90 en su directorio de funciones --el que le crea sceptre-user-setup-- sc1
# arma solo la biblioteca dinamica y la usa. Si no hay ninguno, no cambia
# nada; --sin-funciones la saltea por esta vez.
#
# Se rehace solo si algun .f90 es mas nuevo que el .so, asi la corrida normal
# no paga nada. El .so entra en la huella del caso (abajo), asi que cambiar una
# funcion obliga a rehacer el circuito: no queda una corrida con la version
# vieja. Y va con -fPIC, que es lo que el modo dinamico necesita.
  FUNDIR=${SCEPTRE_FUNCIONES:-${XDG_CONFIG_HOME:-$HOME/.config}/sceptre/funciones}
  FUNSO=
  if [ "${SINFUN:-0}" != 1 ] && [ -d "$FUNDIR" ]; then
     FUNFUENTES=`ls "$FUNDIR"/*.f90 2>/dev/null || true`
     if [ -n "$FUNFUENTES" ]; then
        FUNSO=${SCEPTRE_FUNCIONES_SO:-${XDG_DATA_HOME:-$HOME/.local/share}/sceptre/lib/funciones-usuario.so}
        mkdir -p "`dirname "$FUNSO"`" 2>/dev/null || true
        REHACER=0
        test -f "$FUNSO" || REHACER=1
        for f in $FUNFUENTES; do test "$f" -nt "$FUNSO" && REHACER=1; done
        FUNLIBS=${SCEPTRE_FUNCIONES_LIBS:-}
        if [ ! -f "$FUNSO.enlace" ] || [ "`cat "$FUNSO.enlace"`" != "$FUNLIBS" ]; then REHACER=1; fi
        if [ $REHACER = 1 ]; then
           echo "sc1: armando las funciones propias ($FUNDIR -> $FUNSO)"
           if ${FC} ${FFLAGS} -fPIC -shared -o "$FUNSO" $FUNFUENTES $FUNLIBS 2> "$DIR/$CASO.funciones"; then
              printf '%s\n' "$FUNLIBS" > "$FUNSO.enlace"
              rm -f "$DIR/$CASO.funciones"
           else
              echo "sc1: no se pudieron compilar las funciones de $FUNDIR (ver $CASO.funciones)" >&2
              cat "$DIR/$CASO.funciones" >&2
              exit 109
           fi
        fi
     fi
  fi

# LA BIBLIOTECA DE USUARIO PROPIA (21/10/2026, pasos/DEFECTOS 44): si no es la
# del arbol (-u, o USRLIB en sceptre.conf), en el modo dinamico va ADENTRO del
# .so del circuito --antes no se usaba: bin/sceptreDU trae la del arbol y una
# funcion que solo estuviera en la de -u dejaba el .so sin cargar (83)-- y su
# md5 va a CASO.huella, asi que si cambia la biblioteca el .so se rehace.
  USRLIB_PROPIA=0; HU=usrlib-de-sceptreDU
  # sin biblioteca no hay nada propio que mezclar en la huella
  if [ -n "$USRLIB" ] && [ "$USRLIB" != "$USRLIB_ARBOL" ]; then
     USRLIB_PROPIA=1; HU=`md5sum < "$USRLIB" | cut -c1-32`
  fi
  HF=sin-funciones
  test -n "$FUNSO" && test -f "$FUNSO" && HF=`md5sum < "$FUNSO" | cut -c1-32`
  SCEPTRE_HUELLA_D=$HD; SCEPTRE_HUELLA_MODELLIB=$HM; SCEPTRE_HUELLA_X2=$HX
  export SCEPTRE_HUELLA_D SCEPTRE_HUELLA_MODELLIB SCEPTRE_HUELLA_X2
# EL REUSO ES POR EL GENERADO (28/10/2026, pasos/declara-usos-3.diff): la fase
# 1 corre siempre (son segundos) y el .so se reutiliza si el programa que
# genero hoy es el mismo que compilo el .so guardado --CASO.huella: md5 del
# generado sin SC1_ORIGEN, el de x2 y el de la biblioteca de usuario--, asi
# que cambiar datos o usos (valores, conjuntos, controles) no pasa por
# gfortran; cambiar el modelo si. Se decide despues de la fase 1 (abajo).
# Antes la huella era la del .d, y cualquier cambio del deck recompilaba.
  REUSA=0; HDX=$HD; HMX=$HM   # las huellas que la fase 2 compara con SC1_ORIGEN del .so
# LOS MODELOS DECLARADOS (28/10/2026, el manual (agregados/34-modelos-declarados.tex), pasos/sc1-
# modelos.diff): si el deck dice OBSERVABLES, VARIABLES o LINEALIZADO, la fase 1
# corre una vez por modelo (SCEPTRE_MODELO=comun|observable|lineal, cada uno
# completo), cada programa va a su .so (CASO-MODELO.so, con el reuso por el
# generado) y la fase 2 carga el que los RUN del deck piden: un RUN del
# adjunto, el observable; RUN AC, el lineal; lo demas, el comun.
  MODELOS=""; ELEGIDO=""; SONOM=$CASO
  # en un .dsa: los campos OBSERVABLES: y VARIABLES:, la frase LINEALIZADO,
  # y los RUN como controles (SCEPTRE_SENS, _WC, _MC, _AC) o como renglones
  # de CONTROLES_SCEPTRE ("RUN OPTIMIZATION")
  if grep -q -i -E '^ *(OBSERVABLES|VARIABLES|LINEALIZADO) *(:.*|;.*)?$' "$DECK"; then
     MODELOS="comun"
     if grep -q -i -E '^ *(OBSERVABLES|VARIABLES) *(:.*|;.*)?$' "$DECK"; then MODELOS="$MODELOS observable"; fi
     if grep -q -i -E '^ *LINEALIZADO *(;.*)?$' "$DECK"; then MODELOS="$MODELOS lineal"; fi
     ELEGIDO=comun
     if grep -q -i -E '^ *"?RUN +(SENSITIVITY|OPTIMIZATION|WORST +CASE|MONTE +CARLO)|^ *SCEPTRE_(SENS|WC|MC) *=' "$DECK"; then ELEGIDO=observable
     elif grep -q -i -E '^ *"?RUN +AC *("|;.*)?$|^ *SCEPTRE_AC *=' "$DECK"; then ELEGIDO=lineal; fi
     case " $MODELOS " in *" $ELEGIDO "*) ;; *)
        echo "sc1: el deck pide el modelo $ELEGIDO (por sus RUN) pero no lo declara (OBSERVABLES o LINEALIZADO)" | tee -a $CASO.log >&2; exit 106 ;;
     esac
     SONOM=$CASO-$ELEGIDO
  fi
# SC1_PREPARA=DIR (22/10/2026, lo pone sc1 -lote): solo arma DIR para que la fase
# 1 la haga 'sceptreM --lote' y sale; deja en DIR/modo 'lote' o, si este deck
# reutiliza su .so o continua una corrida, 'propio' (hace la fase 1 en su turno)
  if [ -n "${SC1_PREPARA:-}" ]; then
     if [ $CONTINUAR = 1 ] || [ -n "$MODELOS" ]; then echo propio > "$SC1_PREPARA/modo"; exit 0; fi
     expande_deck "$SC1_PREPARA/input.dat" || exit $?
     inserta_modelos "$SC1_PREPARA/input.dat" || exit $?
     { echo "SCEPTRE_LOG=$PWD/$CASO.log"; echo "SCEPTRE_HUELLA_D=$HD"
       echo "SCEPTRE_HUELLA_MODELLIB=$HM"; echo "SCEPTRE_HUELLA_X2=$HX"; } > "$SC1_PREPARA/sceptreM.entorno"
     echo lote > "$SC1_PREPARA/modo"
     exit 0
  fi
  expande_deck input.dat || exit $?
  inserta_modelos input.dat || exit $?
# EL LISTADO ES UNO SOLO POR CASO, EN APPEND. Las dos fases escriben el
# archivo que diga SCEPTRE_LOG --lo abren al final de lo que ya tenga-- asi
# que el listado de la fase 1, el de la fase 2 y los de las corridas
# sucesivas quedan uno atras del otro, en orden. Antes las dos escribian
# 'sceptre.lis' desde el principio y habia que moverlo entre fase y fase, de
# donde salian los .ls1 y .ls2: eran nombres de este script, no del programa.
#
# No se borra: si el caso se vuelve a correr, la corrida nueva se agrega. Lo
# borra el usuario cuando quiere empezar de cero.
  SCEPTRE_LOG=$CASO.log; export SCEPTRE_LOG
  # EL CODIGO DE SALIDA DE CADA FASE SE GUARDA Y ES CON EL QUE SALE sc1 (paso
# 10; lo encontro el comparador del otro arbol: sc1 escribia '124 | TRPRK' en
# el log y salia con 0, el mismo defecto que tenia el guion viejo). Y las dos
# fases corren con la entrada estandar cerrada, para que nunca se queden
# esperando algo que no va a llegar.
  if [ -n "${SC1_FASE1_DIR:-}" ]; then
     # LA FASE 1 YA LA HIZO 'sceptreM --lote' en SC1_FASE1_DIR (modo -lote): el codigo
     # sale de su sceptreM.fin ('FIN tipo codigo'; una senal, 128 mas su numero, como
     # en el shell) y lo que dejo se trae aca; el listado ya esta en $CASO.log
     read -r F1FIN F1TIPO RC1 < "$SC1_FASE1_DIR/sceptreM.fin" || RC1=108
     if [ "$F1TIPO" = "señal" ]; then RC1=$((128 + RC1)); fi
     for f in pgmsave.for datasave.dat acsave.dat matsave.dat; do
        if test -f "$SC1_FASE1_DIR/$f"; then cp "$SC1_FASE1_DIR/$f" $f; fi
     done
     RCSCEPTRE=$RC1
  elif [ -n "$MODELOS" ]; then
     # LOS MODELOS DECLARADOS: la fase 1 una vez por modelo, cada una en su
     # directorio fase1-MODELO; el listado del elegido va a CASO.log, los otros
     # a CASO-MODELO.log; lo del elegido queda aca como si fuera la unica
     for m in $MODELOS; do
        mkdir -p "fase1-$m"; rm -f "fase1-$m/pgmsave.for" "fase1-$m/datasave.dat" "fase1-$m/acsave.dat" "fase1-$m/matsave.dat" "fase1-$m/codigo"
        cp input.dat "fase1-$m/input.dat"; cp input.dat.origen "fase1-$m/input.dat.origen"
        if [ $m = $ELEGIDO ]; then L=$PWD/$CASO.log; else L=$PWD/$CASO-$m.log; fi
        ( cd "fase1-$m" && SCEPTRE_MODELO=$m SCEPTRE_LOG=$L $SCEPTREM < /dev/null; echo $? > codigo )
     done
     RC1=`cat "fase1-$ELEGIDO/codigo"`; RCSCEPTRE=$RC1
     for f in pgmsave.for datasave.dat acsave.dat matsave.dat; do
        if test -f "fase1-$ELEGIDO/$f"; then cp "fase1-$ELEGIDO/$f" $f; fi
     done
  else
     $SCEPTREM < /dev/null; RC1=$?; RCSCEPTRE=$RC1
  fi
# Los dos "press ENTER to continue" con su 'read dummy' se fueron (pedido del
# autor, 19/10/2026): lanzado desde un programa sin '< /dev/null', sc1 se
# quedaba esperando un ENTER que nunca llegaba. El listado se sigue mostrando.
  echo " "
  if test -s "$SCEPTRE_LOG"; then less "$SCEPTRE_LOG"; fi
# SI LA FASE 1 CORTO POR SEVERIDAD 4 (110, tanda 7 de el manual (apendice de codigos)) NO HAY
# FASE 2: el corte puede llegar en medio de la generacion (WRTOUT, EQFORM) y
# dejar medio pgmsave.for, que no compila y taparia el 110 con un 109.
# Y LO MISMO CON CUALQUIER OTRO CODIGO DE LA FASE 1 (pasar los 999,
# 20/10/2026): el 91 de un numero que no entra tambien corta a mitad de la
# generacion. Antes ciilegal (73) dejaba medio programa y sc1 lo compilaba.
# El 103 --'falto modellib.dat y la corrida siguio'-- era el unico codigo
# distinto de 0 que dejaba un programa entero, y ya no existe: la biblioteca
# no es mas un archivo que puede faltar (05/11/2026).
  if [ "$RC1" = 0 ] && test -s pgmsave.for
  then
# remove trailing blanks
    sed 's/[ ]*$//g' < pgmsave.for > ${CASO}_pgmsave.f
    MAPA_ORIGEN="$OUTDIR/$CASO.origen.json"
    FUENTE_MAPA=$ORIGEN_USUARIO
    test -f "$FUENTE_MAPA" || FUENTE_MAPA="$DIR/$CASO.d"
    rm -f "$MAPA_ORIGEN"
    if ! python3 "$BINDIR/sceptre-origen" "$FUENTE_MAPA" "${CASO}_pgmsave.f" "$MAPA_ORIGEN" --generado-final "$OUTDIR/${CASO}_pgmsave.f" --modellib "$MODELLIB" 2>"$CASO.origen-error"; then
       echo "sc1: no se pudo preparar el mapa de procedencia; ver $CASO.origen-error" >&2
    else
       rm -f "$CASO.origen-error"
    fi
# EL REUSO POR EL GENERADO (ver arriba): la huella del programa de hoy, sin el
# bloque SC1_ORIGEN (que lleva la huella del .d y cambia con cualquier byte del
# deck). Si es la del .so guardado, y x2 y la biblioteca son los mismos, no hay
# gfortran; la fase 2 compara SC1_ORIGEN del .so con las huellas de ESE deck.
    HG=`sed '/^CSECT   SC1_ORIG/,/^      END\( \|$\)/d' pgmsave.for | md5sum | cut -c1-32`
    if [ $ESTATICO = 0 ] && [ $REHACER = 0 ] && [ $CONTINUAR = 0 ] \
       && test -f "$SODIR/$SONOM.so" && test -f "$SODIR/$SONOM.huella" \
       && [ "`cut -d' ' -f1-4 "$SODIR/$SONOM.huella"`" = "$HG $HX $HU $HF" ]; then
       REUSA=1
       read -r HG0 HX0 HU0 HF0 HDX HMX < "$SODIR/$SONOM.huella"
       echo "sc1: reutiliza $SODIR/$SONOM.so: el programa generado es el mismo (sin gfortran)" | tee -a $SCEPTRE_LOG
    fi
# LOS VOLCADOS DE LA FASE 1 SE LLAMAN CASO.datasave, CASO.acsave y CASO.plotsave
# (pedido del autor, 19/10/2026). Eran CASO_datasave.d, CASO_acsave.d y
# CASO_plotsave.d --la 'd' de data, de Novender-- y la extension .d es la del
# deck: no son decks (siru los tomaba por circuitos, siru/corpus/nousamos).
# Sin .dat tampoco, que es de siru. Lo mismo en exa.sh, tests/check-corpus.sh
# y corpus/hacer-patron.
    cp datasave.dat ${CASO}.datasave
    if test -f acsave.dat; then cp acsave.dat ${CASO}.acsave; fi
    if test -f matsave.dat; then cp matsave.dat ${CASO}.matsave; fi   # la matriz en datos (el manual (07-algebra))
    if [ $ESTATICO = 1 ]; then
      RCFC=0; ${FC} ${FFLAGS} -I "$MODDU" -o sceptreDU ${CASO}_pgmsave.f $SCEPTREDU $USRLIB $FUNSO $LIBDU -ltabular2 -llapack -lblas -lumfpack -lstdc++ 2>$CASO.compila || RCFC=$?   # -ltabular2: ETABLE
      gfortran_asesinado $RCFC $CASO.compila
      if [ $RCFC -ne 0 ]; then aviso_so_cambio $CASO.compila; fi
      if [ ! -x sceptreDU ]
         then
         less $CASO.compila
         exit 109
      fi
      ./sceptreDU < /dev/null; RC2=$?; if [ $RC2 -ne 0 ]; then
        RCSCEPTRE=$RC2
        if test -s "$MAPA_ORIGEN"; then echo "SCEPTRE: MAPA DE ECUACIONES | $MAPA_ORIGEN" >&2; fi
      fi
    else
      if [ $REUSA = 0 ]; then
        # -Bsymbolic-functions: lo que el circuito define Y x2 tambien trae (FCONVY de la
        # convolucion, SIMAC/AGDIM/LSDIM del AC...) se resuelve adentro del .so;
        # sin eso, con -rdynamic, la version de x2 en el ejecutable le ganaba a
        # la del circuito, que en modo estatico la pisaba al enlazar (8 casos
        # del corpus: a06b, cmpac, a11, a11vec, acdep, c14, diodosym, eydep).
        # Solo FUNCIONES: -Bsymbolic a secas ata tambien los datos y a08 se
        # colgaba (100 % de CPU, sin fin).
        USRLIB_SO=""; if [ $USRLIB_PROPIA = 1 ]; then USRLIB_SO=$USRLIB; fi
        RCFC=0; ${FC} ${FFLAGS} -fPIC -shared -Wl,-Bsymbolic-functions -I "$MODDU" -o "$SODIR/$SONOM.so" ${CASO}_pgmsave.f $USRLIB_SO $FUNSO 2>$CASO.compila || RCFC=$?
        gfortran_asesinado $RCFC $CASO.compila
        if [ $RCFC -ne 0 ]; then aviso_so_cambio $CASO.compila; fi
        if [ ! -f "$SODIR/$SONOM.so" ]
           then
           if [ $USRLIB_PROPIA = 1 ] && grep -q -- '-fPIC' $CASO.compila; then
              echo "sc1: la biblioteca $USRLIB no es PIC: para el modo dinamico hay que compilarla con -fPIC (o correr con -estatico)" | tee -a $CASO.compila >&2
           fi
           less $CASO.compila
           exit 109
        fi
        cp pgmsave.for "$SODIR/$SONOM.pgmsave"   # el programa que compilo el .so
        echo "$HG $HX $HU $HF $HD $HM" > "$SODIR/$SONOM.huella"
      fi
      # el par que se guarda junto al .d: el .so y el datasave DE LA FASE 1 de hoy
      cp datasave.dat "$SODIR/$SONOM.datasave"
      if test -f acsave.dat; then cp acsave.dat "$SODIR/$SONOM.acsave"; fi
      # LOS OTROS MODELOS DECLARADOS, cada uno a su .so con el mismo reuso por el
      # generado, para que cambiar los RUN del deck encuentre el suyo hecho
      USRLIB_SO=""; if [ $USRLIB_PROPIA = 1 ]; then USRLIB_SO=$USRLIB; fi
      for m in $MODELOS; do
         if [ $m = $ELEGIDO ]; then continue; fi
         if ! test -s "fase1-$m/pgmsave.for"; then echo "sc1: el modelo $m no se genero (codigo `cat fase1-$m/codigo 2>/dev/null`): ver $CASO-$m.log" | tee -a $SCEPTRE_LOG >&2; continue; fi
         sed 's/[ ]*$//g' < "fase1-$m/pgmsave.for" > ${CASO}-${m}_pgmsave.f
         HGM=`sed '/^CSECT   SC1_ORIG/,/^      END\( \|$\)/d' "fase1-$m/pgmsave.for" | md5sum | cut -c1-32`
         if [ $REHACER = 0 ] && test -f "$SODIR/$CASO-$m.so" && test -f "$SODIR/$CASO-$m.huella" \
            && [ "`cut -d' ' -f1-4 "$SODIR/$CASO-$m.huella"`" = "$HGM $HX $HU $HF" ]; then
            echo "sc1: reutiliza $SODIR/$CASO-$m.so (modelo $m): el programa generado es el mismo" | tee -a $SCEPTRE_LOG
         else
            RCFC=0; ${FC} ${FFLAGS} -fPIC -shared -Wl,-Bsymbolic-functions -I "$MODDU" -o "$SODIR/$CASO-$m.so" ${CASO}-${m}_pgmsave.f $USRLIB_SO $FUNSO 2>$CASO-$m.compila || RCFC=$?
            gfortran_asesinado $RCFC $CASO-$m.compila
            if [ ! -f "$SODIR/$CASO-$m.so" ]; then
               echo "sc1: el modelo $m no compilo: ver $CASO-$m.compila" | tee -a $SCEPTRE_LOG >&2
            else
               cp "fase1-$m/pgmsave.for" "$SODIR/$CASO-$m.pgmsave"
               echo "$HGM $HX $HU $HF $HD $HM" > "$SODIR/$CASO-$m.huella"
            fi
         fi
         cp "fase1-$m/datasave.dat" "$SODIR/$CASO-$m.datasave"
         if test -f "fase1-$m/acsave.dat"; then cp "fase1-$m/acsave.dat" "$SODIR/$CASO-$m.acsave"; fi
      done
      # CON -lote la fase 2 la hace el servidor (ver modo LOTE, arriba): el
      # pedido es 'DIRECTORIO CASO.so VAR=VALOR...' y la respuesta 'DIRECTORIO
      # CODIGO'; los mensajes de sceptreDU quedan en sceptreDU.salida y se muestran
      # aca. Un blanco en las rutas no entra en el renglon: corre sceptreDU como
      # siempre.
      SOABS=$SODIR/$SONOM.so
      case "$SOABS" in /*) : ;; *) SOABS=$PWD/$SOABS ;; esac
      if [ "${SC1_SERVIDOR:-0}" = 1 ] && [ "$PWD $SOABS $SCEPTRE_LOG" = "`echo $PWD $SOABS $SCEPTRE_LOG`" ]; then
        echo "$PWD $SOABS SCEPTRE_LOG=$SCEPTRE_LOG SCEPTRE_HUELLA_D=$HDX SCEPTRE_HUELLA_MODELLIB=$HMX SCEPTRE_HUELLA_X2=$HX" >&8
        read -r DIRRESP RC2 <&9 || RC2=108
        if test -f sceptreDU.salida; then cat sceptreDU.salida; rm -f sceptreDU.salida; fi
      else
        SCEPTRE_SO="$SODIR/$SONOM.so" SCEPTRE_HUELLA_D=$HDX SCEPTRE_HUELLA_MODELLIB=$HMX $EXEC2BIN < /dev/null; RC2=$?
      fi
      if [ $RC2 -ne 0 ]; then
        RCSCEPTRE=$RC2
        if test -s "$MAPA_ORIGEN"; then echo "SCEPTRE: MAPA DE ECUACIONES | $MAPA_ORIGEN" >&2; fi
      fi
    fi
    if test -s singularidad.matriz && test -s "$MAPA_ORIGEN"; then
       python3 "$BINDIR/sceptre-origen" "$FUENTE_MAPA" "${CASO}_pgmsave.f" "$MAPA_ORIGEN" --singularidad singularidad.matriz || :
       mv -f singularidad.matriz "$OUTDIR/$CASO.singularidad.matriz"
    fi
# los datos de ploteo que POST relee: RE-OUTPUT los necesita de la corrida
# anterior (defecto 21); se conservan como CASO.plotsave, igual que datasave
    if test -s plotsave.dat; then cp plotsave.dat ${CASO}.plotsave; fi
# y el datasave DESPUES de la corrida, que es el estado en el que quedo: es lo
# que un deck CONTINUE tiene que heredar. El de mas arriba es el que dejo la
# fase 1 (el estado inicial); con ese, un CONTINUE no continuaba nada,
# repetia la corrida desde t=0.
# EL ESTADO FINAL, reescrito por la fase 2, es lo que un CONTINUE hereda: va
# aparte, CASO.datasave-final, para no pisar el de la fase 1 (que es el que
# repite la corrida y el que se guarda junto al .so)
    if test -s datasave.dat; then cp datasave.dat ${CASO}.datasave-final; fi
    if test -s "$SCEPTRE_LOG"; then less "$SCEPTRE_LOG"; fi
    if test -f fort.7
      then
      mv fort.7 $CASO.dirac
    fi
    if test -s sceptre.sim
      then
      if [ $NOSIM = 1 ]; then rm -f sceptre.sim; else mv sceptre.sim $CASO.simnativo; fi
      else
      rm -f sceptre.sim
    fi
# en modo filtro, el .sim es LA salida: va por la salida estandar de verdad
    if test -s "$CASO.simnativo" && test -s "$CASO.graficos.ds"; then
       printf 'TABLE %s FORMATO=SIMUL\n' "$CASO" >> "$CASO.graficos.ds"
       # POS4 contiene nombres y componentes complejas: usar el exportador
       # existente, no adivinar las columnas a partir de OUTPUTS.
       EXPORTADOR=$(busca sceptre2simul "$BINDIR" "$BASEDIR/bin")
       case "$EXPORTADOR" in NO-ENCONTRADO:*) echo "sc1: falta sceptre2simul para la tabla grafica" >&2; exit 108 ;; esac
       TABLADIR=$(mktemp -d "${TMPDIR:-/tmp}/sc1-tabla.XXXXXX") || exit 108
       if ! "$EXPORTADOR" "$CASO.dirac" --salida "$TABLADIR/tabla.simul" >&2; then
          rm -f "$TABLADIR/tabla.simul"; rmdir "$TABLADIR"; exit 109
       fi
       cat "$TABLADIR/tabla.simul" >> "$CASO.graficos.ds"
       rm -f "$TABLADIR/tabla.simul"; rmdir "$TABLADIR"
       if [ $FILTRO = 1 ]; then cat "$CASO.graficos.ds" >&3; fi
    elif [ $FILTRO = 1 ] && test -s "$CASO.simnativo"; then cat "$CASO.simnativo" >&3; fi
    if [ "$OUTDIR" != "." ]; then
      mv -f $CASO.log $CASO.compila ${CASO}_pgmsave.f ${CASO}.datasave ${CASO}.datasave-final "$OUTDIR"/ 2>/dev/null
      test -f ${CASO}.acsave && mv -f ${CASO}.acsave "$OUTDIR"/
      test -f ${CASO}.plotsave && mv -f ${CASO}.plotsave "$OUTDIR"/
      test -f $CASO.dirac     && mv -f $CASO.dirac     "$OUTDIR"/
      test -f $CASO.simnativo && mv -f $CASO.simnativo "$OUTDIR"/
      test -s "$CASO.graficos.ds" && mv -f "$CASO.graficos.ds" "$OUTDIR"/
    fi
    ls -l "$OUTDIR"/$CASO[_.]* 2>/dev/null || ls -l $CASO[_.]*
# el fort.16 que deja POS4 (su unidad de log) quedaba suelto en el directorio
# de trabajo: si tiene algo que decir va a las salidas, y si esta vacio se va
    if test -s fort.16; then mv -f fort.16 "$OUTDIR/$CASO.pos4log"; else rm -f fort.16; fi
    rm -fv pgmsave.o sceptreDU input.dat
    rm -fv pgmsave.for acsave.dat datasave.dat plotsave.dat
  else
    echo 'simulation canceled'
    # el codigo es el de la fase 1 si fallo (101, 102...); si dijo 0 y aun asi
    # no dejo programa, es la cadena del guion: 109
    if [ "${RCSCEPTRE:-0}" -ne 0 ]; then exit $RCSCEPTRE; else exit 109; fi
  fi
else
  echo "sc1: $DIR/$CASO.d: no existe el archivo de entrada" >&2
  exit 107
fi
# el codigo de la fase que fallo, o 0; nunca el 0 fijo de antes
exit ${RCSCEPTRE:-0}
