476 lines
23 KiB
Python
476 lines
23 KiB
Python
# -*- coding: utf-8 -*-
|
|
import json
|
|
import argparse
|
|
import os
|
|
import copy
|
|
import traceback
|
|
import re
|
|
import importlib
|
|
import sys
|
|
|
|
# --- Constantes y Configuración ---
|
|
SCL_SUFFIX = "_scl"
|
|
GROUPED_COMMENT = "// Logic included in grouped IF"
|
|
|
|
# Global data variable
|
|
data = {}
|
|
|
|
def process_group_ifs(instruction, network_id, scl_map, access_map, data):
|
|
"""
|
|
Busca instrucciones que generan condiciones (Contact, O, Eq, PBox, etc.) ya procesadas
|
|
y, si habilitan un grupo (>1) de bloques funcionales (Move, Add, Call, etc.),
|
|
construye el bloque IF agrupado.
|
|
Modifica el campo 'scl' de la instrucción generadora de condición.
|
|
"""
|
|
instr_uid = instruction["instruction_uid"]
|
|
instr_type = instruction["type"]
|
|
instr_type_original = instr_type.replace("_scl", "").replace("_error", "")
|
|
made_change = False
|
|
|
|
# Solo actuar sobre generadores de condición ya procesados (_scl)
|
|
# y que no sean ellos mismos errores o ya agrupados por otro IF
|
|
if (
|
|
not instr_type.endswith("_scl")
|
|
or "_error" in instr_type
|
|
or instruction.get("grouped", False)
|
|
or instr_type_original
|
|
not in [
|
|
"Contact",
|
|
"O",
|
|
"Eq",
|
|
"Ne",
|
|
"Gt",
|
|
"Lt",
|
|
"Ge",
|
|
"Le",
|
|
"PBox",
|
|
"And",
|
|
"Xor",
|
|
]
|
|
): # Añadir más si es necesario
|
|
return False
|
|
|
|
# Evitar reagrupar si ya se hizo (comprobando si SCL ya es un IF complejo)
|
|
current_scl = instruction.get("scl", "")
|
|
if current_scl.strip().startswith("IF") and "END_IF;" in current_scl:
|
|
# print(f"DEBUG Group: {instr_uid} ya tiene IF complejo, saltando agrupación.")
|
|
return False
|
|
# Ignorar comentarios simples que empiezan por IF
|
|
if current_scl.strip().startswith("//") and "IF" in current_scl:
|
|
return False
|
|
|
|
# Obtener la condición generada por esta instrucción (debería estar en scl_map['out'])
|
|
map_key_out = (network_id, instr_uid, "out")
|
|
condition_scl = scl_map.get(map_key_out)
|
|
|
|
# No agrupar para condiciones triviales, no encontradas o ya agrupadas
|
|
if condition_scl is None or condition_scl in ["TRUE", "FALSE"]:
|
|
return False
|
|
|
|
# Encontrar todos los bloques funcionales habilitados DIRECTAMENTE por esta condición
|
|
grouped_instructions_cores = [] # Lista de SCL 'core' de los consumidores
|
|
consumer_instr_list = [] # Lista de instrucciones consumidoras
|
|
network_logic = next(
|
|
(net["logic"] for net in data["networks"] if net["id"] == network_id), []
|
|
)
|
|
if not network_logic:
|
|
return False
|
|
|
|
# Identificar los tipos de instrucciones que queremos agrupar (bloques funcionales)
|
|
groupable_types = [
|
|
"Move",
|
|
"Add",
|
|
"Sub",
|
|
"Mul",
|
|
"Div",
|
|
"Mod",
|
|
"Convert",
|
|
"Call_FC",
|
|
"Call_FB",
|
|
] # Añadir más si es necesario
|
|
|
|
for consumer_instr in network_logic:
|
|
consumer_uid = consumer_instr["instruction_uid"]
|
|
# Saltar si ya está agrupado por otra condición o es él mismo
|
|
if consumer_instr.get("grouped", False) or consumer_uid == instr_uid:
|
|
continue
|
|
|
|
consumer_en = consumer_instr.get("inputs", {}).get("en")
|
|
consumer_type = consumer_instr.get("type", "") # Tipo actual (_scl o no)
|
|
consumer_type_original = consumer_type.replace("_scl", "").replace("_error", "")
|
|
|
|
# ¿Está la entrada 'en' del consumidor conectada a nuestra salida 'out'?
|
|
is_enabled_by_us = False
|
|
if (
|
|
isinstance(consumer_en, dict)
|
|
and consumer_en.get("type") == "connection"
|
|
and consumer_en.get("source_instruction_uid") == instr_uid
|
|
and consumer_en.get("source_pin")
|
|
== "out" # Condición viene de 'out' del generador
|
|
):
|
|
is_enabled_by_us = True
|
|
|
|
# ¿Es un tipo de instrucción agrupable y ya procesado (tiene SCL)?
|
|
if (
|
|
is_enabled_by_us
|
|
and consumer_type.endswith("_scl")
|
|
and consumer_type_original in groupable_types
|
|
):
|
|
consumer_scl = consumer_instr.get("scl", "")
|
|
# Extraer el SCL core (la parte DENTRO del IF o la línea única si no había IF)
|
|
core_scl = None
|
|
if consumer_scl.strip().startswith("IF"):
|
|
# Extraer todo entre THEN y END_IF;
|
|
match = re.search(
|
|
r"IF\s+.*\s+THEN\s*(.*?)\s*END_IF;",
|
|
consumer_scl,
|
|
re.DOTALL | re.IGNORECASE,
|
|
)
|
|
if match:
|
|
core_scl = match.group(1).strip()
|
|
elif consumer_scl and not consumer_scl.strip().startswith("//"):
|
|
# Si no es IF y no es solo comentario, es el core
|
|
core_scl = consumer_scl.strip()
|
|
|
|
if core_scl:
|
|
grouped_instructions_cores.append(core_scl)
|
|
consumer_instr_list.append(consumer_instr) # Guardar referencia
|
|
# else: # Debug
|
|
# print(f"DEBUG Group: Consumidor {consumer_uid} ({consumer_type}) habilitado por {instr_uid} no tenía SCL core extraíble. SCL: '{consumer_scl}'")
|
|
|
|
# Si encontramos más de un consumidor agrupable
|
|
if len(grouped_instructions_cores) > 1:
|
|
print(
|
|
f"INFO: Agrupando {len(grouped_instructions_cores)} instrucciones bajo condición de {instr_type_original} UID {instr_uid} (Cond: {condition_scl})"
|
|
)
|
|
|
|
# Construir el bloque IF agrupado
|
|
scl_grouped = [f"IF {condition_scl} THEN"]
|
|
for core_line in grouped_instructions_cores:
|
|
# Añadir indentación adecuada (2 espacios)
|
|
indented_core = "\n".join(
|
|
[f" {line.strip()}" for line in core_line.splitlines()]
|
|
)
|
|
scl_grouped.append(indented_core)
|
|
scl_grouped.append("END_IF;")
|
|
final_grouped_scl = "\n".join(scl_grouped)
|
|
|
|
# Sobrescribir 'scl' de la instrucción generadora de condición
|
|
instruction["scl"] = final_grouped_scl
|
|
# Marcar los consumidores como agrupados y limpiar su SCL original
|
|
for consumer_instr in consumer_instr_list:
|
|
consumer_instr["scl"] = f"{GROUPED_COMMENT} (by UID {instr_uid})"
|
|
consumer_instr["grouped"] = True # Marcar como agrupado
|
|
made_change = True
|
|
# else: # Debug
|
|
# if len(grouped_instructions_cores) == 1:
|
|
# print(f"DEBUG Group: Solo 1 consumidor ({consumer_instr_list[0]['instruction_uid']}) para {instr_uid}. No se agrupa.")
|
|
# elif len(grouped_instructions_cores) == 0 and condition_scl not in ['TRUE', 'FALSE']:
|
|
# # Solo mostrar si la condición no era trivial
|
|
# pass # print(f"DEBUG Group: Ningún consumidor agrupable encontrado para {instr_uid} (Cond: {condition_scl}).")
|
|
|
|
return made_change
|
|
|
|
def load_processors(processors_dir="processors"):
|
|
"""
|
|
Escanea el directorio, importa módulos, construye el mapa y una lista
|
|
ordenada por prioridad.
|
|
"""
|
|
processor_map = {}
|
|
processor_list_unsorted = [] # Lista para guardar (priority, type_name, func)
|
|
default_priority = 10 # Prioridad si no se define en get_processor_info
|
|
|
|
if not os.path.isdir(processors_dir):
|
|
print(f"Error: Directorio de procesadores no encontrado: '{processors_dir}'")
|
|
return processor_map, [] # Devuelve mapa vacío y lista vacía
|
|
|
|
print(f"Cargando procesadores desde: '{processors_dir}'")
|
|
processors_package = os.path.basename(processors_dir)
|
|
|
|
for filename in os.listdir(processors_dir):
|
|
if filename.startswith("process_") and filename.endswith(".py"):
|
|
module_name_rel = filename[:-3]
|
|
full_module_name = f"{processors_package}.{module_name_rel}"
|
|
try:
|
|
module = importlib.import_module(full_module_name)
|
|
|
|
if hasattr(module, 'get_processor_info') and callable(module.get_processor_info):
|
|
processor_info = module.get_processor_info()
|
|
info_list = []
|
|
if isinstance(processor_info, dict):
|
|
info_list = [processor_info]
|
|
elif isinstance(processor_info, list):
|
|
info_list = processor_info
|
|
else:
|
|
print(f" Advertencia: get_processor_info en {full_module_name} devolvió tipo inesperado. Se ignora.")
|
|
continue
|
|
|
|
for info in info_list:
|
|
if isinstance(info, dict) and 'type_name' in info and 'processor_func' in info:
|
|
type_name = info['type_name'].lower()
|
|
processor_func = info['processor_func']
|
|
# Obtener prioridad, usar default si no existe
|
|
priority = info.get('priority', default_priority)
|
|
|
|
if callable(processor_func):
|
|
if type_name in processor_map:
|
|
print(f" Advertencia: '{type_name}' en {full_module_name} sobrescribe definición anterior.")
|
|
processor_map[type_name] = processor_func
|
|
# Añadir a la lista para ordenar
|
|
processor_list_unsorted.append({'priority': priority, 'type_name': type_name, 'func': processor_func})
|
|
print(f" - Cargado '{type_name}' (Prio: {priority}) desde {module_name_rel}.py")
|
|
else:
|
|
print(f" Advertencia: 'processor_func' para '{type_name}' en {full_module_name} no es callable.")
|
|
else:
|
|
print(f" Advertencia: Entrada inválida en {full_module_name}: {info}")
|
|
else:
|
|
print(f" Advertencia: Módulo {module_name_rel}.py no tiene 'get_processor_info'.")
|
|
|
|
except ImportError as e:
|
|
print(f"Error importando {full_module_name}: {e}")
|
|
except Exception as e:
|
|
print(f"Error procesando {full_module_name}: {e}")
|
|
traceback.print_exc()
|
|
|
|
# Ordenar la lista por prioridad (menor primero)
|
|
processor_list_sorted = sorted(processor_list_unsorted, key=lambda x: x['priority'])
|
|
|
|
print(f"\nTotal de tipos de procesadores cargados: {len(processor_map)}")
|
|
print(f"Orden de procesamiento por prioridad: {[item['type_name'] for item in processor_list_sorted]}")
|
|
|
|
# Devolver el mapa (para lookup rápido si es necesario) y la lista ordenada
|
|
return processor_map, processor_list_sorted
|
|
|
|
# --- Bucle Principal de Procesamiento (Modificado) ---
|
|
def process_json_to_scl(json_filepath):
|
|
"""
|
|
Lee el JSON simplificado, aplica los procesadores dinámicamente cargados
|
|
siguiendo un orden de prioridad, y guarda el JSON procesado.
|
|
"""
|
|
global data # Necesario si process_group_ifs (definido fuera) accede a data globalmente.
|
|
# Si process_group_ifs está definida DENTRO de process_json_to_scl,
|
|
# no necesitarías global, ya que accedería a la 'data' local.
|
|
# Lo más limpio es definir process_group_ifs fuera y pasarle 'data'
|
|
# como argumento (como ya se hace). Así que 'global data' aquí es probablemente innecesario.
|
|
# Eliminémoslo por ahora y aseguremos que data se pasa a process_group_ifs.
|
|
|
|
if not os.path.exists(json_filepath):
|
|
print(f"Error: JSON no encontrado: {json_filepath}")
|
|
return
|
|
print(f"Cargando JSON desde: {json_filepath}")
|
|
try:
|
|
# Cargar datos en una variable local de esta función
|
|
with open(json_filepath, "r", encoding="utf-8") as f:
|
|
data = json.load(f)
|
|
except Exception as e:
|
|
print(f"Error al cargar JSON: {e}")
|
|
traceback.print_exc()
|
|
return
|
|
|
|
# --- Carga dinámica de procesadores (Obtiene mapa y lista ordenada) ---
|
|
script_dir = os.path.dirname(__file__)
|
|
processors_dir_path = os.path.join(script_dir, 'processors')
|
|
processor_map, sorted_processors = load_processors(processors_dir_path)
|
|
|
|
if not processor_map: # O verificar sorted_processors
|
|
print("Error crítico: No se cargaron procesadores. Abortando.")
|
|
return
|
|
|
|
# --- Crear mapas de acceso por red ---
|
|
network_access_maps = {}
|
|
for network in data.get("networks", []):
|
|
net_id = network["id"]
|
|
current_access_map = {}
|
|
# Extraer todos los 'Access' usados en esta red
|
|
for instr in network.get("logic", []):
|
|
# Revisar Inputs
|
|
for _, source in instr.get("inputs", {}).items():
|
|
sources_to_check = (source if isinstance(source, list) else ([source] if isinstance(source, dict) else []))
|
|
for src in sources_to_check:
|
|
if (isinstance(src, dict) and src.get("uid") and src.get("type") in ["variable", "constant"]):
|
|
current_access_map[src["uid"]] = src
|
|
# Revisar Outputs
|
|
for _, dest_list in instr.get("outputs", {}).items():
|
|
if isinstance(dest_list, list):
|
|
for dest in dest_list:
|
|
if (isinstance(dest, dict) and dest.get("uid") and dest.get("type") in ["variable", "constant"]):
|
|
current_access_map[dest["uid"]] = dest
|
|
network_access_maps[net_id] = current_access_map
|
|
|
|
# --- Inicializar mapa SCL y bucle ---
|
|
scl_map = {} # Mapa para resultados SCL intermedios
|
|
max_passes = 30
|
|
passes = 0
|
|
processing_complete = False
|
|
|
|
print("\n--- Iniciando Bucle de Procesamiento Iterativo (con prioridad) ---")
|
|
while passes < max_passes and not processing_complete:
|
|
passes += 1
|
|
made_change_in_base_pass = False
|
|
made_change_in_group_pass = False
|
|
print(f"\n--- Pase {passes} ---")
|
|
num_processed_this_pass = 0
|
|
num_grouped_this_pass = 0
|
|
|
|
# --- FASE 1: Procesadores Base (Itera según la lista ordenada por prioridad) ---
|
|
print(f" Fase 1 (Base - Orden por Prioridad):")
|
|
for processor_info in sorted_processors: # Iterar sobre la lista ordenada por prioridad
|
|
current_type_name = processor_info['type_name']
|
|
func_to_call = processor_info['func']
|
|
# Descomentar para depuración muy detallada:
|
|
# print(f" Intentando procesar tipo: {current_type_name} (Prio: {processor_info['priority']})")
|
|
|
|
# Buscar instrucciones de este tipo en todas las redes
|
|
for network in data.get("networks", []):
|
|
network_id = network["id"]
|
|
access_map = network_access_maps.get(network_id, {})
|
|
network_logic = network.get("logic", [])
|
|
|
|
for instruction in network_logic:
|
|
instr_uid = instruction.get("instruction_uid")
|
|
instr_type_original = instruction.get("type", "Unknown")
|
|
|
|
# Saltar si ya está procesado, es un error o ya fue agrupado por otro
|
|
if (instr_type_original.endswith(SCL_SUFFIX)
|
|
or "_error" in instr_type_original
|
|
or instruction.get("grouped", False)):
|
|
continue
|
|
|
|
# Determinar el tipo efectivo de la instrucción para la comparación
|
|
# (Manejo especial para 'Call')
|
|
lookup_key = instr_type_original.lower()
|
|
effective_type_name = lookup_key
|
|
if instr_type_original == "Call":
|
|
block_type = instruction.get("block_type", "").upper()
|
|
if block_type == "FC": effective_type_name = "call_fc"
|
|
elif block_type == "FB": effective_type_name = "call_fb"
|
|
# Nota: Si es un tipo de bloque desconocido, effective_type_name será 'call'
|
|
|
|
# Si el tipo efectivo de la instrucción coincide con el tipo que estamos procesando en este ciclo...
|
|
if effective_type_name == current_type_name:
|
|
try:
|
|
# Llamar a la función del procesador, pasando 'data'
|
|
changed = func_to_call(instruction, network_id, scl_map, access_map, data) # Pasar data
|
|
if changed:
|
|
made_change_in_base_pass = True
|
|
num_processed_this_pass += 1
|
|
# La función llamada debe añadir _scl o _error al tipo de la instrucción
|
|
# Descomentar para depuración:
|
|
# print(f" Procesado: {instr_type_original} UID {instr_uid}")
|
|
except Exception as e:
|
|
print(f"ERROR(Base) al procesar {instr_type_original} UID {instr_uid} con {func_to_call.__name__}: {e}")
|
|
traceback.print_exc()
|
|
# Marcar como error para no reintentar
|
|
instruction["scl"] = f"// ERROR en procesador base: {e}"
|
|
instruction["type"] = instr_type_original + "_error"
|
|
made_change_in_base_pass = True # Considerar error como cambio
|
|
|
|
# --- FASE 2: Procesador de Agrupación (Se ejecuta después de toda la Fase 1) ---
|
|
# Ejecutar solo si hubo cambios en la fase base (o en el primer pase)
|
|
if made_change_in_base_pass or passes == 1:
|
|
print(f" Fase 2 (Agrupación IF):")
|
|
for network in data.get("networks", []):
|
|
network_id = network["id"]
|
|
access_map = network_access_maps.get(network_id, {})
|
|
network_logic = network.get("logic", [])
|
|
# Iterar sobre instrucciones ya procesadas que podrían generar condiciones
|
|
for instruction in network_logic:
|
|
# Intentar agrupar solo si está procesado (_scl) y no previamente agrupado
|
|
if instruction["type"].endswith("_scl") and not instruction.get("grouped", False):
|
|
try:
|
|
# Llamar a la función de agrupación, pasando 'data'
|
|
group_changed = process_group_ifs(instruction, network_id, scl_map, access_map, data)
|
|
if group_changed:
|
|
made_change_in_group_pass = True
|
|
num_grouped_this_pass += 1
|
|
except Exception as e:
|
|
print(f"ERROR(Group) al intentar agrupar desde UID {instruction.get('instruction_uid')}: {e}")
|
|
traceback.print_exc()
|
|
# No marcamos la instrucción origen como error, solo falló la agrupación
|
|
|
|
# --- Comprobar si se completó el procesamiento ---
|
|
if not made_change_in_base_pass and not made_change_in_group_pass:
|
|
print(f"\n--- No se hicieron más cambios en el pase {passes}. Proceso iterativo completado. ---")
|
|
processing_complete = True
|
|
else:
|
|
print(f"--- Fin Pase {passes}: {num_processed_this_pass} procesados, {num_grouped_this_pass} agrupados. Continuando...")
|
|
|
|
# --- Comprobar límite de pases ---
|
|
if passes == max_passes and not processing_complete:
|
|
print(f"\n--- ADVERTENCIA: Límite de {max_passes} pases alcanzado. Puede haber dependencias no resueltas. ---")
|
|
|
|
# --- FIN BUCLE ITERATIVO ---
|
|
|
|
# --- Verificación Final de Instrucciones No Procesadas ---
|
|
print("\n--- Verificación Final de Instrucciones No Procesadas ---")
|
|
unprocessed_count = 0
|
|
unprocessed_details = []
|
|
ignored_types = ['raw_scl_chunk', 'unsupported_lang'] # Tipos que esperamos no procesar
|
|
|
|
for network in data.get("networks", []):
|
|
network_id = network.get("id", "Unknown ID")
|
|
network_title = network.get("title", f"Network {network_id}")
|
|
for instruction in network.get("logic", []):
|
|
instr_uid = instruction.get("instruction_uid", "Unknown UID")
|
|
instr_type = instruction.get("type", "Unknown Type")
|
|
is_grouped = instruction.get("grouped", False)
|
|
|
|
# Comprobar si NO está procesada, NO es error, NO está agrupada Y NO es un tipo ignorado
|
|
if (not instr_type.endswith(SCL_SUFFIX) and
|
|
"_error" not in instr_type and
|
|
not is_grouped and
|
|
instr_type.lower() not in ignored_types):
|
|
unprocessed_count += 1
|
|
unprocessed_details.append(
|
|
f" - Red '{network_title}' (ID: {network_id}), "
|
|
f"Instrucción UID: {instr_uid}, Tipo Original: '{instr_type}'"
|
|
)
|
|
|
|
if unprocessed_count > 0:
|
|
print(f"ADVERTENCIA: Se encontraron {unprocessed_count} instrucciones que no fueron procesadas (y no son tipos ignorados):")
|
|
if unprocessed_details:
|
|
for detail in unprocessed_details:
|
|
print(detail)
|
|
print(">>> Estos tipos podrían necesitar un procesador en el directorio 'processors' o tener dependencias irresolubles.")
|
|
# else: # No debería pasar si unprocessed_count > 0 y la lógica es correcta
|
|
# print("...")
|
|
else:
|
|
print("INFO: Todas las instrucciones relevantes fueron procesadas a SCL, marcadas como error o agrupadas exitosamente.")
|
|
|
|
# --- Guardar JSON Final ---
|
|
output_filename = json_filepath.replace("_simplified.json", "_simplified_processed.json")
|
|
print(f"\nGuardando JSON procesado en: {output_filename}")
|
|
try:
|
|
with open(output_filename, "w", encoding="utf-8") as f:
|
|
# Usamos la 'data' local que hemos estado modificando
|
|
json.dump(data, f, indent=4, ensure_ascii=False)
|
|
print("Guardado completado.")
|
|
except Exception as e:
|
|
print(f"Error Crítico al guardar JSON procesado: {e}")
|
|
traceback.print_exc()
|
|
|
|
|
|
# --- Ejecución (igual que antes) ---
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description="Process simplified JSON to embed SCL logic.")
|
|
parser.add_argument(
|
|
"source_xml_filepath",
|
|
nargs="?",
|
|
default="TestLAD.xml",
|
|
help="Path to the original source XML file (used to derive JSON input name, default: TestLAD.xml)"
|
|
)
|
|
args = parser.parse_args()
|
|
|
|
xml_filename_base = os.path.splitext(os.path.basename(args.source_xml_filepath))[0]
|
|
# Usar directorio del script actual si el XML no tiene ruta, o la ruta del XML si la tiene
|
|
xml_dir = os.path.dirname(args.source_xml_filepath)
|
|
input_dir = xml_dir if xml_dir else os.path.dirname(__file__) # Directorio de entrada/salida
|
|
|
|
input_json_file = os.path.join(input_dir, f"{xml_filename_base}_simplified.json")
|
|
|
|
if not os.path.exists(input_json_file):
|
|
print(f"Error Fatal: El archivo de entrada JSON simplificado no existe: '{input_json_file}'")
|
|
print(f"Asegúrate de haber ejecutado 'x1_to_json.py' primero sobre '{args.source_xml_filepath}'.")
|
|
sys.exit(1)
|
|
else:
|
|
process_json_to_scl(input_json_file) |