Ok, tengo unas necesidades muy similares, tengo una gran cantidad de líneas de sintaxis diferente, básicamente remarcar líneas y líneas con algunos códigos para utilizar en un proceso de formato de tarjeta inteligente, también, líneas descriptivas de claves y códigos secretos, en todos los casos, creo que el patrón/acción "modelo" es el enfoque bestial para reconocer y procesar muchas líneas.
estoy usando C++/CLI para desarrollar mi ensamblaje nombrado LanguageProcessor.dll, el núcleo de esta biblioteca es una clase lex_rule que básicamente contiene:
- un miembro de expresiones regulares miembro de
- un evento
El constructor carga la cadena de expresiones regulares y llama a los códigos necesarios para construir el evento sobre la marcha usando DynamicMethod, Emit y Reflexion ... también en el conjunto existe otra clase como meta y objeto que construye y crea una instancia de los objetos con los nombres simples del publicador y la clase receptora, la clase receptora proporciona los controladores de acción para cada regla coincidente.
Tarde, tengo una clase llamada fasterlex_engine que crea un diccionario <Regex, action_delegate> que carga las definiciones de una matriz para ejecutar.
El proyecto está en un punto avanzado pero todavía estoy construyendo, hoy.Voy a tratar de mejorar el rendimiento de funcionamiento que rodea el acceso secuencial a cada entrada de línea par foreach, a través de el uso de algún mecanismo de buscar el diccionario directamente a través de la expresión regular como:
map_rule[gcnew Regex("[a-zA-Z]")];
Aquí, algunos de los segmentos de mi código:
public ref class lex_rule: ILexRule
{
private:
Exception ^m_exception;
Regex ^m_pattern;
//BACKSTORAGE delegates, esto me lo aprendi asiendo la huella.net de m*e*da JEJE
yy_lexical_action ^m_yy_lexical_action;
yy_user_action ^m_yy_user_action;
public:
virtual property String ^short_id;
private:
void init(String ^_short_id, String ^well_formed_regex);
public:
lex_rule();
lex_rule(String ^_short_id,String ^well_formed_regex);
virtual event yy_lexical_action ^YY_RULE_MATCHED
{
virtual void add(yy_lexical_action ^_delegateHandle)
{
if(nullptr==m_yy_lexical_action)
m_yy_lexical_action=_delegateHandle;
}
virtual void remove(yy_lexical_action ^)
{
m_yy_lexical_action=nullptr;
}
virtual long raise(String ^id_rule, String ^input_string, String ^match_string, int index)
{
long lReturn=-1L;
if(m_yy_lexical_action)
lReturn=m_yy_lexical_action(id_rule,input_string, match_string, index);
return lReturn;
}
}
};
Ahora la clase fasterlex_engine que ejecutar una gran cantidad de par patrón/acción:
public ref class fasterlex_engine
{
private:
Dictionary<String^,ILexRule^> ^m_map_rules;
public:
fasterlex_engine();
fasterlex_engine(array<String ^,2>^defs);
Dictionary<String ^,Exception ^> ^load_definitions(array<String ^,2> ^defs);
void run();
};
Y dE ESTA bacalao para decorar TOPIC..some correo de mi cpp:
este código crea un invocador constructor por el signo del parámetro
inline Exception ^object::builder(ConstructorInfo ^target, array<Type^> ^args)
{
try
{
DynamicMethod ^dm=gcnew DynamicMethod(
"dyna_method_by_totem_motorist",
Object::typeid,
args,
target->DeclaringType);
ILGenerator ^il=dm->GetILGenerator();
il->Emit(OpCodes::Ldarg_0);
il->Emit(OpCodes::Call,Object::typeid->GetConstructor(Type::EmptyTypes)); //invoca a constructor base
il->Emit(OpCodes::Ldarg_0);
il->Emit(OpCodes::Ldarg_1);
il->Emit(OpCodes::Newobj, target); //NewObj crea el objeto e invoca al constructor definido en target
il->Emit(OpCodes::Ret);
method_handler=(method_invoker ^) dm->CreateDelegate(method_invoker::typeid);
}
catch (Exception ^e)
{
return e;
}
return nullptr;
}
Este código adjuntar un cualquier función de controlador (estática o no) para hacer frente a una devolución de llamada planteado haciendo coincidir de una cadena de entrada
Delegate ^connection_point::hook(String ^receiver_namespace,String ^receiver_class_name, String ^handler_name)
{
Delegate ^d=nullptr;
if(connection_point::waitfor_hook<=m_state) // si es 0,1,2 o mas => intenta hookear
{
try
{
Type ^tmp=meta::_class(receiver_namespace+"."+receiver_class_name);
m_handler=tmp->GetMethod(handler_name);
m_receiver_object=Activator::CreateInstance(tmp,false);
d=m_handler->IsStatic?
Delegate::CreateDelegate(m_tdelegate,m_handler):
Delegate::CreateDelegate(m_tdelegate,m_receiver_object,m_handler);
m_add_handler=m_connection_point->GetAddMethod();
array<Object^> ^add_handler_args={d};
m_add_handler->Invoke(m_publisher_object, add_handler_args);
++m_state;
m_exception_flag=false;
}
catch(Exception ^e)
{
m_exception_flag=true;
throw gcnew Exception(e->ToString()) ;
}
}
return d;
}
, finalmente, el código que llama al motor de léxico:
array<String ^,2> ^defs=gcnew array<String^,2> {/* shortID pattern namespc clase fun*/
{"LETRAS", "[A-Za-z]+" ,"prueba", "manejador", "procesa_directriz"},
{"INTS", "[0-9]+" ,"prueba", "manejador", "procesa_comentario"},
{"REM", "--[^\\n]*" ,"prueba", "manejador", "nullptr"}
}; //[3,5]
//USO EL IDENTIFICADOR ESPECIAL "nullptr" para que el sistema asigne el proceso del evento a un default que realice nada
fasterlex_engine ^lex=gcnew fasterlex_engine();
Dictionary<String ^,Exception ^> ^map_error_list=lex->load_definitions(defs);
lex->run();
Supongo, pero creo que esto es imposible porque hay un número infinito de expresiones regulares que coinciden con su clave, y un número infinito de teclas que coinciden con su expresión regular. –
"esto es imposible porque hay un número infinito de expresiones regulares que coinciden con su clave" - no es adivinar. Esa es una consecuencia de la definición de una expresión regular. –
@jeff ¿Tiene una implementación de ejemplo para la solución aceptada? Será útil, ¡Gracias! – 18bytes