2026-10-06  Entrega 1.0-24 con siru 1.0-3

	* debian/changelog: documenta el generador GLM v2 y SPLIT entregado
	con el motor. M5 sigue siendo un contrato, no una implementacion.
	* d2datdinc/probar: las referencias actuales de circuitoB ya
	incorporan los valores predeterminados nuevos; 103 pruebas pasan.
	Se conserva abajo el resultado historico de r2444.
	* Paquetes construidos en copia exportada: probar/varios y los
	seis tests del lexer pasan; dos comparaciones con el corpus externo
	se omiten en esa copia. Lintian sin errores, con el aviso previo
	de falta de pagina de manual para d2datdinc.

2026-10-06  M4 inicial: composicion SPLIT

	* din/split.inc, din.c, din.h, Makefile.am: din_split genera los
	mapas y descriptor autosuficiente para Lie-Trotter y Strang.
	Dos subflujos autonomos declarados exactos, paso fijo; rechaza
	capacidades no implementadas sin sustituirlas por otro metodo.
	* d2datdinc: selector SPLIT y controles textuales; pruebas/split.ds
	y cuatro comprobaciones en probar. Documentacion en ambos README
	y en siru/MANUAL.md y PLAN_CAPACIDADES_MOTOR.md.
	* Verificacion: las cuatro pruebas SPLIT pasan. En probar pasan
	101 de 103; las dos diferencias anteriores de circuitoB-ED3
	corresponden al nuevo paso/adaptacion predeterminados de otra
	sesion (0.001 adaptativo frente a la referencia 0.1 fija).
	No se cambian esa politica ni las referencias en este bloque.

2026-10-06  Motor de integracion (r2371)

	* din/glm.inc, d2datdinc/biblioteca/glm.json: contrato GLM v2 con
	adaptacion optativa para Euler, BDF2 efectivo/directo y AB2. La
	corrida incorpora glm_arranque con orden_error 2 y conserva lectura
	v1 fija. Rechaza DT/TICK en el modelo adaptativo. No agrega IDs.

	* d2datdinc/main.c: acepta versiones 1 y 2 del catalogo GLM.
	No se cambia el parser ni din.c;
	se conservan las migraciones Bison concurrentes.

	* din/README.md, d2datdinc/README.md: contrato y enlace a los limites
	y las pruebas de siru. Compilacion, 99 pruebas de d2datdinc/probar
	y los cinco tests de SLEX verificados en el arbol actual.

2026-10-06  Diego Saravia  <dsa@unsa.edu.ar>

	* dato/json.c, json.h (j_arena_nueva, j_arena_usar,
	j_arena_liberar): los valores, por arena (r2375).
	* d2datdinc/dato.c, dato.h (dato_falla, dato_fallo), userfunc.c,
	main.c (leer): una lectura que falla no termina el proceso (r2375,
	r2376). din/din.c: los valores de paso son del arena (r2377, r2378).
	* d2datdinc/varios.c: con arenas, el .din, y que ninguno termine el
	proceso; pruebas/falta-include.ds, pruebas/control-de-rama.d (r2375).
	* d2datdinc/README.md, seccion 11 (r2379).

	* d2datdinc/piezas.y, piezas.h: las piezas de un valor de ELEMENTS;
	se quitan pieza_sig, pieza_coma y valor_con_vars de dato.c (r2360,
	r2361). d2datdinc/parametros.y (param_partes): la marca D:, para
	param_leer y reescribe_parametro (r2362, r2363).

	Lo que quedaba a mano en dato.c y din.c, a Bison (r2346-r2357).

	* din/din.c (sustituir_palabra, menciona, simbolo_no_constante,
	fila_menciona, es_comparacion): sobre las piezas de valor.y (r2346,
	r2349). din/pglm.inc (imex_aritmetica): la expresion explicita de
	IMEX; se quitan imex_atomo, imex_producto, imex_suma (r2347).

	* d2datdinc/control.y (control_lista): la lista de un valor de .ds
	(r2351). d2datdinc/declaraciones.y (decl_externa): EXTERNAL (r2352).
	d2datdinc/edef.y, edef.h: ELEMENT DEFINITION (r2353-r2355).
	d2datdinc/comas.y, comas.h: las comas de afuera, para d_partir
	(r2356, r2357).

	* reentrante/PLAN_MIGRACION_SLEX_BISON.md: las tablas las lee
	tabular2 (r2350).

	Los valores de din con Bison (r2326-r2330).

	* din/valor.y, din/valor.h: la gramatica de un valor al traducirlo a
	ExprTk; devuelve las piezas y marca las llamadas con sus parentesis
	y sus comas. Acepta la multiplicacion sin * (r2329).

	* din/din.c (valor_expresion, reemplazar, referencia_tabla,
	signo_fortran, piezas): recorren las piezas; se quitan argumentos y
	caracter_admitido. reemplazar deja pasar and, or, not y xor (r2328).

	* din/glm.inc, din/pglm.inc: reemplazar lleva el din (r2327).

	* din/Makefile.am: la regla de Bison de valor.y.

	* d2datdinc/probar, d2datdinc/pruebas/valores-raros.d: dos pruebas.

	* din/din.c (cuerpo_funcion, cuerpo_con_args, en_linea_una,
	escribe_funciones, es_lineal, es_logico, din_leer_con): los cuerpos
	de FUNCTIONS y la marca @lineal sobre las piezas; texto() lleva el
	din (r2337, r2339). din/glm.inc, din/pglm.inc: idem (r2337, r2338).

