129 lines
6.2 KiB
Python
129 lines
6.2 KiB
Python
# ToUpload/x3_generate_scl.py
|
|
# -*- coding: utf-8 -*-
|
|
import json
|
|
import os
|
|
import re
|
|
import argparse
|
|
import sys
|
|
import traceback
|
|
|
|
# --- Importar Generadores Específicos ---
|
|
try:
|
|
from generators.generate_scl_db import generate_scl_for_db
|
|
from generators.generate_scl_code_block import generate_scl_for_code_block
|
|
from generators.generate_md_udt import generate_udt_markdown
|
|
from generators.generate_md_tag_table import generate_tag_table_markdown
|
|
from generators.generator_utils import format_variable_name, generate_scl_declarations # Importar generate_scl_declarations
|
|
except ImportError as e:
|
|
print(f"Error crítico: No se pudieron importar los módulos de 'generators': {e}")
|
|
sys.exit(1)
|
|
|
|
# --- Modificar generate_scl_or_markdown para pasar project_root_dir ---
|
|
def generate_scl_or_markdown(processed_json_filepath, output_directory, project_root_dir): # <-- Nuevo argumento
|
|
"""
|
|
Genera un archivo SCL o Markdown a partir del JSON procesado,
|
|
llamando a la función generadora apropiada y escribiendo el archivo.
|
|
Ahora pasa project_root_dir a los generadores relevantes.
|
|
"""
|
|
if not os.path.exists(processed_json_filepath):
|
|
print(f"Error: JSON no encontrado: '{processed_json_filepath}'")
|
|
return
|
|
|
|
print(f"Cargando JSON procesado desde: {processed_json_filepath}")
|
|
try:
|
|
with open(processed_json_filepath, "r", encoding="utf-8") as f:
|
|
data = json.load(f)
|
|
except Exception as e: print(f"Error al cargar/parsear JSON: {e}"); traceback.print_exc(); return
|
|
|
|
block_name = data.get("block_name", "UnknownBlock")
|
|
block_type = data.get("block_type", "Unknown")
|
|
scl_block_name = format_variable_name(block_name)
|
|
output_content = []
|
|
output_extension = ".scl"
|
|
|
|
print(f"Generando salida para: {block_type} '{scl_block_name}' (Original: {block_name})")
|
|
|
|
# --- Selección del Generador y Extensión ---
|
|
generation_function = None
|
|
# Pasar project_root_dir a las funciones que lo necesiten
|
|
func_args = {'data': data}
|
|
if block_type == "GlobalDB":
|
|
print(" -> Modo de generación: DATA_BLOCK SCL")
|
|
generation_function = generate_scl_for_db
|
|
func_args['project_root_dir'] = project_root_dir # <--- Pasar la ruta raíz
|
|
output_extension = ".scl"
|
|
elif block_type in ["FC", "FB", "OB"]:
|
|
print(f" -> Modo de generación: {block_type} SCL")
|
|
generation_function = generate_scl_for_code_block
|
|
# generate_scl_for_code_block también usa generate_scl_declarations internamente
|
|
# así que también necesita la ruta raíz.
|
|
func_args['project_root_dir'] = project_root_dir # <--- Pasar la ruta raíz
|
|
output_extension = ".scl"
|
|
elif block_type == "PlcUDT":
|
|
print(" -> Modo de generación: UDT Markdown")
|
|
generation_function = generate_udt_markdown
|
|
# generate_udt_markdown no necesita buscar otros archivos por ahora
|
|
output_extension = ".md"
|
|
elif block_type == "PlcTagTable":
|
|
print(" -> Modo de generación: Tag Table Markdown")
|
|
generation_function = generate_tag_table_markdown
|
|
output_extension = ".md"
|
|
else:
|
|
print(f"Error: Tipo de bloque desconocido '{block_type}'. No se generará archivo.")
|
|
return
|
|
|
|
# --- Llamar a la función generadora ---
|
|
if generation_function:
|
|
try:
|
|
# Pasar argumentos desempaquetados
|
|
output_content = generation_function(**func_args)
|
|
except Exception as gen_e:
|
|
print(f"Error durante la generación de contenido para {block_type} '{scl_block_name}': {gen_e}")
|
|
traceback.print_exc()
|
|
return
|
|
|
|
# --- Escritura del Archivo de Salida ---
|
|
# Usar el directorio del XML original para la salida final
|
|
output_filename_base = f"{scl_block_name}{output_extension}"
|
|
# El output_directory ya viene calculado correctamente desde __main__
|
|
output_filepath = os.path.join(output_directory, output_filename_base)
|
|
|
|
print(f" -> Escribiendo archivo de salida en: {output_filepath}")
|
|
try:
|
|
os.makedirs(os.path.dirname(output_filepath), exist_ok=True) # Asegurar que el directorio exista
|
|
with open(output_filepath, "w", encoding="utf-8") as f:
|
|
for line in output_content: f.write(line + "\n")
|
|
print(f"Generación de {output_extension.upper()} completada.")
|
|
except Exception as e: print(f"Error al escribir el archivo {output_extension.upper()}: {e}"); traceback.print_exc()
|
|
|
|
# --- Ejecución ---
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description="Generate final SCL or Markdown file.")
|
|
parser.add_argument("source_xml_filepath", help="Path to the original source XML file.")
|
|
# Nuevo argumento para la ruta raíz del proyecto
|
|
parser.add_argument("project_root_dir", help="Path to the root directory of the XML project structure.") # <--- Nuevo argumento
|
|
args = parser.parse_args()
|
|
source_xml_file = args.source_xml_filepath
|
|
project_root_dir = args.project_root_dir # <--- Capturar la ruta raíz
|
|
|
|
if not os.path.exists(source_xml_file): print(f"Advertencia (x3): Archivo XML original no encontrado: '{source_xml_file}'.")
|
|
|
|
xml_filename_base = os.path.splitext(os.path.basename(source_xml_file))[0]
|
|
xml_dir = os.path.dirname(source_xml_file) # Directorio del XML original
|
|
parsing_dir = os.path.join(xml_dir, "parsing") # Directorio de parsing relativo al XML
|
|
input_json_file = os.path.join(parsing_dir, f"{xml_filename_base}_processed.json")
|
|
|
|
# El directorio de salida final será el mismo que el del XML original
|
|
output_dir = xml_dir
|
|
|
|
print(f"(x3) Generando SCL/MD desde: '{os.path.relpath(input_json_file)}' en directorio: '{os.path.relpath(output_dir)}'")
|
|
print(f"(x3) Usando ruta raíz del proyecto: '{project_root_dir}' para buscar UDTs.") # Informar
|
|
|
|
if not os.path.exists(input_json_file):
|
|
print(f"Error Fatal (x3): JSON procesado no encontrado: '{input_json_file}'"); sys.exit(1)
|
|
else:
|
|
try:
|
|
# Pasar project_root_dir a la función principal
|
|
generate_scl_or_markdown(input_json_file, output_dir, project_root_dir) # <--- Pasar la ruta raíz
|
|
sys.exit(0)
|
|
except Exception as e: print(f"Error Crítico (x3): {e}"); traceback.print_exc(); sys.exit(1) |