Creazione di un programma di analisi in C

Prima di iniziare

Una libreria di implementazione caricabile, o LIL (Loadable Implementation Library), è il modulo di implementazione di un programma di analisi in C (o nodo). Una LIL è un oggetto condiviso UNIX o Linux o una DLL (Dynamic Link Library) Windows; la sua estensione file però non è .dll, ma .lil.

Le funzioni di implementazione che devono essere scritte dallo sviluppatore sono riportate in Funzioni di implementazione del programma di analisi in C. Le funzioni di utilità che sono fornite da WebSphere Message Broker per facilitare questa elaborazione sono riportate in Funzioni di utilità del programma di analisi in C.

WebSphere Message Broker fornisce l'origine per un programma di analisi definito dall'utente di esempio denominato BipSampPluginParser.c. Questo è un programma di analisi pseudo XML semplice che è possibile utilizzare nel relativo stato attuale oppure è possibile modificarlo.

L'attività di scrittura di un programma di analisi varia considerevolmente a seconda della complessità del flusso di bit da analizzare. Di seguito sono descritti solo i passi di base. Questi sono riportati nelle seguenti sezioni:
  1. Dichiarazione e definizione del programma di analisi
  2. Creazione di un'istanza del programma di analisi
  3. Eliminazione di un'istanza del programma di analisi

Dichiarazione e definizione del programma di analisi

Per dichiarare e definire un programma di analisi definito dall'utente al broker è necessario includere una funzione di inizializzazione, bipGetParserFactory nella LIL. I passi seguenti evidenziano il modo in cui il broker chiama la funzione di inizializzazione e come tale funzione dichiara e definisce il programma di analisi definito dall'utente:

La seguente procedura mostra come dichiarare e definire il programma di analisi nel broker:

  1. La funzione di inizializzazione, bipGetParserFactory, viene richiamata dal broker dopo il caricamento e l'inizializzazione della LIL da parte del sistema operativo. Il broker richiama tale funzione per individuare l'operatività della LIL e come è possibile eseguirne la chiamata. Ad esempio:
    CciFactory LilFactoryExportPrefix * LilFactoryExportSuffix
    bipGetParserFactory()
  2. La funzione bipGetParserFactory deve poi richiamare la funzione di utilità cpiCreateParserFactory. Questa funzione trasferisce un nome di produttore univoco (o nome di gruppo) per tutti i programmi di analisi supportati dalla LIL in uso. Ogni nome di produttore (o nome di gruppo) ripassato deve essere univoco nell'ambito di tutte le LIL nel broker.
  3. La LIL deve quindi richiamare la funzione di utilità cpiDefineParserClass per trasferire il nome univoco di ciascun programma di analisi e una tabella di funzioni virtuale degli indirizzi delle funzioni di implementazione.
    Ad esempio, nel codice riportato di seguito viene dichiarato e definito un singolo programma di analisi denominato InputxParser:
    {
    CciFactory*     factoryObject;
    int                  rc = 0;
    	CciChar factoryName[] = L"MyParserFactory";
    	CCI_EXCEPTION_ST exception_st;
    
    	/* Creare il produttore per questo programma di analisi */
    	factoryObject = cpiCreateParserFactory(0, factoryName);
    if (factoryObject == CCI_NULL_ADDR) {
    		
    		/* L'eventuale gestione errori locale può essere inserita qui */
    	}
    	else {
    		/* Definire i programmi di analisi previsti da questo produttore */
    		static CNI_VFT vftable = {CNI_VFT_DEFAULT};
    
    /* Imposta tabella funzioni con puntatori sulle funzioni di implementazione del programma di analisi */
    vftable.iFpCreateContext            = cpiCreateContext;
    vftable.iFpParseBufferEncoded       = cpiParseBufferEncoded;
    vftable.iFpParseFirstChild          = cpiParseFirstChild;
    vftable.iFpParseLastChild           = cpiParseLastChild;
    vftable.iFpParsePreviousSibling     = cpiParsePreviousSibling;
    vftable.iFpParseNextSibling         = cpiParseNextSibling;
    vftable.iFpWriteBufferEncoded       = cpiWriteBufferEncoded;
    vftable.iFpDeleteContext            = cpiDeleteContext;
    vftable.iFpSetElementValue          = cpiSetElementValue;
    vftable.iFpElementValue             = cpiElementValue;
    vftable.iFpNextParserClassName      = cpiNextParserClassName;
    vftable.iFpSetNextParserClassName   = cpiSetNextParserClassName;
    vftable.iFpNextParserEncoding       = cpiNextParserEncoding;
    vftable.iFpNextParserCodedCharSetId = cpiNextParserCodedCharSetId;
    
    	cpiDefineParserClass(0, factoryObject, L"InputxParser", &vftable);
    	}
    
    /* Restituisce l'indirizzo di questo oggetto produttore al broker */
    return(factoryObject);
    }

    La funzione di inizializzazione deve quindi creare un produttore di programmi di analisi richiamando cpiCreateParserFactory. Le classi di programmi di analisi supportate dal produttore vengono definite richiamando cpiDefineParserClass. L'indirizzo dell'oggetto produttore (restituito da cpiCreateParserFactory) deve essere restituito al broker come valore di restituzione dalla funzione di inizializzazione.

    Ad esempio:
    1. Creare il produttore di programmi di analisi utilizzando la funzione cpiCreateParserFactory:
        factoryObject = cpiCreateParserFactory(&rc, constParserFactory);
        
    2. Definire le classi di messaggi previste dal produttore utilizzando la funzione cpiDefineParserClass:
      if (factoryObject) {
         cpiDefineParserClass(&rc, factoryObject, constPXML, &vftable);
        }
      else {
          /* Errore: Impossibile creare il produttore del programma di analisi */
        }
    3. Restituire l'indirizzo di questo oggetto produttore al broker:
        return(factoryObject);
      }