2026-10-05  Diego Saravia  <dsa@unsa.edu.ar>

	* d2datdinc/expresion.y, d2datdinc/dato.c (condicion, diodo): las
	condiciones de RUN CONTROLS y el valor DIODE los lee la gramatica de
	expresiones; el lexer anota los operadores de FORTRAN y los numeros
	con un punto de mas (r2323, r2324). Da lo mismo en todo el arbol.

	* d2datdinc/README.md, reentrante/PLAN_MIGRACION_SLEX_BISON.md: lo que
	queda a mano en dato.c y lo que falta en din/din.c.

	Las expresiones de los valores con Bison (r2321).

	* d2datdinc/expresion.y, d2datdinc/expresion.h: la gramatica de una
	expresion; devuelve lo que encontro y donde.

	* d2datdinc/dato.c (reescribe, reescribe_valor, reescribe_parametro):
	las reescrituras de SCEPTRE sobre los valores. Se quitan ecuacion_a_q,
	tablas_d y fuentes_j_a_corriente, y las reescrituras de la sentencia
	entera en dato_sentencia.

	* d2datdinc/Makefile.am, d2datdinc/pruebas/expresiones-valores.d,
	d2datdinc/probar, d2datdinc/README.md,
	reentrante/PLAN_MIGRACION_SLEX_BISON.md, NEWS, debian/changelog
	(1.0-21).

	Las construcciones chicas de SCEPTRE con Bison (r2319).

	* d2datdinc/sceptre.y, d2datdinc/sceptre.h: cotas, conjuntos DC, MODEL,
	instancias y ELEMENT DESCRIPTION.

	* d2datdinc/dato.c (saca_cotas, conjunto_dc, dato_modelo_d,
	anotar_instancia, sentencia_ds): usan la gramatica.

	* d2datdinc/Makefile.am, d2datdinc/pruebas/sceptre-raros.d,
	d2datdinc/probar, d2datdinc/README.md,
	reentrante/PLAN_MIGRACION_SLEX_BISON.md, NEWS, debian/changelog
	(1.0-20).

	La cabeza de ELEMENTS de un .d con Bison (r2317).

	* d2datdinc/rama.y, d2datdinc/rama.h: NOMBRE, n1-n2[-n3...] =.

	* d2datdinc/dato.c (d_sentencia, case S_ELEMENTS): usa rama_leer.

	* d2datdinc/Makefile.am, d2datdinc/pruebas/ramas-raras.d,
	d2datdinc/probar, d2datdinc/README.md,
	reentrante/PLAN_MIGRACION_SLEX_BISON.md, NEWS, debian/changelog
	(1.0-19).

	La forma de RUN CONTROLS con Bison (r2315).

	* d2datdinc/control.y, d2datdinc/control.h: PALABRAS [= VALOR].

	* d2datdinc/dato.c (control_d): era la case S_RUN_CONTROLS de
	d_sentencia; recibe la clave y el valor de la gramatica. La parte
	general de un .ds (CLAVE=[...]) tambien, con lo raro avisado.

	* d2datdinc/Makefile.am, d2datdinc/pruebas/controles.ds,
	d2datdinc/probar, d2datdinc/README.md,
	reentrante/PLAN_MIGRACION_SLEX_BISON.md, NEWS, debian/changelog
	(1.0-18).

	OUTPUTS de un .d con Bison (r2313).

	* d2datdinc/salidas.y, d2datdinc/salidas.h: la gramatica, con
	posiciones para nombrar lo que se saca tal como esta escrito.

	* d2datdinc/dato.c (d_sentencia, case S_OUTPUTS): usa salidas_leer.

	* d2datdinc/Makefile.am, d2datdinc/pruebas/salidas-raras.d,
	d2datdinc/probar, d2datdinc/README.md,
	reentrante/PLAN_MIGRACION_SLEX_BISON.md, NEWS, debian/changelog
	(1.0-17).

	DEFINED PARAMETERS y VARIABLES con Bison (r2311).

	* d2datdinc/parametros.y, d2datdinc/parametros.h: NOMBRE = VALOR
	[D:DERIVADA]; parser puro con su lexer de slex.

	* d2datdinc/dato.c (sentencia_ds): los case S_DEFINED_PARAMETERS y
	S_VARIABLES guardan lo que da la gramatica; un repetido se avisa y se
	ignora.

	* d2datdinc/Makefile.am, d2datdinc/pruebas/parametros.ds,
	d2datdinc/probar, d2datdinc/README.md,
	reentrante/PLAN_MIGRACION_SLEX_BISON.md, NEWS, debian/changelog
	(1.0-16).

	CONSTANTS y FUNCTIONS con Bison (r2309): la tercera seccion de
	d2datdinc que pasa a slex + Bison.

	* d2datdinc/declaraciones.y, d2datdinc/declaraciones.h: la gramatica de
	NOMBRE = NUMERO y de NOMBRE(N) = expresion o NOMBRE(a, b) = expresion;
	parser puro con su lexer de slex. En un .d el nombre puede ir en pedazos.

	* d2datdinc/dato.c (constante, funcion): guardan lo que da la gramatica;
	una repetida se avisa y se ignora.

	* d2datdinc/Makefile.am: la regla de bison de declaraciones.y.

	* d2datdinc/pruebas/declaraciones.ds, d2datdinc/probar: tres pruebas.

	* d2datdinc/README.md, reentrante/PLAN_MIGRACION_SLEX_BISON.md, NEWS,
	debian/changelog (1.0-15): el cambio, anotado.

	EQUATIONS y CONTROL EQUATIONS con Bison (@REV@): la segunda seccion de
	d2datdinc que pasa a slex + Bison.

	* d2datdinc/ecuacion.y, d2datdinc/ecuacion.h: la gramatica de una
	sentencia: la ecuacion y sus marcas (V: TIPO: RES: INDEP: LINEAL:
	NONUCLEO:) con sus valores; parser puro con su lexer de slex.

	* d2datdinc/dato.c (ecuacion): llama a ecuacion_leer y pone eq, o vec en
	una LINEAL; se van MARCAS y marca_en. Una sentencia que no vale se avisa y
	se ignora.

	* d2datdinc/Makefile.am: las reglas de bison de las dos gramaticas.

	* d2datdinc/pruebas/ecuaciones.ds, d2datdinc/probar: tres pruebas; son
	78.

	* d2datdinc/README.md, reentrante/PLAN_MIGRACION_SLEX_BISON.md, NEWS,
	debian/changelog (1.0-14): el cambio, anotado.

	La seccion DATA de d2datdinc la lee una gramatica de Bison (@REV@): el
	primer paso de pasar d2datdinc a slex + Bison, de a una seccion.

	* d2datdinc/data.y, d2datdinc/data.h: la gramatica de una sentencia de
	DATA (camino = valor), un parser puro con el estado por %param y los
	tokens de un contexto de slex propio; sus reglas y sus acciones van en
	el mismo archivo. Reemplaza a dato_data (dato.c) y a dato/expr.c. Lo
	raro se avisa y la sentencia no toca el dato; sqrt(4)**2 ahora vale.

	* d2datdinc/dato.c: se va dato_data; el case S_DATA llama a
	data_sentencia, ecuacion() lee el vector LINEAL con data_valor, y el
	dato_ctx lleva el analizador (se crea al usarlo, dato_liberar lo
	libera).

	* dato/expr.c, dato/expr.h, dato/Makefile.am: quitados; no quedaba quien
	los usara.

	* d2datdinc/Makefile.am, configure.ac: bison, llamado directo (no por
	AC_PROG_YACC); data.tab.c y data.tab.h se generan al compilar.
	debian/control y hacer-deb piden bison.

	* d2datdinc/pruebas/data.ds, d2datdinc/probar: tres pruebas de DATA (lo
	que vale y las diez sentencias raras); son 75.

	* d2datdinc/README.md (4), reentrante/README.md,
	reentrante/PLAN_MIGRACION_SLEX_BISON.md, PARSERS.md, NEWS,
	debian/changelog (1.0-13): el cambio, anotado.

	* README (2, REENTRANTE): manda a doc/API-CONTEXTO.md. El punto
	describia los hilos de slex y no decia que el estado de cada lexer esta
	en un contexto ni que dos contextos se usan a la vez desde hilos del
	sistema.

	Lo que d2datdinc lleva de una lectura esta en un contexto (r2288): se
	pueden leer varios circuitos en un proceso. Antes el segundo salia
	mezclado con el primero.

	* d2datdinc/dato.c, d2datdinc/dato.h: las 55 variables del archivo
	pasan a un struct dato_ctx. dato_nuevo() lo crea (era dato_ini()), cada
	funcion lo recibe y dato_liberar() libera sus textos y sus vectores; los
	valores JSON siguen sin liberarse. modo_d es un campo: dato_modo_d(),
	dato_en_modo_d(). Son 307 usos en 39 funciones, ubicados con el
	compilador.

	* d2datdinc/userfunc.c, d2datdinc/dato.h: g_base, g_seccion, g_estado,
	g_d_activo, g_fin_buffer y bloque pasan a un struct lector, que llega a
	cada accion como su dato de usuario. lector_ini().

	* d2datdinc/main.c (leer): la lectura sale de main a una funcion que
	crea el lexer, el lector y el dato_ctx, y los libera, tambien cuando
	falla. El ciclo es el mismo.

	* dato/expr.c, dato/expr.h: el cursor expr_p era una variable de la
	biblioteca; ahora lo recibe cada funcion (expr_blancos(&p)...).

	* d2datdinc/varios.c, d2datdinc/Makefile.am: prueba nueva del make
	check. Lee los 48 circuitos de pruebas/ en un proceso, uno despues de
	otro y a la vez desde cuatro hilos, y compara cada dato con el que da
	leerlo solo.

	* d2datdinc/README.md (11), PARSERS.md, reentrante/README.md,
	reentrante/PLAN_MIGRACION_SLEX_BISON.md,
	reentrante/CONSUMIDORES_SLEX.md, Makefile.am, NEWS,
	debian/changelog (1.0-12): el cambio, anotado, y lo que falta para usar
	d2datdinc como biblioteca.

	Los ejemplos piden los tokens con slex_next (r2282).

	* examples/01/main.c, examples/02/main.c, examples/03/main.c,
	examples/06/main.c, examples/07/main.c, examples/08/main.c: el ciclo de
	lectura era el de la API historica, pasado de forma mecanica
	(slex_ctx_get_token, una vuelta del lexer por llamada, con tope de
	vueltas). Ahora es slex_next, que da un token, el fin o un error. Dan
	los mismos tokens, y 07 y 08 la misma tabla. Ya no salen la vuelta
	final sin token ni "CANTIDAD DE CICLOS". 01 y 02 se detienen, con el
	mensaje, en el texto que el estado 45 no reconoce (daban 98 vueltas sin
	token hasta el tope de 100), y 03 lee hasta el final: 84 tokens (el
	tope de 50 vueltas lo cortaba en 49).

	* examples/04/main.c (yylex): pide con slex_next, y los blancos los
	saltea slex_ctx_set_skip. Misma salida. main5, que no se llama, queda
	como estaba.

	* examples/04/rpcalc: rearmado (r2283).

	* doc/API-CONTEXTO.md (9): nombraba los parches de
	reentrante/consumidores, que ya no estan; dice como quedaron pasados
	los programas del arbol.

	Los Makefile de cuatro ejemplos (r2281).

	* examples/03/Makefile, examples/06/Makefile, examples/07/Makefile,
	examples/08/Makefile: buscaban las bibliotecas en /usr/local/lib y no
	armaban. Usan PREFIX, como los de 04, 09 y 11.

	reentrante/ queda como registro (r2279, r2280).

	* reentrante/: se quitan la copia de la biblioteca (src/), las pruebas
	(tests/), los parches de los programas (consumidores/), reemplazar,
	verificar/, el Makefile, NEWS-borrador.txt, API.md y un antecedente
	repetido. El reemplazo esta aplicado desde r2252 y lo que vale es src/
	y tests/; lo quitado se trae con svn export -r 2278 (r2279).

	* reentrante/README.md, reentrante/PLAN_MIGRACION_SLEX_BISON.md,
	reentrante/DIFERENCIAS.md, reentrante/CONSUMIDORES_SLEX.md,
	reentrante/antecedentes/LEEME.md: dicen lo que quedo y que el paquete
	esta armado (r2280).

	* Makefile.am: el comentario nombraba dos pruebas; son cinco en tests/
	y tres en d2datdinc/ (r2280).

	* debian/changelog (1.0-11): el paquete 1.0-10 instalado es de antes de
	la mudanza y sus mensajes nombran Simul/LLAVES.md; con otro numero se
	distingue el que se arma ahora.

	El corpus pasa a siru/corpus y Simul a siruviejo (r2275). En slex
	cambian las rutas que los nombran. Ver siru/ChangeLog.

	* d2datdinc/pruebas/compara-dat, d2datdinc/pruebas/compara-din: los
	envoltorios llaman a siru/corpus/compara-dat y compara-din (r2275).

	* examples/11/probar: los netlists estan en siru/corpus/spice (r2275).

	* d2datdinc/dato.c, din/din.c: los mensajes que mandan a leer
	LLAVES.md dicen siruviejo/LLAVES.md (r2275).

	* d2datdinc/main.c, d2datdinc/probar, d2datdinc/Makefile.am, degen/,
	din/din.h, README, PARSERS.md, PLAN.md, d2datdinc/README.md,
	d2datdinc/biblioteca/LEEME.md, din/README.md, mdin/LEEME.md,
	examples/11/README.md, reentrante/: comentarios y documentos con las
	rutas nuevas (r2275).

	Simul2 pasa a llamarse siru (r2264): en slex cambian las claves que
	escribe y lee d2datdinc, y las rutas. Ver siru/ChangeLog.

	* d2datdinc/dato.c, d2datdinc/main.c: las claves SIMUL2_* de
	GLOBAL.control pasan a SIRU_* (SIRU_PASO, SIRU_PASO_MIN, SIRU_PASO_MAX,
	SIRU_ADAPT, SIRU_ABSOLUTO, SIRU_RELATIVO, SIRU_ORDEN_ERROR,
	SIRU_COMPRESION_CUENTA, SIRU_COMPRESION_CRITERIO) y los controles
	SIMUL2 ADAPTIVE STEP, SIMUL2 ABSOLUTE TOLERANCE, SIMUL2 RELATIVE
	TOLERANCE y SIMUL2 ERROR ORDER de un .d, a SIRU ... Los nombres de
	antes se siguen aceptando al leer un .d, un .ds o un .dat; con -v se
	avisa. Si un .dat trae los dos, vale el de ahora (r2264).

	* din/din.c, din/glm.inc, din/pglm.inc, din/ros.inc: leen las claves
	SIRU_*, y los mensajes dicen siru (r2264).

	* d2datdinc/probar, d2datdinc/pruebas/nombres-de-antes.d,
	d2datdinc/pruebas/nombres-de-antes.ds: cuatro pruebas de los nombres
	de antes; son 72 (r2264).

	* examples/11/cir2ds.c: el .ds que escribe lleva SIRU_PASO (r2264).

	* d2datdinc/pruebas/sceptre/wc-tiempo.informe: era wc-tiempo.simul2,
	el informe de siru (r2264).

	* README, PARSERS.md, d2datdinc/README.md, d2datdinc/Makefile.am,
	d2datdinc/dato.h, d2datdinc/biblioteca/libraryori.siru, dato/json.h,
	din/README.md, din/Makefile.am, din/din.h, mdin/LEEME.md,
	examples/11/README.md, debian/control, reentrante/: donde decia Simul2
	dice siru, y las rutas son siru/... (r2264).

	* NEWS, debian/changelog (1.0-10): el cambio, anotado.

	slex por contexto. Se preparo y se comprobo en reentrante/ (r2205 a
	r2251) y se aplico en r2252 con reentrante/reemplazar --aplicar. Ver
	reentrante/README.md.

	* src/slex.c, src/slex.h, src/slexfunc.c, src/slexint.h,
	src/slexlegacy.c, src/Makefile.am: la biblioteca por contexto reemplaza
	a la anterior. slexlegacy.c es la API de siempre sobre el mismo nucleo;
	slexint.h, el contexto, no se instala. -version-info 1:0:1: se agregan
	funciones y libslex.so.0 conserva su nombre (r2252).

	* tests/test_ctx.c, tests/test_hilos.c, tests/test_azar.c,
	tests/Makefile.am, tests/bison/: las pruebas de la API por contexto
	entran al make check; el piloto de Bison queda con su Makefile (r2252).

	* d2datdinc/main.c, d2datdinc/userfunc.c: el lexer es un contexto
	propio y las acciones reciben el contexto; sin tablas globales ni
	vectorize_usr_func. Misma salida: probar, los 1205 .d/.ds del arbol y
	las 1087 pruebas de siru, antes y despues en el arbol (r2252).

	* examples/01 a 04, 06 a 09 y 11 (main.c, userfunc.c, cir2ds.c): lo
	mismo (r2252). examples/04/rpcalc, examples/09/example09: los dos
	binarios versionados, recompilados (r2253).

	* doc/API-CONTEXTO.md, doc/API.md, tests/README.md, NEWS,
	debian/changelog, PLAN.md, ANALISIS.md: la API nueva y el cambio,
	anotados (r2252, r2254).

	* tests (svn:ignore): test_ctx, test_hilos y test_azar, los programas
	que arma make check, ignorados como test_api y badini (r2257).

	* reentrante/README.md, reentrante/PLAN_MIGRACION_SLEX_BISON.md,
	reentrante/CONSUMIDORES_SLEX.md, reentrante/NEWS-borrador.txt,
	reentrante/Makefile, reentrante/reemplazar,
	reentrante/verificar/comparar: el directorio queda como registro del
	reemplazo ya aplicado: como quedo el arbol despues de aplicar y que
	queda abierto. reemplazar y comparar avisan que ya esta aplicado y
	salen (r2255, r2256).

	* reentrante/src/slex.c, reentrante/src/slex.h,
	reentrante/src/slexfunc.c, reentrante/src/slexfunc.h: copia de partida
	de src/, con historia (r2205).

	* reentrante/src/slex.c, reentrante/src/slex.h,
	reentrante/src/slexint.h, reentrante/src/slexlegacy.c: paso A, mecanico:
	cada funcion del nucleo recibe struct slex_ctx * y lee de el lo que leia
	de una global; la API historica, en slexlegacy.c, sobre el contexto
	heredado. Misma traza con verbose 20 en 199 corridas (r2206).

	* reentrante/src/slex.c, reentrante/src/slex.h,
	reentrante/src/slexint.h, reentrante/src/slexfunc.c,
	reentrante/src/slexlegacy.c: la API por contexto: slex_ctx_new, free y
	reset, registro de acciones por nombre, acciones con contexto y
	userdata, errores devueltos en lugar de exit (salvo en el contexto
	heredado), memoria con dueño, slex_next con fin, error y posicion,
	slex_ctx_ini_file y slex_ctx_ini_string, consulta de las tablas
	(r2209-r2212, r2217-r2220, r2223, r2224, r2236, r2237).

	* reentrante/src/slex.c, reentrante/src/slex.h: cinco errores de la
	biblioteca: la marca <nombre> de un def reconocia tokens; la funcion
	del lugar 0 se informaba como no encontrada; dos restos de depuracion
	leian el response como el struct del ejemplo 08; un flujo que lee de
	otro agregaba (null); use llegaba siempre en 0 (r2213, r2214). Y una
	definicion que se nombra a si misma, que dejaba a la biblioteca
	reemplazando <d> por <d> para siempre: ahora es un error de la
	configuracion (r2242).

	* reentrante/tests/test_ctx.c, reentrante/tests/test_hilos.c,
	reentrante/tests/test_azar.c: 99 pruebas de la API por contexto, ocho
	hilos del sistema con un contexto cada uno, y texto, reglas y llamadas
	a la API al azar (r2215, r2216, r2225, r2232, r2241, r2244-r2246,
	r2250).

	* reentrante/tests/bison/expr.y, reentrante/tests/bison/lista.y,
	reentrante/tests/bison/parser.h, reentrante/tests/bison/test_bison.c,
	reentrante/tests/bison/Makefile: el piloto slex + Bison: dos gramaticas
	en un programa, parsers puros, yylex sobre slex_next (r2223, r2224,
	r2227).

	* reentrante/consumidores/d2datdinc.patch,
	reentrante/consumidores/examples.patch: d2datdinc, cir2ds y los
	ejemplos con un contexto propio (r2221).

	* reentrante/verificar/comparar, reentrante/Makefile,
	reentrante/reemplazar: la comparacion contra src/ programa por
	programa (pruebas, ejemplos, d2datdinc sobre los 1205 circuitos del
	arbol, las pruebas de siru, la traza, ASan), las pruebas de la
	biblioteca y el reemplazo, ensayado en una copia con Autotools (r2222,
	r2225, r2226, r2228, r2229, r2243, r2247).

	* reentrante/README.md, reentrante/API.md, reentrante/DIFERENCIAS.md,
	reentrante/CONSUMIDORES_SLEX.md,
	reentrante/PLAN_MIGRACION_SLEX_BISON.md,
	reentrante/NEWS-borrador.txt, reentrante/antecedentes/LEEME.md: la
	documentacion. Los dos README_slex_bison y los tres parches prototipo
	pasaron a reentrante/antecedentes (r2221, r2230, r2231, r2233-r2235,
	r2238).

2026-10-04  Diego Saravia  <dsa@unsa.edu.ar>

	Las entradas del 2026-09-28 al 2026-10-04 se escribieron juntas el
	2026-10-04, a partir de svn log: por revision, los archivos de slex que
	cambio y la primera linea de su mensaje. Son de las dos sesiones de
	trabajo de esos dias; el detalle de cada una esta en su mensaje de
	commit.

	* din/README.md: slex/din/README.md: lo que se agrego entre el 29/09 y
	el 04/10 (r2186).

	* reentrante/PLAN_MIGRACION_SLEX_BISON.md: (sin mensaje) (r2185).

	* d2datdinc/pruebas/sceptre/mutua-lineal-Sceptre,
	d2datdinc/pruebas/sceptre/mutua-lineal.log,
	d2datdinc/pruebas/sceptre/mutua-lineal.sceptre: Salidas de las
	comparaciones contra SCEPTRE hasta ahora (la pasada limpia del corpus
	sigue corriendo): SCEPTRE.md, -Sceptre, .sceptre y .log; entre ellas
	colori, planeta, con_FOR, subprograma, pru_termistor, tanque_int y
	mutua-lineal (r2184).

	* din/README.md: Documentado: la regla de arranque, Newton contra un
	quiebre y el tiempo dentro de una funcion (HECHO, slex/din/README,
	MANUAL 7) (r2182).

	* din/din.c: libdin: el tiempo dentro del cuerpo de una funcion ya no
	se escribe con su valor inicial. La funcion que nombra T o TIME va en
	linea (cada llamada por su cuerpo), con el tiempo del sistema; antes
	'EQUATION 1 (A,B,C,D) = ((A+B*DCOS(2.*PW*TIME+C))*D)' de g02 quedaba en
	cos(2*PW*0+C) para siempre. Antes de compilar y probar (r2181).

	* d2datdinc/pruebas/sceptre/mutua-lineal.d: pruebas/sceptre/mutua-
	lineal.d: dos bobinas acopladas, para comparar la inductancia mutua de
	siru con la de SCEPTRE (r2178).

	* din/din.c: Arranque: un estado que impone una fuente (bobina en serie
	con una fuente de corriente, capacitor en paralelo con una bateria) y
	cuya condicion inicial el archivo no da arranca con lo que impone la
	fuente, sin trasvase desde cero, como SCEPTRE (decision del autor;
	g02). libdin lo marca 'fuente' en la seccion equilibrio; Circuito lo
	aplica. Antes de compilar y probar (r2176).

	* din/README.md: g02: documentado el equilibrio del flujo con
	inductancias que no son datos y las mutuas en un .ds (corpus/README,
	slex/din/README, HECHO); g02 sigue sin correr (el primer paso tras el
	salto no converge) (r2174).

	* d2datdinc/README.md: Documentar ROS v5 con sensibilidades SENS1:
	seleccion, controles, limites, corpus y verificacion (r2173).

	* d2datdinc/dato.c, din/din.c: La inductancia mutua 'M, L1-L2 = valor'
	tambien en un .ds (d2datdinc; antes se ignoraba); libdin: el signo de
	lo que impone una E en inductancia_previa; g02.ds con su paso. Antes de
	compilar y probar (r2172).

	* din/din.c: libdin: en el equilibrio del flujo una inductancia (propia
	o mutua) que no es un dato se toma en el estado de antes del salto: lo
	que impone una fuente con su expresion y las corrientes de las bobinas
	con su valor previo (g02.d, el generador que satura; pedido del autor).
	Antes de compilar y probar (r2171).

	* din/ros.inc: ETABLE en siru: MANUAL 9, HECHO, corpus/README; salidas
	de con_FOR, subprograma, pru_termistor, tanque_int y SCEPTRE.md
	(r2150).

	* din/din.c: ETABLE por el camino 2: si el archivo la declara EXTERNAL,
	libdin no la traduce y se llama a la de Fortran; corpus/sceptre corre
	siru con CALCULA_EXTERNAS=1 (los EXTERNAL del corpus). Antes de
	compilar y probar (r2148).

	* din/din.c: libdin: ETABLE(N, X, Y, V, M) de SCEPTRE se traduce a
	tabla('archivo','X','Y',V,M) de Calcula, con el archivo de la tabla N
	tomado de etable.txt y las columnas por numero (calcula 6.0-34). Pedido
	del autor (con_FOR). Antes de compilar y probar (r2143).

	* din/din.c: Una isla sin camino a la masa deja de ser un error (pedido
	del autor; pru_termistor.d): libdin toma un nodo de la isla como
	referencia, como ya hacia con las islas de las llaves abiertas, lo dice
	en la topologia (islas) y siru lo avisa. Y la referencia de una isla no
	se deshace en el sistema del punto DC. Antes de compilar y probar
	(r2141).

	* d2datdinc/README.md, din/ros.inc: Simul2 ROS: tolerancias por estado
	en din v4 y estadisticas de corrida; corpus, pruebas y plan de
	sensibilidades (r2138).

	* d2datdinc/README.md, d2datdinc/main.c, din/ros.inc: ROS2 adaptativo:
	contrato din v3, corpus, regresiones y documentacion de controles
	SIMUL2 (r2135).

	* din/din.c: libdin: el nombre de una fuente se traduce a lo que impone
	solo dentro de una expresion, no cuando es la expresion entera (un
	OUTPUT como E3 se resuelve por otro lado; rompia a06a.d de
	convolucion.t) (r2122).

	* din/din.c: libdin: el nombre de una fuente solo en una expresion es
	lo que impone (la tension de una E, la corriente de una J), como en
	SCEPTRE: pru_form.d (Q2P(5.E+06, E4)), g02.d (TABLE 1 (ES1)), colori.d.
	Antes de compilar y probar (r2120).

	* din/din.c: libdin: en el sistema de integracion la marca @lineal se
	calcula con los estados como incognitas (lo son en las etapas), no como
	datos; planeta1.d salia marcado todo lineal. Antes de compilar y probar
	(r2119).

	* d2datdinc/pruebas/sceptre/a01-tabla2-q.log,
	d2datdinc/pruebas/sceptre/c-variable-q.log: La ley de la capacidad
	confirmada en el rerun 1 de a01_2 (a01-tabla2-q.d: con la capacidad de
	carga equivalente siru da lo de SCEPTRE); bitacora de PLAN_DC_RERUN con
	lo que pidio d04 y el corpus entero; corpus/README; los mdin del corpus
	que el barrido regenero y los -D.mdin nuevos (r2109).

	* d2datdinc/pruebas/sceptre/a01-tabla2-q.d:
	pruebas/sceptre/a01-tabla2-q.d: a01-tabla2 con las capacidades de carga
	equivalentes a las incrementales de SCEPTRE, para confirmar que la
	diferencia del rerun 1 de a01_2 es la ley de la capacidad (r2108).

	* d2datdinc/README.md, d2datdinc/dato.c, d2datdinc/main.c, din/ros.inc:
	ROS v2: controles de escalas y Jacobiano desde d/ds, corpus y
	compatibilidad din v1 (r2107).

	* d2datdinc/dato.c: d2datdinc: MODEL X (TEMP,CHANGE P1=.975) aplica el
	CHANGE (r2084).

	* d2datdinc/pruebas/sceptre/a01-tabla2-Sceptre,
	d2datdinc/pruebas/sceptre/a01-tabla2.log,
	d2datdinc/pruebas/sceptre/a01-tabla2.sceptre: Contra SCEPTRE con
	calcula 6.0-31: a13 y g04 iguales; a01_2 corre las tres (el rerun 1
	difiere: VCE 0.06, IR3 0.15, sin verificar si es por la ley de la
	capacidad); d04 igual que antes (r2083).

	* d2datdinc/pruebas/sceptre/a01-tabla2.log,
	d2datdinc/pruebas/sceptre/start-time-Sceptre,
	d2datdinc/pruebas/sceptre/start-time.log,
	d2datdinc/pruebas/sceptre/start-time.sceptre: HECHO 3 undecies: calcula
	6.0-31 (busqueda lineal), respaldo del paso fijo, START TIME; salidas
	de start-time y a01-tabla2 (r2082).

	* d2datdinc/pruebas/sceptre/a01-tabla2.d: pruebas/sceptre/a01-tabla2.d:
	a01 con la tabla del rerun 1 de a01_2 (no converge a paso fijo en t =
	58.3) (r2081).

	* d2datdinc/pruebas/sceptre/start-time.d: pruebas/sceptre/start-time.d:
	START TIME = 5 (r2080).

	* din/din.c: libdin: la corrida arranca en el valor inicial del tiempo
	(START TIME de un .d), no siempre en 0. Antes de compilar y probar
	(r2079).

	* d2datdinc/README.md, din/ros.inc: ROS2: documentar contrato y
	limites, probar OUTPUTS y rechazar analisis pendientes; suite 666
	pruebas (r2077).

	* d2datdinc/dato.c, d2datdinc/main.c, din/Makefile.am y 2 mas: ROS2:
	selector ROS 1, din autosuficiente y campo reducido sobre Calcula; 97
	pruebas (r2076).

	* din/din.c: slex/din: 'X=0 D:IE1' en DEFINED PARAMETERS integra una
	variable de rama (r2073).

	* d2datdinc/probar: slex/d2datdinc/probar: un .d incluido desde un .d
	(r2067).

	* d2datdinc/userfunc.c: d2datdinc: un .d incluido desde un .d se lee
	como .d (r2066).

	* din/din.c: slex/din: la seccion '# compresion' en el .din del
	instante, con convolucion (r2060).

	* d2datdinc/dato.c: d2datdinc: COMPRESSION COUNT y COMPRESSION
	CRITERION (la compresion de la convolucion) (r2059).

	* d2datdinc/README.md: ARS222: circuito y tablas de usuario probados;
	documentar contrato IMEX v2 y verificacion completa (r2052).

	* d2datdinc/Makefile.am, d2datdinc/biblioteca/pglm.json, din/pglm.inc:
	IMEX: generador aditivo por tablas, ARS222 y compatibilidad Euler v1;
	144 pruebas (r2049).

	* d2datdinc/dato.c: El punto de operacion DC por integracion (RUN IC
	VIA IMPLICIT de SCEPTRE; pedido del autor para d04): si Newton no llega
	desde las semillas, o si el archivo lo pide (control SCEPTRE_IC_VIA),
	siru integra con el tiempo quieto desde las condiciones iniciales, por
	tramos, y desde cada estado prueba Newton sobre el sistema DC. Antes de
	compilar y probar (r2037).

	* d2datdinc/pruebas/sceptre/c-variable-q.log: MANUAL 7: la capacidad de
	carga equivalente a la incremental de SCEPTRE, comprobada
	(c-variable-q.d: 6.166829 contra 6.166827) (r2028).

	* d2datdinc/pruebas/sceptre/c-variable-q.d:
	pruebas/sceptre/c-variable-q.d: c-variable.d con C = 1 + 0.2 V^2/3, la
	capacidad de carga equivalente a la incremental de SCEPTRE (r2026).

	* d2datdinc/pruebas/sceptre/c-ajena-Sceptre,
	d2datdinc/pruebas/sceptre/c-ajena.log,
	d2datdinc/pruebas/sceptre/c-ajena.sceptre y 11 mas: Documentado:
	capacidades en lazos (del voltaje propio, de otro capacitor, de una
	fuente en paralelo), el punto DC con lazos (NOMBRE-D.mdin) y la
	diferencia con SCEPTRE (I = C dV/dt contra Q = C V; el estado sigue
	siendo la carga): MANUAL 7 y tabla de mensajes, slex/din/README,
	corpus/README, HECHO 3 nonies; salidas de c-variable, c-ajena, lazo-c-
	ajeno y los mdin de d04 (r2025).

	* d2datdinc/main.c, din/din.c, din/din.h: Punto de operacion DC con
	lazos de capacitores o cortes de bobinas: libdin guarda las ecuaciones
	que cambia por las leyes derivadas y da din_puntodc, el instante con
	las originales; d2datdinc lo escribe en NOMBRE-<bits>D.mdin; Preparador
	y Circuito lo usan para punto_dc (d04.d: con las derivadas en cero la
	ley derivada es 0 = 0 y vcrb quedaba suelto). Antes de compilar y
	probar (r2024).

	* din/din.c: libdin: capacidad_normal cambia en la misma rama J su
	corriente y su voltaje (el diodo JE: ije por lo que impone y vje por
	vce) (r2023).

	* d2datdinc/pruebas/sceptre/lazo-c-ajeno-r.d: pruebas/sceptre/lazo-c-
	ajeno-r.d: el mismo circuito con el lazo roto por una resistencia de
	1e-4, para comparar la ley del lazo de libdin con las ecuaciones
	comunes (r2022).

	* din/din.c: libdin: la capacidad de un capacitor en un lazo o en el
	equilibrio se normaliza a voltajes de capacitores: la corriente de una
	fuente J se cambia por lo que impone (CE = f(JE), el diodo de la
	juntura) y el voltaje de una rama en paralelo con un capacitor por el
	de ese capacitor (d04.d: 'equilibrio: CET1 depende de ijet1'). Antes de
	compilar y probar (r2021).

	* d2datdinc/pruebas/sceptre/c-ajena.d,
	d2datdinc/pruebas/sceptre/c-variable.d: pruebas/sceptre: c-variable.d y
	c-ajena.d, una capacidad que depende de su voltaje y del de otro
	capacitor, sin lazos, para ver que ley usa SCEPTRE (Q = C V o I = C
	dV/dt) (r2020).

	* d2datdinc/pruebas/sceptre/lazo-c-ajeno.d: pruebas/sceptre/lazo-c-
	ajeno.d: lazo de tres capacitores con C2 = 1 + 0.2*VC1**2, la capacidad
	que depende del voltaje de otro capacitor (lo de d04.d) (r2019).

	* din/din.c: libdin: sin voltajes ajenos la ley del lazo se escribe
	igual que antes ((dqc2dt)/(c2), sin parentesis de mas) (r2018).

	* din/din.c: libdin: en un lazo de capacitores la capacidad puede
	depender del voltaje de otro capacitor (CC2 = f(VCC1), modelo JCNTRAN
	de d04.d; pedido del autor). Ley del lazo: dV/dt = (dQ/dt - V (dC/dVj)
	dVj/dt)/(dQ/dV), con dVj/dt la del otro capacitor; equilibrio: el
	voltaje ajeno se escribe con los potenciales de sus nodos. Antes de
	compilar y probar (r2017).

	* d2datdinc/pruebas/sceptre/rerun.log, d2datdinc/pruebas/sceptre/wc-
	tiempo.log, d2datdinc/pruebas/sceptre/wc-tiempo.simul,
	d2datdinc/pruebas/sceptre/wc-tiempo.simul2: CONTINUE (PLAN_DC_RERUN
	paso 7): bitacora, MANUAL 11 septies, HECHO 3 octies; wc-tiempo.simul
	con su continuacion hasta 40 y el .simul2 con el estado final (r2009).

	* reentrante/README_slex_bison.md: (sin mensaje) (r1999).

	* d2datdinc/README.md, d2datdinc/dato.c, d2datdinc/main.c y 4 mas:
	Agregar particion IMEX_EXPLICITA, generacion C y din autosuficiente,
	conservando los motores RK y GLM. Incluir plan de ampliacion,
	documentacion, cuatro casos de corpus y 95 pruebas IMEX. Verificacion:
	452 pruebas Simul2 y 67 del generador C (r1998).

	* d2datdinc/Makefile.am, d2datdinc/README.md,
	d2datdinc/biblioteca/glm.json y 6 mas: Conservar GLM20 y RK; corregir
	cache, tablas Euler y selector del din. Agregar catalogo comun,
	generacion matricial C, memoria GLM y din autosuficiente. Incluir
	corpus, documentacion y pruebas: 357 Simul2 y 67 d2datdinc (r1997).