Creazione di un'istanza del programma di analisi

La seguente procedura mostra come creare l'istanza del programma di analisi:

Quando il broker riceve la tabella dei puntatori di funzione, richiama la funzione cpiCreateContext per ciascuna istanza creata del programma di analisi definito dall'utente. Con tre flussi di messaggi che utilizzano il programma di analisi definito dall'utente, per ciascuno di questi viene richiamata la funzione cpiCreateContext. Questa funzione assegna la memoria per la creazione dell'istanza del programma di analisi definito dall'utente. Ad esempio:
  1. Richiamare la funzione cpiCreateContext:
    CciContext* _createContext(
      CciFactory*  factoryObject,
      CciChar*    parserName,
      CciNode*    parserObject
    ){
      static char* functionName = (char *)"_createContext()";
      PARSER_CONTEXT_ST* p;
      CciChar          buffer[256];
  2. Assegnare un puntatore al contesto locale ed eliminare il contenuto nell'area del contesto:
      p = (PARSER_CONTEXT_ST *)malloc(sizeof(PARSER_CONTEXT_ST));
    
      if (p) {
         memset(p, 0, sizeof(PARSER_CONTEXT_ST));
  3. Salvare il puntatore dell'oggetto programma di analisi nel contesto:
       p->parserObject = parserObject;
  4. Salvare il nome del programma di analisi:
     CciCharNCpy((CciChar*)&p->parserName, parserName, MAX_NODE_NAME_LEN);
  5. Restituzione del contesto del programma di analisi:
    return (CciContext*) p;

Eliminazione di un'istanza del programma di analisi

I programmi di analisi vengono eliminati quando viene eliminato o ridistribuito un flusso di messaggi oppure quando viene arrestata l'elaborazione del gruppo di esecuzione (utilizzando il comando mqsistop). Quando un programma di analisi viene eliminato, deve liberare la memoria utilizzata e rilasciare le eventuali risorse impegnate. A tal fine, utilizzare la funzione cpiDeleteContext. Ad esempio:

void cpiDeleteContext(
  CciParser*  parser,
  CciContext* context
){
  PARSER_CONTEXT_ST* pc = (PARSER_CONTEXT_ST *)context ;
  int                  rc = 0;

  return;
}
Informazioni particolari | Marchi | Download | Libreria | Supporto | Commenti
Copyright IBM Corporation 1999, 2006 Ultimo aggiornamento: ago 17, 2006
as10010_