2026-10-03  Diego Saravia  <dsa@unsa.edu.ar>

	* d2datdinc/pruebas/marcha.ds: Simul2: test de la marcha sin estados y
	grilla sin redondeo acumulado (r1996).

	* d2datdinc/README.md: Documentacion de r1990-r1994: la marcha sin
	estados, los nombres con _ y la falla de la llave (r1995).

	* examples/11/README.md, examples/11/cir2ds.c: cir2ds: subcircuitos
	(.subckt/.ends/X) y barrido .dc (puntos 3 y 4 de
	corpus/spice/incorporar.md) (r1991).

	* d2datdinc/d2datdinc.slex, din/din.c: nombres con guion bajo en ramas
	y nodos (r1990).

	* examples/11/README.md, examples/11/cir2ds.c: cir2ds: fuentes SFFM y
	directiva .op (puntos 1 y 2 de corpus/spice/incorporar.md) (r1987).

	* reentrante, reentrante/README_slex_bison (1).md,
	reentrante/README_slex_bison.md y 3 mas: (sin mensaje) (r1986).

	* PLAN.md, README, examples/11/README.md: Documentado el ejemplo 11
	(lexer de netlists de SPICE y cir2ds): README propio con las reglas del
	lexer y sus decisiones (el \n adelante en * y +, los sufijos
	numericos), el uso de cir2ds, el ejemplo rc-tran con su .ds y las
	limitaciones; mencion en el ESTADO del README de slex y seccion en
	PLAN.md (r1983).

	* PLAN.md: PLAN: decision 2026-10-01, slex reemplaza a ds2dat (del .ds
	al dato JSON de Simul en una sola pasada, sin .ds2 intermedio); va como
	examples/10. Con el analisis de las tres capas de Simulparser (r1981).

	* examples/11, examples/11/Makefile, examples/11/cir2ds.c y 4 mas:
	SPICE en el arbol: revision de ngspice y propuesta para siru
	(spice.md), 8 netlists de ejemplo corridos con ngspice-42
	(corpus/spice, con los .ds traducidos) y el traductor de netlists
	cir2ds (slex ejemplo 11: lexer de netlists en slex.slex, mas dos
	pasadas para resolver las fuentes controladas y comportamentales).
	Verificado end-to-end: rc-tran.ds corre en simul2 y coincide con
	ngspice y con la solucion analitica del RC; la salida de ngspice y la
	de siru se cruzan con interpola. cir2ds acepta VON/VOFF (PSpice) y
	VT/VH (ngspice) en el modelo SW, y busca las reglas del lexer en el
	slex.slex del directorio actual o junto al ejecutable: sin reglas
	tokenizaba cualquier cosa y escribia un .ds vacio sin avisar. Los .cir
	documentan tres quirks de ngspice-42 en batch: .op y .tf juntos
	abortan, .noise solo corre desde .control con fuente AC, y la llave SW
	ignora VON/VOFF (r1980).

2026-10-02  Diego Saravia  <dsa@unsa.edu.ar>

	* d2datdinc/dato.c: d2datdinc: 'TABLE EIN = x1, y1, ...' en FUNCTIONS
	(nombre y = en vez de coma, d04.d) es una tabla en una sentencia
	(r1976).

	* din/din.c: slex/din: la ecuacion del reloj sin la marca adentro
	(din.c la calcula aparte) (r1975).

	* din/din.c: slex/din: con convolucion y sin estados, un estado reloj
	(r1974).

	* d2datdinc/pruebas/sceptre/wc-tiempo-Sceptre,
	d2datdinc/pruebas/sceptre/wc-tiempo-low-Sceptre,
	d2datdinc/pruebas/sceptre/wc-tiempo-low.log y 9 mas: WORST CASE = LOW |
	HIGH y la corrida: bitacora (paso 5), MANUAL 11 quinquies, README
	'Contra SCEPTRE' (sensibilidad y peor caso de SCEPTRE, valores
	contrarios, pbound_, .sim de reruns); salidas de wc-tiempo y wc-tiempo-
	low; a01_2 comparado por bloques (r1971).

	* d2datdinc/pruebas/6elementos.esperado.dat,
	d2datdinc/pruebas/circuitoB.esperado.dat: slex/d2datdinc: los .dat
	esperados de las pruebas llevan los tipos KE y KJ (r1970).

	* d2datdinc/dato.c: d2datdinc: K, A-B = FCONVE (H) es una rama KE y
	FCONVJ una KJ (r1969).

	* d2datdinc/pruebas/sceptre/wc-tiempo-low.d: pruebas/sceptre/wc-tiempo-
	low.d: lo mismo con RUN WORST CASE = LOW (r1968).

	* din/din.c: slex/din: la convolucion, ramas KE y KJ con datos de etapa
	(r1967).

	* d2datdinc/biblioteca/libraryori.siru: libraryori: tipos KE y KJ, la
	convolucion de SCEPTRE (r1965).

	* d2datdinc/pruebas/sceptre/wc-tiempo.d: wc-tiempo.d: un DEFINED
	PARAMETER de relleno; con cotas y sin DEFINED PARAMETERS el Fortran de
	SCEPTRE no enlaza (pbound_ sin definir) (r1964).

	* d2datdinc/pruebas/sceptre/wc-tiempo.d: pruebas/sceptre/wc-tiempo.d:
	peor caso y corrida en el tiempo con RUN WORST CASE = HIGH, para ver
	que valores deja SCEPTRE para integrar (r1962).

	* d2datdinc/pruebas/sceptre/rerun-Sceptre,
	d2datdinc/pruebas/sceptre/rerun.log,
	d2datdinc/pruebas/sceptre/rerun.sceptre: RERUN comparado con SCEPTRE
	bloque por bloque: a03 (maestra y 3 reruns de P1T1, 8 cifras) y
	tanque_par_1 (PF 400/500/600) iguales; rerun.d de pruebas: SCEPTRE no
	escribe el .sim de los reruns (SIMUL8 DATA GENERATION HAS BEEN DELETED
	FOR THIS RERUN), solo la maestra se compara (r1959).

	* d2datdinc/dato.c: d2datdinc: 'TABLE 1' sola en FUNCTIONS de un .ds
	abre la tabla (r1954).

	* d2datdinc/dato.c: d2datdinc: TABLE 1(TIME) en el valor de una rama de
	un .ds (r1953).

	* d2datdinc/dato.c: d2datdinc: las tablas de SCEPTRE tambien en un .ds
	(r1950).

	* d2datdinc/dato.c: d2datdinc: una condicion en el RUN CONTROLS de un
	.ds va a CONTROL_EQUATIONS (r1947).

	* din/din.c: slex/din: un estado se registra una sola vez (r1946).

	* din/din.c: slex/din: la acumuladora con RES: es un estado (r1945).

	* d2datdinc/dato.c: d2datdinc: una marca vacia (NONUCLEO:) no se traga
	la marca que sigue (r1944).

	* din/din.c: slex/din: los nodos sin camino a la masa se nombran, y la
	masa es GND (r1941).

	* din/din.c: slex/din: un modelo puede nombrar las incognitas del
	circuito (VARIABLES, V: de EQUATIONS) (r1931).

2026-10-01  Diego Saravia  <dsa@unsa.edu.ar>

	* d2datdinc/dato.c: Monte Carlo como el de SCEPTRE (PLAN_DC_RERUN paso
	4): Simul2::DC::montecarlo con su generador RANDU, su gaussiana (12
	uniformes - 6) y su uniforme, media (max+min)/2 y sigma (max-min)/6 por
	independiente, n puntos de operacion y las estadisticas muestrales, a
	NOMBRE.mc; Simul2::DC::opciones corre lo que el archivo pide (Circuito
	y UnPunto); d2datdinc lee RUN MONTE CARLO = n (r1925).

	* din/din.c: slex/din: una semilla que no es variable del sistema se
	avisa por stderr (r1922).

	* din/din.c: slex/din: semillas para Calcula, SEMILLA X = v en RUN
	CONTROLS o X = v en VARIABLES (r1921).

	* d2datdinc/dato.c: d2datdinc: SEMILLA X = valor en RUN CONTROLS (.d y
	.ds) pasa al dato como SEMILLA_X (r1920).

	* din/din.c: slex/din: las funciones del .din van despues de las que
	llaman (r1911).

	* din/din.c: libdin: los dependientes de las opciones DC (GLOBAL.dc) se
	traducen como las salidas, asi un parametro por expresion que solo
	ellos nombran (PR3 de a08.d) queda como incognita del punto de
	operacion (r1908).

	* d2datdinc/probar, din/din.c: slex: siru3.ds tiene el estado X; la
	prueba y el POR HACER de din.c al dia (r1903).

	* din/din.c: slex/din: 'X=0 D:DX' es un estado si una ecuacion de
	EQUATIONS nombra DX (r1901).

	* d2datdinc/probar: probar: las opciones DC (GLOBAL.dc, cotas,
	controles SCEPTRE_*) y los RERUN/CONTINUE (GLOBAL.reruns, continuar) de
	dc-opciones.d y rerun.d (r1900).

	* din/din.c: slex/din: if, and, or, not y xor pasan tal cual a las
	expresiones (r1899).

	* d2datdinc/dato.c: saca_cotas: sin un numero adelante no es una cota
	('(1,0)' solo es un fasor); se miraba despues de saltar blancos
	(r1896).

	* d2datdinc/probar: probar: la cota de R2 va en GLOBAL.cotas, no en el
	valor (r1895).

	* d2datdinc/dato.c, d2datdinc/dato.h, d2datdinc/userfunc.c: d2datdinc
	lee las opciones DC y los reruns de SCEPTRE (PLAN_DC_RERUN paso 1):
	SENSITIVITY, MONTE CARLO y WORST CASE a GLOBAL.dc (conjuntos
	dependientes/independientes); las cotas '(min, max)' y '(porcentaje)'
	de ELEMENTS y DEFINED PARAMETERS a GLOBAL.cotas, fuera del valor; los
	RUN CONTROLS de las opciones a controles SCEPTRE_SENS, _MC, _WC, _DIST,
	_SEMILLA, _MC_DETALLE, _IC_RERUNS; cada RERUN DESCRIPTION (N) a
	GLOBAL.reruns y CONTINUE a GLOBAL.continuar, con sus lineas tal cual
	(r1893).

	* din/din.c: slex/din: una constante de CONSTANTS en un modelo va con
	su valor (r1892).

	* d2datdinc/dato.c: d2datdinc: los controles de paso de SCEPTRE tambien
	en un .ds (r1890).

	* din/din.c: libdin: TABLEBH(PHfe) pegado es TABLE BH (PHfe) tambien en
	un valor (v030.d: la tabla se define en FUNCTIONS despues de DEFINED
	PARAMETERS y d2datdinc no la tenia al leer) (r1885).

	* d2datdinc/dato.c, din/din.c: RUN INITIAL CONDITIONS [ONLY] de
	SCEPTRE, el punto de operacion DC (PLAN_DC_RERUN paso 0): d2datdinc lo
	lee como control SCEPTRE_IC=[1|2]; libdin lo anota en el instante como
	seccion puntodc (estado derivada, solo 0|1); Simul2 resuelve el
	instante en t=0 con las derivadas en 0 y los estados como incognitas,
	arranca desde ahi, y con ONLY escribe solo esa fila (r1879).

	* din/din.c: slex/din: V y el nombre de un nodo es el potencial del
	nodo (r1871).

	* din/din.c: slex/din: una funcion declarada con la cantidad toma sus
	argumentos del cuerpo (r1868).

	* din/din.c: slex/din: T y TIME son el tiempo aunque DEFINED PARAMETERS
	no declare T (r1859).

	* d2datdinc/biblioteca/library-Siru_examples.siru,
	d2datdinc/biblioteca/library-Siru_examples_otros.siru,
	d2datdinc/biblioteca/library-chopped.siru,
	d2datdinc/biblioteca/libraryB-slex_viejos_parser.siru: GORGE pasa a
	CHARGE en las bibliotecas viejas de slex y en circuitoAX1.ds (r1853).

	* d2datdinc/main.c: d2datdinc: un .d sin GND se acepta (la masa es el 0
	o el nodo mas chico) (r1763).

	* PARSERS.md, d2datdinc/README.md, d2datdinc/probar y 5 mas:
	Documentacion y comentarios: bin/simul2 es ahora bin/siru (r1758).

	* viejos/PMP/Siru/bin/siru-viejo.pl, viejos/PMP/Siru/bin/siru.pl:
	Renombrar los dos siru.pl viejos como siru-viejo.pl (r1755).

	* din/din.c: libdin: la condicion inicial de un capacitor dada en
	voltaje (VC1 = 9.25, como en SCEPTRE) pasa a carga, QC1 = C*VC1; antes
	se tomaba 0 sin avisar. Con una capacidad que no es un numero (a01:
	EQUATION 1 (8., 370., J2)) y voltaje inicial distinto de 0 es un error
	que lo dice. abc.d ahora es igual a SCEPTRE (r1753).

2026-09-30  Diego Saravia  <dsa@unsa.edu.ar>

	* din/README.md: Documentar el flujo concatenado en la bobina acoplada
	fuera del corte (r1738): LLAVES.md 13, din/README 6 bis, HECHO, MANUAL
	(r1739).

	* din/din.c: libdin: en el equilibrio, una bobina fuera de todo corte
	pero acoplada por M conserva su flujo concatenado, L*(i - pre_i) +
	M*(i_otra - pre_i_otra) = 0, en vez de quedarse con su corriente: el
	golpe del secundario al abrir el primario (pruebas/mutua-corte.d);
	Simul2/tests/mutua_corte.t (r1738).

	* d2datdinc/pruebas/mutua-corte.d: pruebas/mutua-corte.d: una llave
	abre la rama de L1 sola, acoplada por M a L2 que no esta en el corte;
	hoy el equilibrio pone il1 en 0 y deja il2 como estaba (deberia saltar
	en M/L2*il1) (r1736).

	* din/din.c: libdin: con paso adaptativo y sin maximo, el maximo de
	SCEPTRE (2E-2 * STOP TIME) (r1734).

	* d2datdinc/dato.c: d2datdinc: STEPSIZE junto vale como STEP SIZE en
	RUN CONTROLS (r1733).

	* din/din.c: libdin: las funciones de Fortran del usuario van a la
	seccion externas del .din (r1716).

	* d2datdinc/dato.c: d2datdinc: EXTERNAL NOMBRE (N) RUTA en FUNCTIONS,
	una funcion de Fortran del usuario (r1715).

	* d2datdinc/dato.c: d2datdinc: en DEFINED PARAMETERS, el nombre solo de
	una fuente J es su corriente (r1711).

	* din/din.c: din.c: XTABLE no es una etiqueta de expresion (r1710).

	* d2datdinc/Makefile.am, d2datdinc/main.c, d2datdinc/probar y 3 mas: Lo
	que faltaba de la lista: el elemento nulo, RK=[-1], el fasor del
	analisis AC (r1709).

	* din/din.c: tabla.ds corre: Table() adentro de una funcion, y Calcula
	desde el directorio del archivo (r1707).

	* d2datdinc/dato.c, d2datdinc/main.c, din/din.c: Las FUNCTIONS de un
	.ds compilan en Calcula: psicro corre y da sus 'buenos datos' (r1706).

	* d2datdinc/biblioteca/modellib.siru: FUNCTIONS de mas de 6 argumentos
	partidas en dos, para que ExprTk las compile (r1705).

	* din/din.c: libdin: ramas con nombre numerico, y un mensaje claro para
	los modelos por incrementos (r1704).

	* d2datdinc/Makefile.am, d2datdinc/dato.c, d2datdinc/probar y 3 mas:
	libdin y d2datdinc: estados y parametros propios en DEFINED PARAMETERS,
	etiquetas XA y tablas pegadas (r1703).

	* d2datdinc/biblioteca/libraryori.siru, d2datdinc/dato.c,
	d2datdinc/pruebas/6elementos.esperado.dat y 3 mas: Los trafo*.d
	reescritos para que corran; MZZZ comentado; el flujo concatenado en el
	equilibrio (r1695).

	* din/README.md: slex/din/README.md: como resuelve libdin cada caso
	(r1693).

	* d2datdinc/Makefile.am, d2datdinc/probar, d2datdinc/pruebas/isla.d,
	din/din.c: libdin: un nodo de cada isla va a potencial cero (los
	circuitos con jacobiano singular) (r1688).

	* d2datdinc/main.c, d2datdinc/pruebas/capacidad-variable.d,
	d2datdinc/pruebas/circuitoB.esperado.din y 4 mas: OUTPUTS: la salida
	trae lo que pide el archivo, no los estados (r1684).

	* d2datdinc/Makefile.am, d2datdinc/biblioteca/libraryori.siru,
	d2datdinc/dato.c y 5 mas: El transformador con nucleo: el devanado MW y
	los estados propios de un circuito (r1683).

	* d2datdinc/Makefile.am, d2datdinc/dato.c, d2datdinc/probar y 2 mas: La
	inductancia mutua de SCEPTRE: 'M, L1-L2 = 299.7' (a02.d) (r1680).

	* d2datdinc/probar: probar: los casos de mdin se miran en sus .mdin
	(r1677).

	* d2datdinc/main.c: d2datdinc --din: un caso de mdin deja .mdin, no
	.din (r1676).

	* d2datdinc/Makefile.am, d2datdinc/probar, d2datdinc/pruebas/capacidad-
	variable.d, din/din.c: libdin: la ley del lazo con una capacidad que
	depende de su propio voltaje (r1675).

	* din/din.c: libdin: en el equilibrio, una capacidad puede depender del
	voltaje de su capacitor (r1674).

	* d2datdinc/Makefile.am, d2datdinc/main.c, d2datdinc/probar y 3 mas:
	libdin: ecuaciones propias en un circuito, y DT, TICK y las paradas
	(r1669).

	* din/din.h: Documentar el armador unico: README, din.h, LLAVES.md 13 y
	la bitacora del plan (r1667).

	* din/din.c: libdin: dos mensajes de error que decian otra cosa
	(r1666).

	* d2datdinc/Makefile.am, d2datdinc/main.c, d2datdinc/probar: d2datdinc:
	un .dat como entrada, para que su sistema lo arme el mismo libdin
	(r1663).

	* din/din.c: libdin: T es el tiempo tambien cuando es el valor entero
	de un parametro (r1662).

	* din/din.c: libdin: una condicion vacia no queda pendiente, y la
	parada acepta T<=numero (r1661).

	* d2datdinc/Makefile.am, d2datdinc/main.c, d2datdinc/probar y 4 mas:
	libdin y d2datdinc: equilibrio, instante y topologia (pasos 5 y 6 de
	PLAN_UN_ARMADOR) (r1660).

	* din/din.c: libdin: lazos de capacitores y cortes de bobinas (paso 4
	de PLAN_UN_ARMADOR) (r1659).

	* din/din.c: libdin: el tiempo de cada etapa (paso 3 de
	PLAN_UN_ARMADOR) (r1658).

	* d2datdinc/main.c, din/din.c, din/din.h: libdin: la tabla de ramas y
	las llaves (pasos 1 y 2 de PLAN_UN_ARMADOR) (r1657).

	* din/din.c: din.c: funciones de mas de 6 argumentos en linea, y los
	parametros con cotas (r1632).

	* d2datdinc/README.md, din/din.c: slex: modelos y diodos de SCEPTRE (el
	codigo entro en r1625) (r1627).

	* d2datdinc/d2datdinc.slex, d2datdinc/dato.c, d2datdinc/dato.h y 4 mas:
	stiffloli queda corregido y andando; los otros cuatro stiff salen del
	corpus (r1625).

	* d2datdinc/biblioteca/LEEME.md, d2datdinc/biblioteca/modellib.siru:
	slex: modellib.siru, los modelos permanentes de SCEPTRE, en la
	biblioteca (r1622).

	* din/din.c: Una ecuacion con RES: es una salida, no algo sin traducir
	(r1620).

	* din/din.c: libdin arma la ecuacion de la forma por coeficientes
	(LINEAL:) (r1618).

	* d2datdinc/probar, d2datdinc/pruebas/tablas.esperado.din, din/din.c:
	Tablas de SCEPTRE: todas las formas del manual, y el .din las encuentra
	(r1617).

	* d2datdinc/dato.c, din/din.c: El cuarto caso: un solo punto, sin
	estados, que Calcula resuelve una vez (r1616).

	* din/din.c: libdin: un sistema sin ramas puede traer su ecuacion
	diferencial en DEFINED PARAMETERS (r1614).

	* d2datdinc/biblioteca/LEEME.md, d2datdinc/biblioteca/library-
	Siru_examples.siru, d2datdinc/biblioteca/library-
	Siru_examples_otros.siru y 3 mas: Las bibliotecas del corpus van con
	las demas, en slex/d2datdinc/biblioteca (r1609).

2026-09-29  Diego Saravia  <dsa@unsa.edu.ar>

	* d2datdinc/main.c, d2datdinc/pruebas/6elementos.d,
	d2datdinc/pruebas/6elementos.esperado.dat y 19 mas: La masa se llama
	GND: slex, ds2dat y d2ds paran sin GND o con nodo 0 (r1604).

	* din/din.c: La masa es el nodo GND, y sin GND se para (r1602).

	* d2datdinc/pruebas/6elementos.esperado.dat,
	d2datdinc/pruebas/circuitoB.esperado.dat: Los esperado.dat de las
	pruebas, sin el control de rama (r1596).

	* d2datdinc/d2datdinc.slex, d2datdinc/dato.c, din/din.c: El control de
	rama sale del formato: los generadores no lo escriben y libdin lo
	rechaza (r1595).

	* d2datdinc/biblioteca/libraryori.siru, d2datdinc/dato.c,
	d2datdinc/pruebas/6elementos.esperado.dat,
	d2datdinc/pruebas/circuitoB.esperado.dat: LNL: la bobina no lineal, con
	nombre propio y derivada, en la biblioteca (r1592).

	* d2datdinc/README.md: Los valores de un .d van separados, y una fuente
	puede traer su derivada (r1588).

	* d2datdinc/dato.c, d2datdinc/main.c, din/din.c: Un tipo sin modelo en
	el dato es un error, y los generadores lo dicen (r1587).

	* PARSERS.md, PLAN.md, d2datdinc/Makefile.am y 6 mas: contra-dods y
	contra-dins pasan a llamarse compara-dat y compara-din (r1585).

	* d2datdinc/biblioteca/libraryori.siru,
	d2datdinc/pruebas/6elementos.esperado.dat,
	d2datdinc/pruebas/circuitoB.esperado.dat: Fuera de la biblioteca C, CC,
	L y LC; el unico caso que los usaba pasa a CB (r1582).

	* din/din.c: din.c: una rama sin control es la rama siempre activa, no
	un PENDIENTE (r1579).

	* d2datdinc/pruebas/6elementos.esperado.dat,
	d2datdinc/pruebas/circuitoB.ds,
	d2datdinc/pruebas/circuitoB.esperado.dat y 2 mas: Una sola biblioteca,
	la de slex: se borran cuatro de las siete copias (r1574).

	* d2datdinc/biblioteca/libraryori.siru: La biblioteca de slex junta los
	dos arreglos que estaban separados (r1573).

	* ANALISIS.md, PARSERS.md, PLAN.md y 12 mas: corpus: dods pasa a
	siru/corpus, con sus programas y su documentacion (r1571).

	* d2datdinc/biblioteca/libraryori.siru,
	d2datdinc/pruebas/6elementos.esperado.dat,
	d2datdinc/pruebas/circuitoB.esperado.dat,
	d2datdinc/pruebas/libraryori.siru: GORGE pasa a CHARGE en todo lo que
	quedaba (r1569).

	* d2datdinc/biblioteca/libraryori.siru, d2datdinc/dato.c,
	d2datdinc/pruebas/6elementos.esperado.dat: d2datdinc: la llave SB
	(letra S y tipo en la biblioteca) (r1567).

	* d2datdinc/Makefile.am, d2datdinc/pruebas/recongelar:
	pruebas/recongelar: vuelve a generar los .dat y .din congelados del
	corpus (r1566).

	* d2datdinc/README.md, d2datdinc/probar, d2datdinc/pruebas/contra-dins:
	Se saca de las pruebas y de la documentacion el .json que ya no existe
	(r1565).

	* d2datdinc/biblioteca/libraryori.siru, d2datdinc/probar,
	d2datdinc/pruebas/6elementos.esperado.dat y 3 mas: El capacitor es
	carga en todo el corpus: se regeneran los .dat y los .din (r1564).

	* din/din.c: El tiempo deja de ser un parametro fijo: el integrador lo
	pone en cada paso (r1562).

	* din/din.c: din: el comentario de referencia_tabla vuelve arriba de su
	funcion (r1561).

	* din/din.c: din: SIGN(a,b) de Fortran se traduce a (abs(a)*sgn(b))
	(r1559).

	* mdin/LEEME.md, mdin/circuitoB-ED3.din, mdin/circuitoB.csv,
	mdin/circuitoB.png: El resultado de circuitoB, en el corpus de este
	trabajo (r1557).

	* d2datdinc/pruebas/libraryori.siru, din/din.c: circuitoB simula con la
	carga como estado (r1556).

	* d2datdinc/Makefile.am, d2datdinc/main.c, degen y 4 mas: Todo en el
	.din: la corrida como secciones, sin JSON y sin rutas (r1555).

	* Makefile.am, configure.ac, degen y 5 mas: slex: libdegen, el detector
	de lazos y cortes en C (r1554).

	* mdin, mdin/LEEME.md: Saca de Simul2 el Perl que habia puesto ahi
	(r1553).

2026-09-28  Diego Saravia  <dsa@unsa.edu.ar>

	* d2datdinc/pruebas/sceptre, doc: svn:ignore para los generados de
	autotools y de pruebas (r1514).

	* doc, doc/simusol-tutorial-2016.pdf: slex/doc: el tutorial de 2016, y
	no lo que se genera (r1513).

	* d2datdinc/README.md, d2datdinc/main.c, d2datdinc/probar: d2datdinc:
	el .din ampliado lleva la configuracion de Simul2 (# @simul2-config-v1)
	(r1511).

	* PARSERS.md, d2datdinc/pruebas/contra-dins: PARSERS.md paso 4: el .dat
	deja de ser un paso obligado (r1510).

	* d2datdinc/README.md, d2datdinc/dato.c, d2datdinc/probar, din/din.c:
	Permitir configurar paso adaptativo de Simul2 desde RUN CONTROLS
	(r1507).

	* d2datdinc/main.c, d2datdinc/probar, d2datdinc/pruebas/contra-dins:
	los .din llevan en el nombre quien los hizo: -de-d2datdinc (r1504).

	* din/README.md: slex/din y dods: la ecuacion sin marca de tanquej es
	un falso negativo (r1501).

2026-09-28  Diego Saravia  <dsa@unsa.edu.ar>

	* din/din.c (es_lineal, marcas_base): cada ecuación del .din que es
	lineal en las incógnitas, con los datos del sistema (parámetros y
	estados, más dt en el ampliado), termina en "# @lineal". Calcula
	puede aprovecharla para no recalcular el jacobiano, y la verifica
	(calcula-6.0/RESOLUCION.md 4.4). El criterio es conservador y es el
	mismo que el de Simul2 (DesdeDat.pm): los dos siguen dando lo mismo
	byte a byte en los 36 archivos que traducen los dos.
	* d2datdinc/pruebas: los .din esperados, con las marcas (solo eso
	cambia).
	* En el mismo commit va trabajo pendiente de otra sesión: din_config
	recibe el método elegido y el ampliado de un método con bc agrega la
	estimación q_estado, para el paso adaptativo de Simul2.


2026-09-27  Diego Saravia  <dsa@unsa.edu.ar>

	* examples/10: como d2ds, en un .d las subsecciones de RERUN,
	CONTINUE y RE-OUTPUT (hasta END) y de MODEL DESCRIPTION (hasta
	CIRCUIT DESCRIPTION) no son de la corrida principal (bloque en
	userfunc.c); RERUN DESCRIPTION (N), RERUN y EXECUTE, que toma
	c_orden, son encabezados en un .d; end en minúscula (d_end);
	WORST-CASE y OPTIMIZATION como secciones sin traducción. probar:
	12 pruebas.


2026-09-27  Diego Saravia  <dsa@unsa.edu.ar>

	* examples/10/dato.c (d_partir): en RUN CONTROLS solo se parte en
	una coma seguida de algo con = o de una palabra de control, como
	d2ds: la lista de un rerun (INTEGRATION ROUTINE = XPO, RUK, TRAP)
	queda entera.


2026-09-27  Diego Saravia  <dsa@unsa.edu.ar>

	* examples/10: reglas del manual de SCEPTRE, igual que d2ds: una
	línea del .d que termina en delimitador sigue en la siguiente
	(regexp dx_continua, prefijo dx_ en main.c), varias sentencias en
	una línea separadas por coma (d_partir), OUTPUTS sin PLOT,
	renombres ni DEGREES/COMPLEX, STOP IF, y XPO (RK=[13]) cuando no
	hay INTEGRATION ROUTINE. Da lo mismo que d2ds + ds2dat en los 10
	.d de Simulparser/pruebas/sceptre y en c12, a05 y psicro.d. probar:
	11 pruebas.


2026-09-27  Diego Saravia  <dsa@unsa.edu.ar>

	* examples/10/dato.c: tres errores de Siru que perdían datos,
	arreglados igual que en ds2dat (Simulparser/lib/Simusol/Parsers),
	así los dos siguen dando el mismo dato: el valor de
	DEFINED_PARAMETERS ya no se corta en la primera D (PDSUM=X1(...)
	daba X1(P), RUN_CONTROLS acepta blancos alrededor del = (RK = [3]
	quedaba sin valor) y CONSTANTS acepta exponente y no guarda el
	blanco de adelante (1E-3 daba "1"). pruebas/siru3.ds en probar;
	README.md, sección 9.


2026-09-27  Diego Saravia  <dsa@unsa.edu.ar>

	* src/slex.c, src/slex.h (slex_conf): ruta del slex.slex que lee
	ini_slex; NULL (el valor inicial) deja la búsqueda de siempre
	(whereisdata). Sin esto un programa solo andaba parado en el
	directorio de su slex.slex: en otro, whereisdata devolvía "-1" y
	slex arrancaba sin las regexps del usuario, sin avisar.
	doc/API.md.

	* examples/10: nuevo. De .d, .ds o .ds2 al dato JSON de Simul
	(.dat), en C, una pasada: un estado por sección, dos juegos de
	estados (.ds 1..20, .d 101..120, difieren en el ;), las reglas de
	d2ds en las acciones (dato.c), json.c para escribir el JSON.
	Reproduce ds2dat (y d2ds + ds2dat): pruebas/contra-ds2dat da 1079
	iguales y 0 distintos sobre el corpus; ./probar, 9 pruebas.
	Agrega a propósito DATABLOB traducido a ExprTk
	(GLOBAL.perlfunctions) y las TABLE del .d dentro del dato
	(GLOBAL.tablas, referencias a Table()); las rutas de Table() de
	un .ds quedan relativas al .dat. Todo lo que no es JSON va a
	stderr y sin -v no sale nada salvo errores. README.md: diseño,
	resultados y las rarezas de Siru que se reproducen.

	* tests/run_tests.sh: compila el ejemplo 10 y corre su probar.


2026-09-27  Diego Saravia  <dsa@unsa.edu.ar>

	* src/slex.c, src/slexfunc.c, src/slex.h: nada por la salida
	estándar salvo el resultado. Todo lo que no es resultado va a
	stderr (fsal, que era stdout; los printf de depuración y de
	error), y con verbose==0 no se imprime nada salvo errores que
	impiden seguir (una línea del slex.slex que no se puede
	tokenizar o con estado/código inválido, el ciclo sin fin de
	end_while, cuyos listados van a /dev/stderr). Las trazas que
	salían siempre (No hay definiciones aún, DEFS, Match, ANALIZADO,
	REEMP, NAME, EXTRAIDO_1, CREATE_TOKEN, RESPONSE, CANTIDAD DE
	CICLOS, PALABRA, 'N' gives N, errores de \include sin nombre)
	quedan bajo verbose>0. slex.h exporta verbose para que el
	programa la ponga en 0 antes de ini_slex. Los listados
	(list_sources, list_tokens...) siguen escribiendo en el archivo
	pedido ("-" es stdout). Pedido del autor, para el ejemplo 10, que
	escribe JSON por stdout. tests/run_tests.sh: todo OK.


2026-09-27  Diego Saravia  <dsa@unsa.edu.ar>

	* src/slex.c (create_token): segfault almacenando tokens cuya
	regexp tenía usa==4 y ninguna función de usuario: quedaba código
	de debug que desreferenciaba *response sin verificarlo. Guardado
	con chequeos de NULL. Ídem el bloque de debug func_num==9 en
	regexps(). Encontrado corriendo el ejemplo 09 sobre el corpus
	dods.

	* examples/*/userfunc.c (vectorize_usr_func): las funciones de
	usuario se registraban desde el slot 6, pero las funciones
	internas son 7 (slots 0..6) y se registran DESPUÉS de las de
	usuario (vectorize_func llama primero a vectorize_usr_func):
	la primera función de usuario quedaba pisada por regexpslexdef
	y su acción nunca se encontraba. Ahora func_occupy es
	NUM_USR_FUNC+7 y las de usuario van desde el slot 7.
	(examples 01, 02, 03, 04, 06, 07, 08)

	* examples/01,02,03,04,06/userfunc.c (fun001): la firma era la
	vieja, sin el parámetro void **response; ahora que la función
	realmente se registra y se llama, la firma correcta importa.

	* examples/04/Makefile: eliminadas las rutas hardcodeadas a
	/usr/local/lib; usa PREFIX ?= /home/dsa/svn/siru/local con
	-I/-L/-rpath. rpcalc reconstruido y verificado con la entrada
	de prueba de rpcalc.y (resultados 7, 4.4 y 9.4).

	* examples/09/: nuevo ejemplo — lexer para circuitos SCEPTRE
	(.d) y siru (.ds). Un solo slex.slex con tokens genéricos
	(fin de línea, espacios, comentarios # y ;, include/input,
	secciones en mayúsculas, cadenas, números, nombres con guion,
	símbolos). corre_corpus.sh lo verifica contra los 474 archivos
	de Simul/varios/dods: todos OK (0 fallas).

	* doc/manual.tex, doc/manual.pdf: manual de uso en LaTeX.
	Qué es slex, instalación, modelo de trabajo, formato del
	slex.slex, funciones de usuario y su registro (slots 7+),
	programa mínimo, uso con bison, referencia completa de la API,
	diagnóstico de errores, tests y guía de los ejemplos.

	* PLAN.md: anotados los dos bugs de debug sin guardar y el
	ejemplo 09.

	* ../Simul/varios/dods/README.md: descripción de los formatos
	.d (SCEPTRE clásico) y .ds (siru) y sus diferencias.

Psicro 4.0 bajo la AGPL v3 o superior, 2008
Psicro 3.0 Escrito en C bajo Linux, bajo la GPL, 2000
Psicro 2.0 QuickBasic 4.0 Registrado en Argentina
Psicro 1.0 QuickBasic 4.0 1992 - 1996
