none
un message d'erreur abscons RRS feed

  • Question

  • bonjour

    Toujours dans ma conversion du type standard au type managé j'ai un message d'erreur que je ne peux pas rattacher à une construction ou à une autre

    Je vous met le message d'erreur et le code

    1>C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\xmemory(200): error C3699: '&&' : impossible d'utiliser cette indirection sur le type 'SpecificationLoader::CElementSemantiqueM ^'
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(418) : voir la référence à l'instanciation de la classe modèle 'std::allocator<_Ty>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^
    1>          ]
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(476) : voir la référence à l'instanciation de la classe modèle 'std::_List_nod<_Ty,_Alloc>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^,
    1>              _Alloc=std::allocator<SpecificationLoader::CElementSemantiqueM ^>
    1>          ]
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(580) : voir la référence à l'instanciation de la classe modèle 'std::_List_val<_Ty,_Alloc>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^,
    1>              _Alloc=std::allocator<SpecificationLoader::CElementSemantiqueM ^>
    1>          ]
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\xstring(838) : voir la référence à l'instanciation de la classe modèle 'std::list<_Ty>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^
    1>          ]
    1>C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(710): error C3699: '&&' : impossible d'utiliser cette indirection sur le type 'SpecificationLoader::CElementSemantiqueM ^'
    1>C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(715): error C3699: '&&' : impossible d'utiliser cette indirection sur le type 'SpecificationLoader::CElementSemantiqueM ^'
    1>
    1>ÉCHEC de la build.
    1>
    1>Temps écoulé 00:00:00.57
    ========== Génération : 0 a réussi, 1 a échoué, 0 mis à jour, 0 a été ignoré ==========
    

    Je vous met la dernière méthode de la classe

    	void CSchedulerGlobal::ProcessUnivers( CAnalysedSegmentM^ pSegment, bool bIsFirst, bool bTitle, System::String^ wsNextUnivers)
    	{ // 0
    		List<CAnalysedChunkM^>::Enumerator        itChunk;
    		int                                       i1;
    		int                                       iSize;
    		int                                       iNum = 0;
    		int                                       len = 0;
    		int                                       iQualif = 0;
    		CElementSemantiqueM^                      pProposition;
    		CAnalysedChunkM^                          pChunk;
    		CAnalysedWordM^                           pWord;
    		System::String^                           wsProposition;
    		System::String^                           wsActualUnivers;
    		bool                                      bWasFound;
    		bool                                      bWasQualif;
    		int                                       iPredicat = 0;
    		const wchar_t*                            chars;
    		// il faut peut être voir si tout n'est pas dans pSegment
    		iSize = pSegment->pLinguisticSegment->pListProposition->Count;
    		wsProposition = L"";
    		if( iSize > 0)
    		{ // 1
    			for each( pProposition in pSegment->pLinguisticSegment->pListProposition)
    			{ // 2
    				for each( pChunk in pProposition->pListChunk)
    				{ // 3
    					for each( pWord in pChunk->pListWord)
    					{ // 4
    						wsProposition += pWord->wsWord;
    						wsProposition += L" ";
    					} // 4
    				} // 3
    			} // 2
    		} // 1
    		if( iSize == 0 && bTitle == false)
    		{ // 1
    			chars = (const wchar_t*)(Marshal::StringToHGlobalUni( wsProposition)).ToPointer();
    			std::string sProposition = CStrConv::awcstombs((wchar_t*)chars);
    			Marshal::FreeHGlobal(IntPtr((void*)chars));
    			std::string msg = "error: This proposition seems to be weak : " + sProposition;
    			CStrConv::StrFreeA( (char*) sProposition.c_str());
    			throw Doc_exception ( (char*)msg.c_str(), nParagraph);
    		} // 1
    		else
    		{ // 1
    			// on fait un crible dans les Propositions:
    			// si c'est une précondition il doit y avoir un Déclencheur dans les deux premiers chunks
    			// si c'est un qualificateur il doit y avoir un Qualificatuer dans les trois premiers chunks
    			// et c'est tout ce qu'on peut retenir comme règle.
    			bIsFirst = false;
    			int ii = 0;
    			size_t len = pSegment->pLinguisticSegment->pListProposition->Count;
    			for each( pProposition in pSegment->pLinguisticSegment->pListProposition)
    			{ // 2
    				len--;
    				// par défaut on positionne pChunk sur le premier chunk
    				wsProposition = L"";
    				itChunk = pProposition->pListChunk->GetEnumerator();
    				itChunk.MoveNext();
    				pChunk = itChunk.Current;
    				for each( pWord in pChunk->pListWord)
    				{ // 3
    					wsProposition += pWord->wsWord;
    					wsProposition += L" ";
    				} // 3
    			} // 2
    			pProposition->idElement = 0;
    			pProposition->idSegSrc = 0;
    			if( iNum < nParagraph && iNum > 0)
    			{ // 2
    				pProposition->idParagraph = iNum;
    			} // 2
    			else
    			{ // 2
    				pProposition->idParagraph = nParagraph;
    				iNum = nParagraph;
    			} // 2
    			i1 = 0;
    			bWasFound = false;
    			if( nParagraph == 1 || wsNextUnivers != wsActualUnivers)
    			{ // 2
    				pProposition->pUnivers->wsName = wsNextUnivers;
    				pProposition->pUnivers->idParagraph = iNum;
    			} // 2
    			else
    			{ // 2
    				pProposition->pUnivers->wsName = wsActualUnivers;
    				pProposition->pUnivers->idParagraph = iNum;
    			} // 2
    			if( bTitle == true)
    			{ // 2
    				pProposition->pUnivers->wsName = wsProposition;
    				pProposition->TypeElement = enElementSemantiqueM::ELEMENT_TITLE;
    				if( iNum > 0)
    					pProposition->pUnivers->idParagraph = iNum;
    				else
    					pProposition->pUnivers->idParagraph = 0;
    			} // 2
    			i1 = 0;
    			string sProposition = "";
    			bWasFound = false;
    			bWasQualif = false;
    			wsProposition = L"";
    			for each( pChunk in pProposition->pListChunk)
    			{ // 2
    				for each( pWord in pChunk->pListWord)
    				{ // 3
    					wsProposition += pWord->wsWord;
    					wsProposition += L" ";
    				} // 3
    			} // 2
    			if( bTitle == true)
    			{ // 2
    				pProposition->TypeElement = enElementSemantiqueM::ELEMENT_TITLE;
    			} // 2
    			else if( pProposition->TypeElement == enElementSemantiqueM::ELEMENT_PRECONDITION)
    			{ // 2
    				// on est dans l'introduction et on cherche si le premier chunk est un déclencheur
    				itChunk = pProposition->pListChunk->GetEnumerator();
    				itChunk.MoveNext();
    				pChunk = itChunk.Current;
    				if( pChunk->ChunkType == enChunkTypeM::CHUNKTYPE_DECLENCHEUR)
    				{ // 3
    					pProposition->TypeElement = enElementSemantiqueM::ELEMENT_PRECONDITION;
    				} // 3
    			} // 2
    			else
    			{ // 2
    				// un qualificateur doit avoir un chunk Qualificateur qui doit avoir plus de 3 éléments qualificateur dans son texte, sinon c'est un predicat
    				int ii = 0;
    				int iQualif = 0;
    				i1 = 0;
    				iSize = pProposition->pListChunk->Count;
    				for each( pChunk in pProposition->pListChunk)
    				{ // 3
    					wsProposition = L"";
    					for each( pWord in pChunk->pListWord)
    					{ // 4
    						wsProposition += pWord->wsWord;
    						wsProposition += L" ";
    					} // 4
    					ii++;
    					for each( pWord in pChunk->pListWord)
    					{ // 4
    						chars = (const wchar_t*)(Marshal::StringToHGlobalUni( pWord->wsWord)).ToPointer();
    						string sTempWord = CStrConv::awcstombs((wchar_t*)chars);
    						Marshal::FreeHGlobal(IntPtr((void*)chars));
    						if( pWord->wsWord == L"=" || pWord->POS == enPOSM::POS_NB || pWord->POS == enPOSM::POS_NAMED_ENTITY || pWord->POS == enPOSM::POS_COLOR)
    						{ // 5
    							iQualif++;
    							sProposition += sTempWord;
    							sProposition += " ";
    						} // 5
    						CStrConv::StrFreeA( (char*)sTempWord.c_str());
    					} // 4
    					if( iQualif > 2)
    					{ // 4
    						pProposition->TypeElement = enElementSemantiqueM::ELEMENT_QUALIFICATEUR;
    						bWasQualif = true;
    						if( i1 > iSize - 1 && iQualif < 3)
    						{ // 5
    							if( sProposition.size() != 0)
    							{ // 6
    								string msg = "error: This Proposition is ambiguously classified : " + sProposition;
    								throw Doc_exception ( msg.c_str(), nParagraph);
    							} // 6
    						} // 5
    					} // 4
    					else
    					{ // 4
    						pProposition->TypeElement = enElementSemantiqueM::ELEMENT_PREDICAT;
    					} // 4
    				} // 3
    				i1++;
    			} // 2
    			if( bWasQualif == true)
    			{ // 2
    				pProposition->TypeElement = enElementSemantiqueM::ELEMENT_QUALIFICATEUR;
    			} // 2
    			else if( bWasFound == true)
    			{ // 2
    				pProposition->TypeElement = enElementSemantiqueM::ELEMENT_PRECONDITION;
    			} // 2
    			else
    			{ // 2
    				for each( pChunk in pProposition->pListChunk)
    				{ // 3
    					for each( pWord in pChunk->pListWord)
    					{ // 4
    						chars = (const wchar_t*)(Marshal::StringToHGlobalUni( pWord->wsWord)).ToPointer();
    						string sTempWord = CStrConv::awcstombs((wchar_t*)chars);
    						Marshal::FreeHGlobal(IntPtr((void*)chars));
    						sProposition += sTempWord;
    						sProposition += " ";
    						CStrConv::StrFreeA( (char*)sTempWord.c_str());
    					} // 4
    				} // 3
    				if( nParagraph > 10)
    				{ // 3
    					if( pProposition->pUnivers->wsName == L"Summary" || pProposition->pUnivers->wsName == L"Scope" ||  pProposition->pUnivers->wsName == L"Introduction" ||   pProposition->pUnivers->wsName == L"Detailed requirements")
    					{ // 4
    						string msg = "error : this Document seems to have a poor structure, please refere to the User Manual The analysis was stopped ";
    						throw BlockingException ( msg.c_str(), nParagraph);
    					} // 4
    				} // 3
    				int ilen = 0;
    			} // 2
    			i1++;
    		} // 1
    	} //0


    Jean Noël Martin

    mercredi 7 janvier 2015 21:00

Réponses

Toutes les réponses

  • Bonjour, Jean Noël,

    De quel type est pListProposition? Est-ce que vous l’avez définie comme std::vector<CElementSemantiqueM^> pListProposition; , comme std::vector<CElementSemantiqueM> pListProposition; ou autrement?

    Cordialement,
    Dimitar

    jeudi 8 janvier 2015 15:35
    Modérateur
  • J'ai la réponse dans le premier document:je la répète:

    CElementSemantiqueM^                      pProposition;


    Jean Noël Martin

    jeudi 8 janvier 2015 19:25
  • Comme le site n'a pas enregitré la réponse , je le note au passage

    Jean Noël Martin

    jeudi 8 janvier 2015 19:28
  • Bonjour, Jean Noël,

    Je viens de préciser le nom de la variable. Mais je n’arrive pas à deviner son type.

    Cordialement,
    Dimitar


    vendredi 9 janvier 2015 13:16
    Modérateur
  • je vous donne donc la déclaration qui est dans un fichier d'include

    	public ref class CElementSemantiqueM
    	{
    	public:
    	  long idElement;
              long idSegSrc;
              int  iIdDoc;
              int  idParagraph;
              stUniversM^ pUnivers;
              List<CAnalysedChunkM^>^ pListChunk;
              enElementSemantiqueM TypeElement;
    	};


    Jean Noël Martin

    vendredi 9 janvier 2015 15:15
  • C'est toujours la même histoire.

    https://social.msdn.microsoft.com/Forums/fr-FR/e3b18f31-acf3-4dba-a1f7-bdba005ca488/dclarer-un-tableau?forum=visualcplusfr

    Le message d'erreur montre que vous voulez mettre des "CElementSemantiqueM^" dans une std::list et nom dans une System.Collections.Generic::List<T>(http://msdn.microsoft.com/fr-fr/library/6sh2ey19(v=vs.110).aspx) 


    Paul Bacelar, Ex - MVP VC++

    samedi 10 janvier 2015 22:27
    Modérateur
  • Je ne trouve pas de déclaration std::list

    J'ai retiré dans le projet toute les déclarations std::list

    et chaque fois que j'introduit un nouveau fichier il sort le même message, qu'il fasse référence à l'objet ou non


    Jean Noël Martin



    dimanche 18 janvier 2015 23:59
  • http://www.cplusplus.com/reference/list/list/?kw=list

    #include <list>

    Cela fait partie de la bibliothèque standard du C++ standard.

    Nouveau fichier et message d'erreur (tout le message d'erreur), SVP.


    Paul Bacelar, Ex - MVP VC++


    mardi 27 janvier 2015 20:30
    Modérateur
  • J'ai retiré le fichier dans les includes, mais ça n'a rien changé

    Jean Noël Martin

    mercredi 28 janvier 2015 11:35
  • Nouveau fichier et message d'erreur (tout le message d'erreur), SVP. (BIS)


    Paul Bacelar, Ex - MVP VC++

    mercredi 28 janvier 2015 15:05
    Modérateur
  • Sur tous les fichier, quand on a fini de debogger il y a le même message d'erreur Chunker1 etChunk2

    1>C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\xmemory(200): error C3699: '&&' : impossible d'utiliser cette indirection sur le type 'SpecificationLoader::CElementSemantiqueM ^'
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(418) : voir la référence à l'instanciation de la classe modèle 'std::allocator<_Ty>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^
    1>          ]
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(476) : voir la référence à l'instanciation de la classe modèle 'std::_List_nod<_Ty,_Alloc>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^,
    1>              _Alloc=std::allocator<SpecificationLoader::CElementSemantiqueM ^>
    1>          ]
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(580) : voir la référence à l'instanciation de la classe modèle 'std::_List_val<_Ty,_Alloc>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^,
    1>              _Alloc=std::allocator<SpecificationLoader::CElementSemantiqueM ^>
    1>          ]
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\xstring(782) : voir la référence à l'instanciation de la classe modèle 'std::list<_Ty>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^
    1>          ]
    1>          Chunk2.cpp(484) : voir la référence à l'instanciation de la fonction modèle 'std::basic_string<_Elem,_Traits,_Ax> std::operator +<char,std::char_traits<char>,std::allocator<_Ty>>(std::basic_string<_Elem,_Traits,_Ax> &&,const _Elem *)' en cours de compilation
    1>          with
    1>          [
    1>              _Elem=char,
    1>              _Traits=std::char_traits<char>,
    1>              _Ax=std::allocator<char>,
    1>              _Ty=char
    1>          ]
    1>C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(710): error C3699: '&&' : impossible d'utiliser cette indirection sur le type 'SpecificationLoader::CElementSemantiqueM ^'
    1>C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(715): error C3699: '&&' : impossible d'utiliser cette indirection sur le type 'SpecificationLoader::CElementSemantiqueM ^'
    1>
    1>ÉCHEC de la build.


    Jean Noël Martin

    mercredi 28 janvier 2015 22:08
  • >Sur tous les fichier, quand on a fini de debogger

    C'est une erreur de compilation, il n'y donc pas d'exécutable généré donc pas de débogage possible.

    Le message d'erreur montre très clairement que le fichier "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list" est toujours utilisé.

    Je ne vois toujours pas votre code.


    Paul Bacelar, Ex - MVP VC++

    mercredi 28 janvier 2015 23:49
    Modérateur
  • je vous met le code de Chunk2. Il est très gros, je l'ai allégé au maximum;

    	
    /*---------------------------------------------------------------*/
    /* Global conception    : 05-22-2003 ; 17:49:32                  */
    /* Specification        : 03-21-2003 ; 16:30:09                  */
    /*                                                               */
    /* Laval Technopole  - B.P. 0102                                 */
    /* 53001 LAVAL CEDEX                                             */
    /*                                                         V-0.8 */
    /*---------------------------------------------------------------*/
    /*******************************************************************************
     * NOM: Chunker.cpp
     * ROLE:
     * HISTORIQUE:
        * 05/05/2003, yab, initial version
    *******************************************************************************/
    /*_____INCLUDE-FILES__________________________________________________________*/
    #pragma unmanaged 
    #include "StdAfx.h"
    #include "ibase.h"
    #include "AlignStructure.h"
    #include "Macro.h"
    #include "EnumerationM.hpp"
    #include "StructureM.h"
    #include "TypeDefsM.hpp"
    #include "POSM.h"
    #include "Layout.h"
    #include "ClasseAlignerManaged.hpp"
    #include "LinkDescription.h"
    #include "Message.h"
    #include "WordManager.h"
    #include "ParserManager.h"
    #include "Chunker.h"
    #include "Message.h"
    #include "StrConv.h"
    #include "Event.h"
    #include "Option.h"
    #include "ParserManager.h"
    #include "Exception.h"
    #include "segmentation.h"
    #include "Database.h"
    #include "InterbaseManagerM.hpp"
    #include "MissionDatabaseManager.h"
    #include "annexFunctions.h"
    #include "ComputingForAlignment.h"
    #include "schedulerGlobal.h"
    #include "Proposition.h"
    #include "Chunker.h"
    
    
    /*_____LOCAL-DEFINE___________________________________________________________*/
    /*_____LOCAL-TYPES____________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    
    extern int						 nParagraph;
    extern enPOSM NextPos[]= { enPOSM::POS_NONE, enPOSM::POS_NONE, enPOSM::POS_NONE, enPOSM::POS_NONE, enPOSM::POS_NONE, enPOSM::POS_NONE, enPOSM::POS_NONE, enPOSM::POS_NONE, enPOSM::POS_NONE, enPOSM::POS_NONE};
    extern bool m_bOptionProblem;
    std::string                      msg;
    static int						 asoonas;
    static int						 nNum;
    static int nNamed;
    static int nColor;
    static int nMark;
    /*_____LOCAL-DATA_____________________________________________________________*/
    /*_____LOCAL-MACROS___________________________________________________________*/
    /*_____LOCAL-FUNCTIONS-PROTOTYPES_____________________________________________*/
    /*_____GLOBAL-FUNCTIONS_______________________________________________________*/
    /*_____LOCAL-FUNCTIONS________________________________________________________*/
    //
    /*---------------------------------------------------------------*/
    /*                CLASS CHUNKER                                  */
    /*---------------------------------------------------------------*/
    /*This module determines how a chunk  is made. Segments are      */
    /*splitted according to grammatical composition. A chunk is one, */
    /*two or more POS which have grammatically the same type.For each*/
    /*language it's necessary to define categories in order torespect*/
    /*linguistic specificities so,each specificities will be stored  */
    /*in the CHUNKS File. This special file comes from OPTION MANAGER*/
    /*---------------------------------------------------------------*/
    //
    //DATA
    //  STRUCT stWord          To Store Word informations
    //    sWord                String characters of word
    //    sLemma               Lemma of word
    //    sPOS                 Part of speech from word
    //    sGender              Gender of word
    //    sPronunciation       Pronunciation of word
    //    Boolean bExcluded    Point out if word is important or not
    //
    //  verbList               List of POS which belong to verb family
    //  nounList               List of POS which belong to noun family
    //  stopperList            List of POS which belong to stooper family
    //
    //  STRUCT stChunk         Contain information for chunk
    //    stWordList           List of stWord in the chunk
    //    sTypeOfChunk         Specify the type of chunk
    //
    //  stChunkList            List of stChunk
    //ATAD
    namespace SpecificationLoader
    { // -1
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    
    
    
    
    	erc CChunker::SplitIntoChunk(CAnalysedSegmentM^ pSegment, System::String^ wsNextUnivers)
    	{ // 0
    		List<CAnalysedWordM^>::Enumerator  itWord;
    		List<CAnalysedWordM^>::Enumerator  itBack;
    		List<CAnalysedWordM^>::Enumerator  itTempBack;
    		List<CAnalysedWordM^>::Enumerator  itPreviousWord;
    		List<CAnalysedChunkM^>::Enumerator  itChunk;
    		erc ErrorCode = 0;
    		CAnalysedChunkM^ pCurrentChunk;
    		CAnalysedChunkM^ pPreviousChunk;
    		CAnalysedChunkM  PreviousChunk;
    		enPOSM^ Curpos;
    		enPOSM^ DrivingPos;
    		int Step=0;
    		bool processed = false;
    		bool bMarkOngoing;
    		bool bPivotPending;
    		bool bPivotWasPending;
    		bool bIsPlaned;
    		enChunkTypeM^ Chunktype;
    		int len;
    		int iSize;
    		int iSize1;
    		System::String^   wsWord;
    		System::String^   wsNextWord;
    		System::String^   wsNext2Word;
    		System::String^   wsNextText;
    		CAnalysedWordM^ pWord;
    		CAnalysedWordM^ pNextWord;
    		CAnalysedWordM^ pNext2Word;
    		CAnalysedWordM^ pPreviousWord;
    		List<CAnalysedWordM^>^ pListWord;
    		List<CAnalysedWordM^>::Enumerator  itTemp;
    		int iSegment;
    		System::String^ wsText;
    		enPOSM^ NextPos0;
    		enPOSM^ NextPos1;
    		enPOSM^ NextPos2;
    		enPOSM^ NextPos3;
    		enPOSM^ NextPos4;
    		enPOSM^ NextPos5;
    		enPOSM^ NextPos6;
    		enPOSM^ NextPos7;
    		enPOSM^ NextPos8;
    		enPOSM^ NextPos9;
    		const wchar_t* chars;
    		
    		//DO
    		NextPos[0] = enPOSM::POS_NONE;
    		NextPos[1] = enPOSM::POS_NONE;
    		NextPos[2] = enPOSM::POS_NONE;
    		NextPos[3] = enPOSM::POS_NONE;
    		NextPos[4] = enPOSM::POS_NONE;
    		NextPos[5] = enPOSM::POS_NONE;
    		NextPos[6] = enPOSM::POS_NONE;
    		NextPos[7] = enPOSM::POS_NONE;
    		NextPos[8] = enPOSM::POS_NONE;
    		NextPos[9] = enPOSM::POS_NONE;
    		pListWord = pSegment->pLinguisticSegment->pListWord;
    		pPreviousChunk = %PreviousChunk;
    		if( m_bOptionProblem == false)
    		{ // 1
    	//  [Split stWordListSegment in listOfChunks with chunk rules]=
    	//  DO
    	//    [Point on the first element of ListWord from CLinguisticSegment]
    	//    WHILE (stWordListSegment is not end of List)
    			iSegment = 0;
    			ErrorCode = 0;
    			nNum = 0;
    			nColor = 0;
    			nMark = 0;
    			nNamed = 0;
    			bMarkOngoing = false;
    			bPivotWasPending = false;
    			bPivotPending = false;
    			pPreviousChunk->ChunkType = enChunkTypeM::CHUNKTYPE_NONE;
    			iSize = pSegment->pLinguisticSegment->pListWord->Count;
    			System::String^ wsSegment = L"";
         		for each( pWord in pSegment->pLinguisticSegment->pListWord)
    			{ // 2
    				wsSegment += pWord->wsWord;
    				wsSegment += L" ";
    				if( pWord->wsWord  == L"T_EnableDecklidRelease" && pWord->POS == enPOSM::POS_ADJ)
    					pWord->POS = enPOSM::POS_NAMED_ENTITY;
    			} // 2
    			pSegment->pLinguisticSegment->pListChunk->Clear();
    			Step = 0;
    			pPreviousWord = gcnew CAnalysedWordM;
    			pPreviousWord->POS = enPOSM::POS_NONE;
    			iSize =  pSegment->pLinguisticSegment->pListWord->Count;
    			itWord = pSegment->pLinguisticSegment->pListWord->GetEnumerator();
    			for each ( pWord in pSegment->pLinguisticSegment->pListWord)
    			{ // 2
    	//    DO
    				iSegment++;
    	//      Si le mot est un début de syntagme
    			// pour validation il faut avoir acces au lemme
    				wsText = L"";
    				wsWord = pWord->wsWord;
    				if( itWord.MoveNext() != false)
    				{ // 3
    					pNextWord = itWord.Current;
    					wsNextWord = pNextWord->wsWord;
    					if( itWord.MoveNext() != false)
    					{
    						pNext2Word = itWord.Current;
    						wsNext2Word = pNext2Word->wsWord;
    					}
    				}
    				Chunktype = enChunkTypeM::CHUNKTYPE_NONE;
    				int pos = pWord->wsWord->IndexOf( L"ever");
    				if( pos > 0)
    				{ // 3
    					pWord->POS = enPOSM::POS_DECLENCHEUR;
    				} // 3
    				else if( ( pWord->wsWord == L"either") && ( pWord->POS == enPOSM::POS_PREP) && ( pPreviousChunk->ChunkType == enChunkTypeM::CHUNKTYPE_VERB))
    				{ // 3
    					pWord->POS = enPOSM::POS_PIVOT;
    				}
    				else if(( pWord->POS == enPOSM::POS_NB || pWord->POS == enPOSM::POS_AUX) && pNext2Word->POS == enPOSM::POS_DECLENCHEUR && (pNext2Word->wsWord == L"Only" || pNext2Word->wsWord == L"only"))
    				{
    					pNext2Word->POS = enPOSM::POS_ADJ;
    				}
    				else if( pWord->POS == enPOSM::POS_CONJ && pNextWord->POS == enPOSM::POS_DECLENCHEUR && (pNextWord->wsWord == L"Only" || pNextWord->wsWord == L"only"))
    				{
    					pNextWord->POS = enPOSM::POS_ADJ;
    				}
    				if( pWord->POS == enPOSM::POS_PREP && pNextWord->POS == enPOSM::POS_VERB)
    				{
    					Curpos = pWord->POS;
    					Chunktype = NewPosType( pNextWord, pNext2Word);
    				} // 3
    				else
    					Curpos = TestPosType( pWord);
    				wsWord = pWord->wsWord;
    				if( pWord->POS == enPOSM::POS_PRESENT_PARTICIPLE && pPreviousWord->wsWord == L"is")
    				{ // 3
    					pWord->POS = enPOSM::POS_ADJ;
    					Curpos = TestPosType(pWord);
    				} // 3
    				System::String^ wsLemma = pWord->wsLemma;
    				if( wsLemma == L"ha")
    					pWord->wsLemma = L"have";
    				NextPos0 = NextPos[0];
    				NextPos1 = NextPos[1];
    				NextPos2 = NextPos[2];
    				NextPos3 = NextPos[3];
    				NextPos4 = NextPos[4];
    				NextPos5 = NextPos[5];
    				NextPos6 = NextPos[6];
    				NextPos7 = NextPos[7];
    				NextPos8 = NextPos[8];
    				NextPos9 = NextPos[9];
    				wsNextText = wsWord + L" " + wsNextWord + L" " + wsNext2Word;
    				if( Curpos != NextPos0 && Curpos != NextPos1 && Curpos != NextPos2  && Curpos != NextPos3 && Curpos != NextPos4 && Curpos != NextPos5 && Curpos != NextPos6 && Curpos != NextPos7 && Curpos != NextPos8 && Curpos != NextPos9)
    				{ // 3 on a un nouveau syntagme à initialiser
    					bool b1;
    					bool b2;
    					bool bb;
    					bool notbb;
    					pCurrentChunk = gcnew CAnalysedChunkM();
    					if( pPreviousWord != nullptr)
    					{ // 4
    						b1 = pPreviousWord->POS == enPOSM::POS_PRESENT_PARTICIPLE;
    						b2 = pPreviousWord->POS == enPOSM::POS_AUX;
    						bb = b1 || b2;
    						notbb = !bb;
    					}
    					else
    					{
    						b1 = false ;
    						b2 = false;
    						notbb = false;
    					} // 4
    					if( ( Curpos == enPOSM::POS_CONJ || Curpos == enPOSM::POS_COMMA) && pPreviousChunk->ChunkType == enChunkTypeM::CHUNKTYPE_VERB && pPreviousWord->POS != enPOSM::POS_PRESENT_PARTICIPLE)
    					{ // 4
    						if( pWord->POS == enPOSM::POS_COMMA)
    							pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_FUNCT;
    						else
    							pCurrentChunk->ChunkType = NewPosType( pWord, pNextWord);
    					} // 4
    					//      1                                                                       23               2                               1    23               2                10
    					else if( Curpos == enPOSM::POS_PIVOT && pNextWord->POS != enPOSM::POS_DECLENCHEUR && pPreviousChunk->ChunkType == enChunkTypeM::CHUNKTYPE_VERB && notbb)
    						pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_FUNCT;
    					else if( Curpos == enPOSM::POS_PIVOT && pWord->POS != enPOSM::POS_COMMA && pNextWord->POS == enPOSM::POS_NAMED_ENTITY)
    						pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_DECLENCHEUR;
    					else if( iSegment < 5 && pPreviousWord != nullptr && pPreviousWord->POS == enPOSM::POS_MARK && pWord->POS == enPOSM::POS_NAMED_ENTITY && pNextWord->POS == enPOSM::POS_PRESENT_PARTICIPLE)
    						pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_DECLENCHEUR;
    					else if( iSegment == 1 && pWord->POS == enPOSM::POS_NB && pNextWord->POS == enPOSM::POS_MARK)
    						pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_OTHER;
    					else if( pWord->POS == enPOSM::POS_COMMA)
    						pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_OTHER;
    					else if( pWord->POS == enPOSM::POS_NB && pNextWord->POS == enPOSM::POS_DECLENCHEUR)
    						pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_DECLENCHEUR;
    					else
    						pCurrentChunk->ChunkType = NewPosType( pWord, pNextWord);
    					if( pPreviousChunk->ChunkType != enChunkTypeM::CHUNKTYPE_NONE)
    					{ // 4
    						len = pPreviousChunk->pListWord->Count;
    						if (len != 0)
    						{ // 5
    							// void CChunker::InitiateChunk( enPOSM^ DrivingPos, enChunkTypeM ChunkType, CAnalysedSegmentM^ pSegment, CAnalysedChunkM^ pPreviousChunk, CAnalysedChunkM^ pCurrentChunk)
    							InitiateChunk( DrivingPos, Chunktype, pSegment, pPreviousChunk, pCurrentChunk);
    						} // 5
    					} // 4
    					if( bMarkOngoing == true)
    					{ // 4
    						// il faut mettre le PreviousWord dans un chunk unique et
    						// reconstruire l'environnement de travail
    						bMarkOngoing = false;
    						pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_OTHER;
    						pCurrentChunk->DrivingPos = enPOSM::POS_MARK;
    						pCurrentChunk->pListWord->Add( pPreviousWord);
    						pSegment->pLinguisticSegment->pListChunk->Add( pCurrentChunk);
    						pCurrentChunk = gcnew CAnalysedChunkM;
    					} // 4
    					pCurrentChunk->ChunkType = NewPosType( pWord, pNextWord);
    					Step = 0;
    				} // 3
    				if( bPivotWasPending == true)
    				{	// 3 si on est sur un nom il y a l'article à mémoriser
    					// si on est sur un pronom aussi
    					CAnalysedWordM^ pTempWord = pPreviousWord;
    					enPOSM TempCurpos = (enPOSM)Curpos;
    					switch( TempCurpos)
    					{ // 4
    						case enPOSM::POS_AUX:
    							if( pTempWord->POS == enPOSM::POS_PRONOUN)
    							{ // 5
    								pCurrentChunk->pListWord->Add(  pTempWord);
    								pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_NOUN;
    								pCurrentChunk->DrivingPos = enPOSM::POS_PRONOUN;
    								pSegment->pLinguisticSegment->pListChunk->Add( pCurrentChunk);
    								pCurrentChunk = gcnew CAnalysedChunkM();
    								pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_VERB;
    								Step = 0;
     								NextPos[0] = enPOSM::POS_AUX;
     								NextPos[1] = enPOSM::POS_NONE;
     								NextPos[2] = enPOSM::POS_NONE;
     								NextPos[3] = enPOSM::POS_NONE;
    							} // 5
    							break;
    						case enPOSM::POS_NOUN:
    							if( pTempWord->POS == enPOSM::POS_ART)
    							{ // 5
    								pCurrentChunk->pListWord->Add(  pTempWord);
    								Step = 1;
     								NextPos[0] = enPOSM::POS_NB;
     								NextPos[1] = enPOSM::POS_DECLENCHEUR;
     								NextPos[2] = enPOSM::POS_PRONOUN;
     								NextPos[3] = enPOSM::POS_NOUN;
    							} // 5
    							break;
    						default:
    							break;
    					} // 4
    					Step = 0;
    					bPivotWasPending = false;
    				} // 3
    				else if( bPivotPending == true)
    				{ // 3
    					CAnalysedWordM^ pTempWord = pPreviousWord;
    					pTempWord->POS = enPOSM::POS_CONJ;
    					DrivingPos = enPOSM::POS_CONJ;
    					pCurrentChunk->pListWord->Add(  pTempWord);
    					pCurrentChunk->ChunkType = enChunkTypeM::CHUNKTYPE_DECLENCHEUR;
    					NextPos[0] = enPOSM::POS_NB;
    					NextPos[1] = enPOSM::POS_DECLENCHEUR;
    					NextPos[2] = enPOSM::POS_NONE;
    					NextPos[3] = enPOSM::POS_NAMED_ENTITY;
    					bPivotPending = false;
    					bPivotWasPending = true;
    					Step++;
    				} // 3
    				Chunktype = pCurrentChunk->ChunkType;
    				bool bWord = false;
    				if( pCurrentChunk->ChunkType == enChunkTypeM::CHUNKTYPE_NOUN && (processed == false))
    				{ // 3	// après un déterminant on peut avoir un nom ou un adjectif ou une préposition ou un participe passé
    						//  mais après un adjetif on ne peut trouver qu'un nom
    					if( Step == 0)
    					{ // 4
    						pCurrentChunk = CChunker::InitiateCurrentNounSyntagme( pSegment->pLinguisticSegment, itWord, pCurrentChunk, Step, DrivingPos, bMarkOngoing, bPivotPending);
    						pWord = itWord.Current;
    						processed = true;
    					} // 4
    					else
    					{ // 4
    						int StepDep = Step;
    						itTempBack = itWord;
    						pCurrentChunk = CChunker::AnalyseCurrentNounSyntagme( pSegment->pLinguisticSegment, itWord, pCurrentChunk , Step, DrivingPos, bMarkOngoing, bPivotPending);
    						int InterStep = Step - StepDep;
    						if( InterStep > 1)
    						{ // 5
    							itWord = itTempBack;
    							for( iSize1 = InterStep; iSize1 > StepDep; iSize1--)
    							{ // 6
    								iSize--;
    								itWord.MoveNext();
    							} // 6
    						} // 5
    						processed = true;
    					} // 4
    				} // 3
    	//			[Add current Chunk to ListChunk from CLinguisticSegment]
    	//			[Create a new empty chunk]
    	//			[Add current word to ListWord from Chunk]
    	//			[Type = TestPOSType(POS of current word)]
    				if (pCurrentChunk->ChunkType == enChunkTypeM::CHUNKTYPE_VERB)
    				{ // 3
    					if( Step == 0)
    					{ // 4
    						pCurrentChunk = CChunker::InitiateCurrentVerbSyntagme( pSegment->pLinguisticSegment, itWord, pCurrentChunk, Step, DrivingPos, bMarkOngoing, bPivotPending);
    						pWord = itWord.Current;
    						processed = true;
    					} // 4
    					else
    					{ // 4
    						int StepDep = Step;
    						itTempBack = itWord;
    						pCurrentChunk = CChunker::AnalyseCurrentVerbSyntagme( pSegment->pLinguisticSegment, itWord, pCurrentChunk , Step, DrivingPos, bMarkOngoing, bPivotPending);
    						Chunktype = pCurrentChunk->ChunkType;
    						int InterStep = Step - StepDep;
    						if( InterStep > 1)
    						{ // 5
    							itWord = itTempBack;
    							for( iSize1 = InterStep; iSize1 > StepDep; iSize1--)
    							{ //6
    								iSize--;
    								itWord.MoveNext();
    							} // 6
    						} // 5
    						pWord = itWord.Current;
    						processed = true;
    					} // 4
    				} // 3
    				if (pCurrentChunk->ChunkType == enChunkTypeM::CHUNKTYPE_FUNCT)
    				{ // 3
    					if( Step == 0)
    					{ // 4
    						InitiateCurrentFunct( Step, pCurrentChunk, pWord, DrivingPos, Curpos, processed);
    						processed = true;
    					}// 4
    					else if( Curpos == NextPos[0] || Curpos == NextPos[1] || Curpos == NextPos[2] || Curpos == NextPos[3] || Curpos == NextPos[4] || Curpos == NextPos[5] || Curpos == NextPos[6] || Curpos == NextPos[7] || Curpos == NextPos[8] || Curpos == NextPos[9])
    					{ // 4
    						int StepDep = Step;
    						itTempBack = itWord;
    						//                                        1          2               3                              4                                         5                          6                   7                8          9
    						// CAnalysedChunkM^ ProcessCurrentFunct( int& Step, enPOSM^ Curpos, CAnalysedChunkM^ pCurrentChunk, List<CAnalysedWordM^>::Enumerator itWord, CAnalysedWordM^ pNextWord, enPOSM^ DrivingPos, bool& processed, int& nNum, int& nColor)
    						pCurrentChunk = ProcessCurrentFunct( Step, Curpos, pCurrentChunk, itWord, pNextWord, DrivingPos, processed, nNum, nColor);
    						Chunktype = pCurrentChunk->ChunkType;
    						int InterStep = Step - StepDep;
    						if( InterStep > 1)
    						{ // 5
    							itWord = itTempBack;
    							for( iSize1 = InterStep; iSize1 > StepDep; iSize1--)
    							{ //6
    								iSize--;
    								itWord.MoveNext();
    							} // 6
    						} // 5
    						pWord = itWord.Current;
    						processed = true;
    					} // 4
    				} // 3
    				if (pCurrentChunk->ChunkType == enChunkTypeM::CHUNKTYPE_DECLENCHEUR)
    				{ // 3
    					if( wsNextUnivers->Length == 0 || wsNextUnivers == L"Scope" || wsNextUnivers == L"introduction")
    					{ // 4
    						chars = (const wchar_t*)(Marshal::StringToHGlobalUni( wsSegment)).ToPointer();
    						string seg = CStrConv::awcstombs( (wchar_t*)chars);
    						Marshal::FreeHGlobal(IntPtr((void*)chars));
    						msg = "error: no precondition is allowed in the introduction " + seg + " in the paragraph ";
    						CStrConv::StrFreeA( (char*)seg.c_str());
    						throw Doc_exception( msg.c_str(), nParagraph);
    					} // 4
    					if(Step == 0)
    					{ // 4                                             1          2                               3                      4                5               6
    						// void CChunker::InitiateCurrentDeclencheur( int& Step, CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, bool& processed, enPOSM^ Curpos, enPOSM^ DrivingPos)
    						InitiateCurrentDeclencheur( Step, pCurrentChunk, pWord, processed, Curpos, DrivingPos);
    					} // 4
    					if( Curpos == NextPos[0] || Curpos == NextPos[1] || Curpos == NextPos[2] || Curpos == NextPos[3] || Curpos == NextPos[4] || Curpos == NextPos[5] || Curpos == NextPos[6] || Curpos == NextPos[7] || Curpos == NextPos[8] || Curpos == NextPos[9])
    					{ // 4                                                       1           2              3                               4                                         5                   6               7
    						// CAnalysedChunkM^ CChunker::ProcessCurrentDeclencheur( int& Step, enPOSM^ Curpos, CAnalysedChunkM^ pCurrentChunk, List<CAnalysedWordM^>::Enumerator itWord, enPOSM^ DrivingPos, int& processed, bool& bIsPalned)
    						int StepDep = Step;
    						itTempBack = itWord;
    						pCurrentChunk = ProcessCurrentDeclencheur( Step, Curpos, pCurrentChunk, itWord, DrivingPos, processed, bIsPlaned);
    						Chunktype = pCurrentChunk->ChunkType;
    						int InterStep = Step - StepDep;
    						if( InterStep > 1)
    						{ // 5
    							itWord = itTempBack;
    							for( iSize1 = InterStep; iSize1 > StepDep; iSize1--)
    							{ //6
    								iSize--;
    								itWord.MoveNext();
    							} // 6
    						} // 5
    						pWord = itWord.Current;
    						processed = true;
    					} // 4
    				} // 3
    				if (pCurrentChunk->ChunkType == enChunkTypeM::CHUNKTYPE_OTHER)
    				{ // 3
    					if( Step == 0)
    					{ // 4
    						InitiateCurrentOther( Step, Curpos, processed, pCurrentChunk, pWord, DrivingPos, nNum);
    					} // 4	
    					if( Curpos == NextPos[0] || Curpos == NextPos[1] || Curpos == NextPos[2] || Curpos == NextPos[3] || Curpos == NextPos[4] || Curpos == NextPos[5] || Curpos == NextPos[6] || Curpos == NextPos[7] || Curpos == NextPos[8] || Curpos == NextPos[9])
    					{ // 4
    						if( Step > 1 && processed == false)
    						{ // 5
    							// CAnalysedChunkM^ CChunker::ProcessCurrentOther( int& Step, enPOSM^ Curpos, bool& processed, CAnalysedChunkM^ pCurrentChunk, List<CAnalysedWordM^>::Enumerator itWord, enPOSM^ DrivingPos, int& nColor)
    							pCurrentChunk = ProcessCurrentOther( Step, Curpos, processed, pCurrentChunk, itWord, DrivingPos, nColor);
    						} // 5
    					} // 4
    				}// 3
    				processed = false;
    				itPreviousWord = itWord;
    				pPreviousWord = itPreviousWord.Current;
    				if( !(pPreviousWord->POS == enPOSM::POS_STOPMARK && Step != 1))
    					itWord.MoveNext();
    				} // 3
    				pPreviousChunk = pCurrentChunk;
    			} // 2
    	//    OD
    	//    IF(current Chunk is empty)THEN
    	//      [Delete current Chunk]
    	//    ELSE
    	//      [Find and Set TypeOfChunk of stChunk]
    	//      [Add current Chunk into ListChunk]
    	//    FI
    	// dans le cas normal on a le point dans ListWord
    			if( pCurrentChunk != nullptr)
    			{ // 2
    				iSize = pCurrentChunk->pListWord->Count;
    				if ( iSize == 0)
    				{ // 3
    					// si il n'y a pas de point il faut le réajouter
    					// on reconstitue le segment
    					// on cherche le point
    					// si on ne le trouve pas on remet un point à la fin.
    					CAnalysedChunkM^ pChunk;
    					wsText = L"";
    					for each( pChunk in pSegment->pLinguisticSegment->pListChunk)
    					{ // 4
    						for each( pWord in pChunk->pListWord)
    						{ // 5
    							wsText += pWord->wsWord;
    							wsText += L" ";
    						} // 5
    					} // 4
    					len = wsText->Length;
    					int iresult = wsText->IndexOf( L".");
    					if( iresult == -1)
    					{ // 4
    						wsText = wsText + L" .";
    						// il reste à mettre le point à la fin de la liste chunk si nécéssaire
    						// CAnalysedChunkM^ CChunker::PoseStopmark( CAnalysedSegmentM^ pSegment, CAnalysedWordM^ pWord)
    						pCurrentChunk = PoseStopmark( pSegment, pWord);
    					} // 4
    				} // 3
    				else if( iSize < 100)
    				{ // 3
    					// CAnalysedChunkM^ CChunker::SetChunk( CAnalysedChunkM^ pCurrentChunk, CAnalysedSegmentM^ pSegment, enPOSM^ DrivingPos)
    					pCurrentChunk = SetChunk( pCurrentChunk, pSegment, DrivingPos);
    				} // 3
    			} // 2
    			// void CChunker::TerminateChunk( CAnalysedWordM^ pWord, CAnalysedChunkM^ pChunk, int iSize, CAnalysedSegmentM^ pSegment)
    			TerminateChunk( pWord, pCurrentChunk, Step, pSegment);
    			return( 0);
    		} // 1
    	}; //0


    Jean Noël Martin

    jeudi 29 janvier 2015 10:51
  • >List<CAnalysedWordM^>::Enumerator  itWord;


    Vous utilisez une classe template (C++ natif) ou générique(.NET).

    En .NET, List<T> est dans le namespace "System.Collections.Generic.List<T>", or, vous ne faites pas d'"using namespace" associé.

    En .NET, vous devriez utilisez des références managées (^), or, ce n'est pas le cas.

    Vous faites un include de StdAfx.h, qui très souvent inclus des header de la stl pour accélérer la compilation.

    Une Macro inlinant std::list en List n'est pas impossible.

    Pour être sûr de mes assertions, pouvez-vous compiler, temporairement, l'un des fichier sources qui ne compilent pas avec une option de compilation supplémentaire : "/P"

    https://msdn.microsoft.com/en-us/library/8z9z0bx6.aspx

    On pourra voir dans le fichier xxx.i ainsi créé, la définition exacte de List (Macro, typedef, ...)

    Pour désambigüiser la chose, pouvez-vous ajouter "Generic::" devant chaque utilisation de "List" ?


    Paul Bacelar, Ex - MVP VC++



    jeudi 29 janvier 2015 17:02
    Modérateur
  • J'ai mis tous les appels en commentaire dans stdafx.h

    J'ai indique using namespace System::Collections::Generic; dans la liste des namespace

    J'ai indiqué Generic:: devant chaque déclaration de List

    les deux syntaxes d'appel des objets managés sont indiqués ci-dessous:

    Generic::List<CAnalysedWordM^>^ pListWord;
    Generic::List<CAnalysedWordM^>::Enumerator  itTemp;


    Jean Noël Martin

    jeudi 29 janvier 2015 18:08
  • Et ?


    Paul Bacelar, Ex - MVP VC++

    jeudi 29 janvier 2015 18:25
    Modérateur
  • Ou ?

    Jean Noël Martin

    vendredi 30 janvier 2015 11:55
  • Les messages d'erreurs après modification, par exemple ...

    Paul Bacelar, Ex - MVP VC++

    vendredi 30 janvier 2015 12:37
    Modérateur
  • voila, c'est toujours le même
    C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\xmemory(200): error C3699: '&&' : impossible d'utiliser cette indirection sur le type 'SpecificationLoader::CElementSemantiqueM ^'
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(418) : voir la référence à l'instanciation de la classe modèle 'std::allocator<_Ty>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^
    1>          ]
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(476) : voir la référence à l'instanciation de la classe modèle 'std::_List_nod<_Ty,_Alloc>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^,
    1>              _Alloc=std::allocator<SpecificationLoader::CElementSemantiqueM ^>
    1>          ]
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(580) : voir la référence à l'instanciation de la classe modèle 'std::_List_val<_Ty,_Alloc>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^,
    1>              _Alloc=std::allocator<SpecificationLoader::CElementSemantiqueM ^>
    1>          ]
    1>          C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\xstring(782) : voir la référence à l'instanciation de la classe modèle 'std::list<_Ty>' en cours de compilation
    1>          with
    1>          [
    1>              _Ty=SpecificationLoader::CElementSemantiqueM ^
    1>          ]
    1>          Chunk2.cpp(485) : voir la référence à l'instanciation de la fonction modèle 'std::basic_string<_Elem,_Traits,_Ax> std::operator +<char,std::char_traits<char>,std::allocator<_Ty>>(std::basic_string<_Elem,_Traits,_Ax> &&,const _Elem *)' en cours de compilation
    1>          with
    1>          [
    1>              _Elem=char,
    1>              _Traits=std::char_traits<char>,
    1>              _Ax=std::allocator<char>,
    1>              _Ty=char
    1>          ]
    1>C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(710): error C3699: '&&' : impossible d'utiliser cette indirection sur le type 'SpecificationLoader::CElementSemantiqueM ^'
    1>C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include\list(715): error C3699: '&&' : impossible d'utiliser cette indirection sur le type 'SpecificationLoader::CElementSemantiqueM ^'
    1>


    Jean Noël Martin

    vendredi 30 janvier 2015 18:28
  • Pouvez-vous régénérer les pre-compiled header de votre projet ?

    Pouvez-vous faire la manipulation à base de "/P" indiquée dans mon post de "jeudi 29 janvier 2015 17:02" ?


    Paul Bacelar, Ex - MVP VC++

    samedi 31 janvier 2015 00:10
    Modérateur
  • Je vous fourni les Header de la classe:

    stdAfx.h

    // stdafx.h : fichier Include pour les fichiers Include système standard,
    // ou les fichiers Include spécifiques aux projets qui sont utilisés fréquemment,
    // et sont rarement modifiés
    
    #pragma once
    #define _WIN32_WINDOWS  0x0501
    #define _WIN32_WINNT_WINXP 0x0501
    #define _WIN32_WINNT 0x0501
    #define _AFXDLL
    

    AlignStructure

    /*******************************************************************************
     * FILE NAME: AlignStructure.h
     * PURPOSE  : This file contains
     * HISTORY  :
     * Date        Version                   Author
     * 04/06/2003  Initial version :1.0      Rajani
    *******************************************************************************/
    #ifndef AlignStructureH
    #define AlignStructureH
    
    //---------------------------- INCLUDE FILES -----------------------------------
    
    #define MAX_LINE_SIZE  255
    #define ALIGNINIFILE L"align.ini"
    #define hidDB unsigned long long
    #define erc hidDB
    #define INIT_NO_ERROR 0
    const int HUNDRED = 100;
    // Enumerated values for handling the Criteria values
    	enum class enCriteria
    	{
    		SEGMENT_PERCENTAGE,
    		CHUNK_PERCENTAGE,
    		SERVER_NAME,
    		SERVER_TYPE,
    		DATABASE_FILE_NAME,
    		MAINDATABASE_CHANGED,
    		NO_OF_CRITERIA_ELEMENTS
    	};
    // Enumerated values for handling the Parameter values
    	enum class enParamter
    	{
    		FOCUSED_CELL_BKGND_COLOUR,
    		FOCUSED_CELL_TEXT_COLOUR,
    		MANUAL_ALIGNED_ELEMENTS_COLOUR,
    		EXCLUDED_ELEMENTS_COLOUR,
    		RECENTLY_ALIGNED_ELEMENTS_COLOUR,
    		FORMERLY_ALIGNED_ELEMENTS_COLOUR,
    		NON_ALIGNED_ELEMENTS_COLOUR,
    		MMI_LANGUAGE,
    		NO_OF_PARAMETERS_ELEMENTS
    	};
    #endif

    Macro.h

    /*******************************************************************************
    * FILE NAME: Macro.h
    * PURPOSE:   This file contains the macros to be used across COM utility
    * HISTORY:
    * Date        Version                   Author
    * 03/06/2003  initial version :1.0      Shridhar
    *******************************************************************************/
    #ifndef MacroH
    #define MacroH
    //---------------------------------------------------------------------------
    
    
    //-------------------CONSTANTS AND USER DEFINED DATA TYPES----------------------
    //Constants to extract the respective numbers from return code
    //#define TYPE_MASK 0xC000000000000000
    #define MESSAGE_CODE_MASK 0x3FFFF80000000000
    #define MODULE_ID_MASK 0x000007FF80000000
    #define CLASS_ID_MASK  0x000000007FF80000
    #define FUNCTION_ID_MASK 0x000000000008FF80
    #define RETURN_FUNCTION_MASK 0x000000000000007F
    #define MESSAGE_TYPE_MASK 0x000003FFFFFFFFFF
    
    //Constants to move bits
    #define MOVE_FOR_FUNCTION_ID 7
    #define MOVE_FOR_CLASS_ID 19
    #define MOVE_FOR_MODULE_ID 31
    #define MOVE_FOR_MESSAGE_CODE 43
    #define MOVE_FOR_TYPE 62
    
    //Constant used to initialize error code
    #define INIT_NO_ERROR      0
    #endif

    enumerationM.h

    /*******************************************************************************
    * FILE NAME: Enumerations.hpp
    * PURPOSE:   This file contains constants and user defined data for all the
    *            classes.
    * HISTORY:
    * Date        Version                   Author
    * 16/05/2003  initial version :1.0      jn Martin
    *******************************************************************************/
    #ifndef EnumerationM_H
    #define EnumerationM_H
    //--------------------------- INCLUDE-FILES ------------------------------------
    	
        public enum class enDatabaseServerM
    	{
    		DATABASESERVER_NONE,
    		SQLSERVER,
    	};
    	
    	public enum class enStatusDoc
    	{
    		DOCUMENT_NONE,
    		DOCUMENT_AVAILABLE,
    		DOCUMENT_LOADE,
    		DOCUMENT_CHECKE,
    		DOCUMENT_MODELLE,
    		DOCUMENT_TO_REWORK,
    	};
    
    	public enum class enApplicationNameM
    	{
    		APPLICATIONNAME_NONE,
    		APPLICATIONNAME_SPECIFICATION_LOADER,
    		APPLICATIONNAME_ALIGNER,					//	the document can be read with MS Word as a word document
    		APPLICATIONNAME_MEMORIA_MANAGER,	//	the document can be read with an HTML parser
    		APPLICATIONNAME_TRANSLATION_TOOL,	//	the document can be read with an XML parser
    		NUMBER_OF_APPLICATIONNAME,
    	};
    	//Liste of the existing modules that compose Memoria system
    	public enum class enError
    	{
    		ERROR_DOCUMENT_MANAGER_START_READER = 1,
    		ERROR_DOCUMENT_MANAGER_OPEN_DOC,
    		ERROR_DOCUMENT_MANAGER_INIT_POINT_BLOC,
    		ERROR_DOCUMENT_MANAGER_READ_BLOC,
    		ERROR_PARSER_MANAGER_PARSE_BLOC,
    		ERROR_SEGMENTATION_SPLIT_IN_SEGMENT,
    		ERROR_CHUNKER_SPLIT_IN_CHUNK,
    		ERROR_CANNOT_SEARCH_NGRAM,
    		ERROR_SEGMENTATION_ADD_SPACE,
    		ERROR_MISSION_DATABASE_CREATE_SEGMENT,
    		ERROR_CANNOT_COMPUTE_ALIGNMENT_SCORE,
    		POINTER_NULL,
    		ERROR_DATABASE_PROBLEM,
    		CANT_GO_TO_NEXT_BLOC,
    	};
    
    	public enum class enModuleIDM
    	{
    		MODULE_ID_NULL = 0,
    		MODULE_ID_ALN_KERNEL,
    		MODULE_ID_DBMS_MANAGER,
    		MODULE_ID_MDB_MANAGER,
    		MODULE_ID_ALIGNMENT,
    		MODULE_ID_ANALYSER,
    		MODULE_ID_DOCUMENT_MANAGER,
    		MODULE_ID_HTML_READER,
    		MODULE_ID_NARA_MANAGER,
    		MODULE_ID_PARSER_MANAGER,
    		MODULE_ID_WORD_READER,
    		MODULE_ID_XELDA_MANAGER,
    		MODULE_ID_XML_READER,
    		MODULE_ID_EVENT_MANAGER,
    		MODULE_ID_INI_FILE_MANAGER,
    		MODULE_ID_OPTION_MANAGER,
    		MODULE_ID_REPORT_MANAGER,
    		MODULE_ID_TEXT_FILE_MANAGER,
    		MODULE_ID_STATISTIC_MANAGER,
    		NUMBER_OF_MODULE_ID
    	};
    	
    	public enum class enTYPEM
    	{
    		TYPE_NULL = 0,	    	      //	The initialisation type
    		TYPE_INFO,	    	          //	The info type
    		TYPE_WARNING,	              //	The warning type
    		TYPE_ERROR,	    	          //	The error type
    		NUMBER_OF_TYPE                //    the number of type
    	};
    
    	public enum class enLanguageM
    	{
    		LANGUAGE_NONE,                                        //  Undefined language
    		LANGUAGE_FRENCH,                                      //  French
    		LANGUAGE_ENGLISH,                                     //  English
    		LANGUAGE_SPANISH,                                     //  Spanish
    		LANGUAGE_ITALIAN,                                     //  Italian
    		LANGUAGE_GERMAN,                                      //  German
    		NUMBER_OF_LANGUAGE
    	};
    
    	public enum class enSERVER_STATUS
    	{
    		SERVER_DISCONNECTED,
    		SERVER_CONNECTED,
    	};
    	 
    	public enum class enDATABASE_TYPE
    	{
    		ZERO,
    		ONE,
    		TWO,
    		THREE,
    	};
    
    	public enum class enDATABASE_STATUS
    	{
    		DATABASE_CONNECTED,
    		DATABASE_DISCONNECTED,
    	};
    	
    	public enum class enInArray
    	{
    		IN_ARRAY_NULL,          //  DOJ JUST for coding homogeneity
    		IN_ARRAY_TRUE,          //  the element is in Array
    		IN_ARRAY_FALSE,         //  the element is not in Array
    		NUMBER_OF_IN_ARRAY
    	};
    
    	public enum class enBold
    	{
    		BOLD_NULL,					//	the whole element is not in bold, it is not homogeneous
    		BOLD_TRUE,					//	the element is in bold
    		BOLD_FALSE,					//	the element is not in bold
    		NUMBER_OF_BOLD
    	};
    
    	public enum class enItalic
    	{
    		ITALIC_NULL,				//	the whole element is not in Italic, it is not homogeneous
    		ITALIC_TRUE,				//	the element is in Italic
    		ITALIC_FALSE,				//	the element is not in Italic
    		NUMBER_OF_ITALIC
    	};
    
    	public enum class enUnderline
    	{
    		UNDERLINE_NULL,			//	the whole element is not in Underline, it is not homogeneous
    		UNDERLINE_TRUE,			//	the element is in Underline
    		UNDERLINE_FALSE,		//	the element is not in Underline
    		NUMBER_OF_UNDERLINE
    	};
    
    	public enum class enUppercase
    	{
    		UPPERCASE_NULL,			//	the whole element is not in Uppercase, it is not homogeneous
    		UPPERCASE_TRUE,			//	the element is in Uppercase
    		UPPERCASE_FALSE,		//	the element is not in Uppercase
    		NUMBER_OF_UPPERCASE
    	};
    
    	public enum class enColorM
    	{
    		COLOR_NONE,
    		COLOR_BLACK,
    		COLOR_RED,
    		COLOR_ORANGE,
    		COLOR_YELLOW,
    		COLOR_GREEN,
    		COLOR_BLUE,
    		COLOR_VIOLET,
    		COLOR_WHIGHT,
    		NUMBER_OF_COLOR,
    	};
    
    	public enum class enGenderM
    	{
    		GENDER_NONE,
    		GENDER_MASCULINE,
    		GENDER_FEMININE,
    		GENDER_NEUTER,
    		NUMBER_OF_GENDER,
    	};
    
    	public enum class enFlexNumberM
    	{
    		NUMBER_NONE,
    		FLEX_SING,
    		FLEX_PLUR,
    		NUMBER_OF_NUMBER,
    	};
    
    	public enum class enPersM
    	{
    		PERS_NONE,
    		PERS_1,
    		PERS_2,
    		PERS_3,
    		NUMBER_OF_PERS,
    	};
    
    	public enum class enNbrM
    	{
    		NBR_NONE,
    		NBR_SING,
    		NBR_PLUR,
    	};
    
    	public enum class enPOSM
    	{
    		POS_NONE,								//	Undefined                   0
    		POS_PREP,								//	Preposition                 1
    		POS_ART,								//	Article                     2
    		POS_ADJ,								//	Adjective                   3
    		POS_NOUN,								//	Noun                        4
    		POS_NB,								//	Number                      5
    		POS_MARK,								//	Mark                        6
    		POS_SENT,								//	Sentence point              7
    		POS_STOPMARK,							//	Mark of end of sentence     8
    		POS_COMMA,							//	virgule                     9
    		POS_CONJ,								//	Conjunction                 10
    		POS_PRONOUN,							//	Pronoun                     11
    		POS_VERB,								//	Verb                        12
    		POS_AUX,								//	Auxiliary                   13
    		POS_ADV,								//	Adverb                      14
    		POS_PAST_PARTICIPLE,	                //	Participe passé             15
    		POS_PRESENT_PARTICIPLE,               //  Participe présent           16
    		POS_BLANK,							//	Blank                       17
    		POS_ABREV,                            //  Abreviations                18
    		POS_NAMED_ENTITY,                     //  Noms propre et Entitée nomée19
    		POS_DECLENCHEUR,                      //  mots servant à repèrer les préconditions 20
    		POS_DECLENCHEUR_MOT,                  //  noms déclanchant            21
    		POS_PIVOT,                            //  mot continuant un syntagme  22
    		POS_SEMI_COLUMN,                      //  deux points                 23
    		POS_PASSIVE,                          //  mot introduisnat une forme passive 24
    		POS_COLOR,                            //  couleurs normalisées        25
    		POS_OTHER,							  //  Other POS                   26
    		NUMBER_OF_POS,
    	};
    	
    	public enum class enElementSemantiqueM
    	{
    		ELEMENT_NONE,								  //0
    		ELEMENT_PREDICAT,                            //1
    		ELEMENT_PREDICAT_QUALIFIANT,                 //2
    		ELEMENT_PRECONDITION,                        //3
    		ELEMENT_QUALIFICATEUR,                       //4
    		ELEMENT_COMMENTAIRE,                         //5
    		ELEMENT_TITLE,                               //6
    		ELEMENT_OTHER,                               //7
    		NUMBER_OF_ELEMENT
    	};
    
    	
    	public enum class enChunkTypeM
    	{
    		CHUNKTYPE_NONE,                                       // 0 Undefined chunk type
    		CHUNKTYPE_VERB,                                       // 1
    		CHUNKTYPE_NOUN,                                       // 2
    		CHUNKTYPE_FUNCT,                                      // 3
    		CHUNKTYPE_DECLENCHEUR,                                // 4
    		CHUNKTYPE_QUALIFICATEUR,                              // 5
    		CHUNKTYPE_PASSIVE,                                    // 6
    		CHUNKTYPE_OTHER,                                      // 7
    		NUMBER_OF_CHUNKTYPE                                   // 8
    	};
    	
    	public enum class enStatusM
    	{
    		STATUS_NONE,                                          //  weak words   0
    		STATUS_NORMAL,                                        //  NormalWords  1
    		STATUS_BIS,                                           //  doubleWords  2
    		STATUS_NB,                                            //               3
    		STATUS_PROPER,                                        //  ProperNoun   4
    		STATUS_NOT_DEFINED2,                                  //               5
    		STATUS_REGULAR,                                       //  The lemma is an identifier  6
    		STATUS_UNDEFINED,
    		STATUS_NEGATIVE,                                      //  The word  holds a negative form  8
    		STATUS_EXCLUDED,
    		STATUS_NOT_ALIGNED,
    		STATUS_MAN_ALIGNED,
    		STATUS_AUTO_ALIGNED,
    		STATUS_FORMER_ALIGNED,
    		NUMBER_OF_STATUS
    	};
    
    	public enum class enFonctionM
    	{
    		FONCTION_NONE,     //0
    		FONCTION_SUJET,
    		FONCTION_PREDICAT,
    		FONCTION_OBJET,
    		FONCTION_VERB,
    		FONCTION_PIVOT,     //5
    		FONCTION_CONJ,
    		FONCTION_SUBSTANTIF,
    		FONCTION_DECLENCHEUR,
    		FONCTION_IDENTIFIANT,
    		FONCTION_FUNCT,     //10
    		FONCTION_ART,
    		FONCTION_NOUN,
    		FONCTION_QUALIFICATEUR,
    		FONCTION_PASSIVE,
    		FONCTION_TITLE,
    		FONCTION_UNKNOWN,
    		NUMBER_OF_FUNCTIONS
    	};
    
    #endif

    La suite dans le post suivant


    Jean Noël Martin

    samedi 31 janvier 2015 09:58
  • Suite des headers:

    structureM.h

    /*******************************************************************************
    * FILE NAME: StructureM.h
    * PURPOSE:   This file contains constants and user defined data for all the
    *            classes.
    * HISTORY:
    * Date        Version                   Author
    * 16/05/2003  initial version :1.0      JN Martin
    *******************************************************************************/
    #ifndef StructureM_H
    #define StructureM_H
    
    //--------------------------- INCLUDE-FILES ------------------------------------
    //-------------------------- GLOBAL-NAMESPACE-----------------------------------
    namespace SpecificationLoader
    {
    	using namespace System;
    	using namespace System::Collections::Generic;
    //------------------------------------------------------------------------------
    	ref struct sEquationM
    	{
    		int len;
    		array<System::String^, 1>^ pWord1;
    		array<System::String^, 1>^ pWord2;
    	};
    	
    		
    	ref struct ElementWork
    	{
    		int Id;
    		System::String^ wsText;
    	};
    
    	ref struct stPOSM
    	{
    		array<enPOSM, 1>^ pPOS;
    	};
    
    	ref struct stOptionStructureM
    	{
    		System::String^ sSectionName;
    		System::String^ sKeyName;
    		System::String^ sValue;
    	};
    
    	ref struct stAnalysedWordM
    	{
    		System::String^				wsWord;					  //  Texte du mot
    		System::String^				wsLemma;				  //  Texte du lemma
    		enPOSM                      POS;                      //  Part Of Speech du lemma (et du mot)
    		enGenderM                   Gender;                   //  Genre du lemma (et du mot)
    		enPersM                     iPers;
    		enNbrM                      iNbr;
    		int                         iExcluded;                //  Le lemma est important ou non
    		unsigned long               ulStart;                  //  Position du premier caractère du mot dans le segment
    		unsigned long               ulLength;                 //  Longueur du mot (les espaces sont exclus)
    	};
    
    	ref struct stElementDescriptionM
    	{
    		System::String^ sSectionName;
    		System::String^ sKeyName;
    		System::String^ sValue;
    		unsigned int dwValue;
    		bool bValue;
    		System::String^ sDefaultValue;
    		unsigned int dwDefaultValue;
    		bool bDefaultValue;
    		int iType;
    	};
    };
    #endif

    TypeDefsM.hpp

    /*******************************************************************************
    * FILE NAME: TypeDefsM.hpp
    * PURPOSE:   This file contains constants and user defined data for all the
    *            classes.
    * HISTORY:
    * Date        Version                   Author
    * 16/05/2003  initial version :1.0      jn Martin
    *******************************************************************************/
    #ifndef TypeDefsH
    #define TypeDefsH
    //--------------------------- INCLUDE-FILES ------------------------------------
    //--------------------------- DECLARATIONS ------------------------------------
    namespace SpecificationLoader
    {
    	using namespace System;
    	using namespace System::Collections::Generic;
    	
    
    
    
    	typedef ref struct stTranslationLemmaM
    	{
          hidDB idSrcWord;
          hidDB idSrcLemma;
          hidDB idTgtLemma;
          int iProb;
          bool bExclude;
          hidDB hiPos;
          hidDB hiGender;
          hidDB hiLangue;
    	}stTRANSLATION_LEMMA;
    
    	typedef ref struct stListOfElementValuesM
    	{
          hidDB idElement;
          List<stTranslationLemmaM^>^ pListLemma;
    	}stLIST_OF_ELEMENT_VALUES;
    
    	typedef ref struct stElementAlignmentM
    	{
          hidDB idElement;
          hidDB idSegSrc;
          hidDB idSegTgt;
          List<stTranslationLemmaM^>^ pListWord;
          hidDB idChkSrc;
          hidDB idChkTgt;
          hidDB TypeChunk;
          hidDB TypeSeg;
          hidDB Proba;
    	} stELEMENT_ALIGNMENT;
    };
    #endif

    POSM.h

    /*******************************************************************************
     * NOM: 
     * ROLE: 
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef POSM_H
    #define POSM_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    /*_____GLOBAL-NAMESPACE_______________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Collections::Generic;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    /*_____GLOBAL-DATA____________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    	ref class CPOSM
    	{
    	public:
    		static CPOSM^ objPOS;
    		stPOSM  stPos;//	Part Of Speech de l'element
    		enPOSM  POS;											
    		CPOSM::CPOSM();
    		CPOSM::~CPOSM();
    		static System::String^ CPOSM::GetPOSLabelWithPOS(enPOSM POS);
    		static enPOSM CPOSM::GetPOSWithPOSLabel(System::String^ wsPOS);
    	};
    };
    #endif /* POSM_H */
    
    

    Layout.h

    /*******************************************************************************
     * NOM: 
     * ROLE: 
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef LAYOUT_H
    #define LAYOUT_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    #define FONTSIZE_NOT_HOMOGENEOUS          -1
    #define FOREGROUNDCOLOR_NOT_HOMOGENEOUS   -1
    #define BACKGROUNDCOLOR_NOT_HOMOGENEOUS   -1
    /*_____GLOBAL-TYPES___________________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    	ref class CLayout
    	{
    	private:
    		bool CLayout::isConsistent( wchar_t* Name);
    	public:
    		bool              IsValid;
    		System::String^   wsStyleName;              //  Nom du style, si ce n'est pas uniforme, on ne met rien dans le wsStyleName
    		System::String^   wsFontName;               //  Nom de la fonte, si ce n'est pas uniforme, on ne met rien dans le wsFontName
    		long              lFontSize;                //  Taille de la fonte, si ce n'est pas uniforme, on met FONTSIZE_NOT_HOMOGENEOUS
    		enBold            Bold;		                //  L'élément est en gras
    		enItalic          Italic;		            //  L'élément est en italique
    		enUnderline       Underline;                //  L'élément est souligné
    		enUppercase       Uppercase;                //  L'élément est en majuscule
    		long              lForegroundColor;         //  Couleur de l'element, si ce n'est pas uniforme, on met FOREGROUNDCOLOR_NOT_HOMOGENEOUS
    		long              lBackgroundColor;         //  Couleur de fond de l'element, si ce n'est pas uniforme, on met BACKGROUNDCOLOR_NOT_HOMOGENEOUS
    		bool              bInArray;                 //  L'element fait partie d'un tableau
    
    		CLayout::CLayout();
    		CLayout::~CLayout();
    		CLayout^ CLayout::NormLayout( CLayout^ pLayout);
    	};
    };
    /*_____GLOBAL-DATA____________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    #endif /* LAYOUT_H */
    
    

    ClasseAligerManaged.hpp

    /*******************************************************************************
    * FILE NAME: Classes.hpp
    * PURPOSE:   This file contains constants and user defined data for all the
    *            classes.
    * HISTORY:
    * Date        Version                   Author
    * 16/05/2003  initial version :1.0      jn Martin
    *******************************************************************************/
    #ifndef ClassesManagedH
    #define ClassesManagedH
    //--------------------------- INCLUDE-FILES ------------------------------------
    //--------------------------- CLASS-DEFINITION ---------------------------------
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Collections::Generic;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    	public ref struct stUniversM
    	{
          int idParagraph;
          System::String^ wsName;
    	};
    	
    	public ref class CLayoutM
    	{
    	public:
    		bool bTitle;
    		CLayoutM::CLayoutM()
    		{;};
    		CLayoutM::~CLayoutM()
    		{;};
    	};
    	
    	ref class CElementM
    	{
    	public:
    		System::String^ wsElementText;
    		CLayoutM^ pLayout;
    		CElementM::CElementM()
    		{
    			;
    		}
    		CElementM::~CElementM()
    		{
    			;
    		}
    	};
    
    
    	ref class CBlocM
    	{
    	public:
    		wchar_t* wsBlocText;
    		CLayoutM^ pLayoutBloc;
    		List<CElementM^>^ plistElement;
    		CBlocM::CBlocM()
    		{
    			;
    		}
    		CBlocM::~CBlocM()
    		{
    			;
    		}
    	};
    	
    	public ref class CAnalysedWordM
    	{
    	public:
    		unsigned long long          ullWordID;               //  Identifiant du Word dans la base de données
    		unsigned long long          ullLemmaID;              //  Identifiant du Lemma dans la base de données
    		System::String^             wsWord;                   // Texte du mot
    		System::String^             wsLemma;                  // Texte du lemma
    		enPOSM                      POS;                      // Part Of Speech du lemma (et du mot)
    		enGenderM                   iGender;                  // Genre du lemma (et du mot)
    		enPersM                     iPers;                    // la Personne du mot
    		enNbrM                      iNbr;                     // le nombre du mot
    		System::String^             wsPronunciation;          // Prononciation du lemma (pour le japonais)
    		int                         iExcluded;                // La valeur du lemma est important ou non
    		int                         ValueOfWord;              // la valeur du mot pour l'alignement
    		unsigned long               ulStart;                  // Position du premier caractère du mot dans le segment
    		unsigned long               ulLength;                 // Longueur du mot (les espaces sont exclus)
    		int                         iWordOccurence;           // occurence du mot dans la BD
    		CAnalysedWordM()
    		{
    		}
    		~CAnalysedWordM()
    		{;}
    	};
    
    	public ref class   CAnalysedChunkM
    	{
    	public:
    		unsigned long long          ullChunkID;               //  Identifiant du Chunk dans la base de données
    		List<CAnalysedWordM^>^      pListWord;                 //  Liste de pointeurs sur les mots qui constituent le Chunk
    		enChunkTypeM^               ChunkType;                //  Type du chunk
    		enFonctionM^                TypeFonction;
    		enPOSM^                     DrivingPos;                //  POS du terme qui à conduit à la catégrisation du syntagme
    
    	CAnalysedChunkM()
    	{
    		ChunkType = enChunkTypeM::CHUNKTYPE_NONE;
    	}
    	~CAnalysedChunkM()
    		{;}
    	};
    
    	
    	public ref class CChunkDescriptionM
    	{
    	public:
    		enChunkTypeM            ChunkType;          //  Type of the Chunk
    		hidDB                   hidElementID;       //  Identifier of the segment where the chunk is used
    		long long               llChunkID;          //  Identifiant du Chunk dans la base de données
    		long                    lInitialPosition;
    		System::String^         wsText;             //  Texte de l'element
    		int                     Status;
    	  CChunkDescriptionM()
    		{;}
    	  ~CChunkDescriptionM()
    		{;}
    	};
    
    	public ref class CSegmentChunkDescriptionM
    	{
    	public:
    		hidDB                   hidElementID;       //  Identifier of the segment where the chunk is used
    		long long               llChunkID;          //  Identifiant du Chunk dans la base de données
    		long                    lInitialPosition;
    		System::String^         wsText;             //  Texte de l'element
    		enChunkTypeM            ChunkType;          //  Type of the Chunk
    		int                     Status;
    		CSegmentChunkDescriptionM()
    		  {;}
    		~CSegmentChunkDescriptionM()
    		  {;}
    	};
    
    
    	public ref class CSegmentStatisticsM
    	{
    	public:
    		hidDB                       hidSegmentID;             //  Segment identifier in the database
    		long                        lCharNumber;              //  Number of CHAR of this segment
    		long                        lWordNumber;              //  Number of WORD of this segment
    
    		CSegmentStatisticsM()
    		  {;}
    		~CSegmentStatisticsM()
    		  {;}
    	};
    
        
    	public ref class CObjetM
        {
    	public:
    	    CObjetM^ Comprend;
            System::String^ Name;
            System::String^ Text;
            bool Valid;
            CObjetM^ inherit;
            List<System::String^> Enumerated;
            int nValue;
            int min;
            int max;
            int type;
            int step;
        };
        
    
        public ref class QualificateurLinkM
        {
    	public:
    		System::String^ Identifier;
            enPOSM iPos;
            int TypeData;
            cli::array<Int32,1>^ Values;
            List<CAnalysedWordM^>^ pColors;
            int iEnumerated;
            CObjetM^ oValue;
        };
        
        public ref class QualificateurNormalizedM
        {
    	public:
            int indice;
            int Occurence;
            List<QualificateurNormalizedM^>^ plistQualificateur;
            System::String^ ListParagraph;
            stUniversM^ pUnivers;
            System::String^ Verb;
            System::String^ Sujet;
            System::String^ Complement;
            System::String^ Comment;
            System::String^ Declencheur;
            System::String^ Identifier;
            bool bIsEnumerated;
            int iEnumerated;
            enPOSM iPOS;
    		enPersM   iPers;
    		enNbrM    iNbr;
            int TypeData;
            cli::array<Int32,1>^ Values;
            int min;
            int max;
            int type;
            List<CAnalysedWordM^>^ pColors;
            List<CAnalysedWordM^>^ pWord;
            QualificateurLinkM^ plink;
        };
    
        public ref class PropositionNormalizedM
        {
    	public:
    		int     TypeProposition;
            int		indice;
            int		Occurence;
    		int		iEnumerated;
    		enPOSM  iPOS;
    		enPersM iPers;
    		enNbrM  iNbr;
    		int 	TypeData;
            cli::array<Int32,1>^ Values;
    		int		min;
    		int		max;
    		int		type;
    		bool	bIsEnumerated;
            bool	bAllocated;
            bool	bStatus;
            System::String^ ValWords;
    		System::String^ ListParagraph;
            stUniversM^ pUnivers;
            System::String^ Declencheur;
            System::String^ Configuration;
            System::String^ Identifier;
            System::String^ Sujet;
            System::String^ Verb;
            System::String^ Complement;
    		System::String^ Precision;
            System::String^ Frequence;
            System::String^ Comment;
            System::String^ wskeyValue;
            System::String^ operande;
            List<QualificateurLinkM^>^ plistLink;
    		List<CAnalysedWordM^>^ pColors;
            List<CAnalysedWordM^>^ pWord;
        };
        
        public ref class TempPreconditionM
        {
    	public:
            int occurence;
            PropositionNormalizedM^ pPrecondition;
        };
        
        public ref class TermeM
        {
    	public:
            TermeM^ Implique;
            System::String^ wsOrigine;
            System::String^ wsTerme;
            System::String^ wsDeclencheur;
            System::String^ wsIdentifier;
            System::String^ wsValueOfWords;
            System::String^ ListParagraph;
            System::String^ wskeyValue;
            System::String^ operande;
            System::String^ wsText;
            List<CAnalysedWordM^>^ pWord;
            bool bStatus;
        };
    
    	public ref class ElementLinksM
    	{
    	public:
           int linksId;
           int linksSrc;
           int idParagraph;
    	};
    
        
    	public ref class ElementSemanticM
    	{
    		public:
                 stUniversM^ pUnivers;
                 System::String^ wsText;
                 System::String^ wsIdentifier;
                 int siIdOccurence;
                 int nuIdTypeElement;
                 int siNbChunk;
                 int nuIdParagraph;
                 int nuIdChunk;
                 int nuIdElemn;
                 int nuIdChunkType;
                 int siNbWord;
    			 int ullLemmaID;
                 enPOSM nuIdDrivingPos;
    			 int nuIdWord;
                 System::String^ wsWord;
    			 System::String^ wsLemma;
    			 System::String^ wsPronunciation;
                 int iValWord;
    			 int cExcluded;
                 int iIdDoc;
                 enPOSM iPOS;
    			 enGenderM iGender;
    			 enPersM   iPers;
    			 enNbrM    iNbr;
    			 int iStart;
    			 int iLength;
    			 int iWordOccurence;
    			 int indice;
    			 System::String^ Sujet;
    			 System::String^ listParagraph;
                 List<ElementLinksM^>^ pLink;
    	};
    
    
        public ref class SubChainM
        {
    	public:
            SubChainM() {;};
            System::String^ name;
            CObjetM^ state;
        };
    	
    	
    	public ref class CElementSemantiqueM
    	{
    	public:
    	  long idElement;
          long idSegSrc;
          int  iIdDoc;
          int  idParagraph;
          stUniversM^ pUnivers;
          List<CAnalysedChunkM^>^ pListChunk;
          enElementSemantiqueM TypeElement;
    	};
    
    	public ref class CLinguisticSegmentM
    	{
    	public:
    		System::Collections::Generic::List<CAnalysedWordM^>^  pListWord;                 //  Liste de pointeurs sur les Mots qui constituent le Segment
    		System::Collections::Generic::List<CElementSemantiqueM^>^ pListProposition;      //  Liste de pointeurs sur les Ngrams qui sont dans le Segment
    		System::Collections::Generic::List<CAnalysedChunkM^>^ pListChunk;                //  Liste de pointeurs sur les Chunks qui sont dans le Segment
    		System::Collections::Generic::List<ElementSemanticM^>^ pListPredicat;
    		System::Collections::Generic::List<ElementSemanticM^>^ pListPrecondition;
    		System::Collections::Generic::List<ElementSemanticM^>^ pListQualificatif;
    		System::Collections::Generic::List<ElementSemanticM^>^ pListUnivers;
    		System::Collections::Generic::List<QualificateurNormalizedM^>^ plistQualificateurNormalized;
    		System::Collections::Generic::List<PropositionNormalizedM^>^ pListPredicatNormalized;
    		System::Collections::Generic::List<PropositionNormalizedM^>^ pListPreconditionNormalized;
    		System::Collections::Generic::List<CObjetM^>^ plistObjectsNormalized;
    
    		CLinguisticSegmentM()
    		  {;}
    		~CLinguisticSegmentM()
    		  {;}
    	};
    
    	public ref class CAnalysedSegmentM
    	{
    	public:
    		unsigned long long          ullSegmentID;             //  Identifiant du Segment dans la base de données
    		CLinguisticSegmentM^        pLinguisticSegment;       //  Segment decomposition
    		CLayoutM^					pSegmentLayout;           //  Segment layout at the segment level only
    		short                       shSegmentCharLength;      //  Number of character in sentence
    		short                       shSegmentWordLength;      //  Number of words in sentence
    		enLanguageM                 Language;                 //  Langue du segment
    		unsigned long               ulDocPosition;            //  Segment position into the Document
    
    		CAnalysedSegmentM::CAnalysedSegmentM()
    		{
    				;
    		};
    		CAnalysedSegmentM::~CAnalysedSegmentM()
    		{
    				;
    		};
    	};
    };
    #endif

    La suite dans le prochain post


    Jean Noël Martin

    samedi 31 janvier 2015 10:07
  • suite de headers:

    Message.h
    /*******************************************************************************
    * FILE NAME: Message.h
    * PURPOSE:   This file contains the assumed message function
    * HISTORY:
    * Date        Version                   Author
    * 16/05/2003  initial version :1.0      Shridhar
    *******************************************************************************/
    #ifndef MessageH
    #define MessageH
    
    
    typedef enum
    {
      MESSAGE_ID = 0,
      MSG_DATABASE_POINTER_NOT_VALID,
      // the pointer on the mission database is not valid
      MSG_CHUNK_MATCH_SCORE_POINTER_NOT_VALID,
      // the Chunk match score with lemma class can't be instantiated
      MSG_CANT_SUPPRESS_OLD_CHUNK_LINKS_OF_SEGMENT_LINK,
      // The chunk links of the segment link can't be suppressed
      MSG_CANT_GET_CHUNKS_OF_SEGMENT,
      // the segment decompisition into chunks is not accessible
      MSG_CHUNK_LIST_EMPTY,
      // at least a chunk list empty
      MSG_UNABLE_TO_COMPUTE_CHUNK_MATCH_SCORE_WITH_LEMMA,
      // chunk match score computing according to lemma comparison doesn't work
      MSG_CANT_WRITE_CHUNK_LINK_IN_DATABASE,
      // chunk link can't be inserted in the mission database
      MSG_CANT_WRITE_LEMMA_LINK_IN_DATABASE,
      // lemma link can't be inserted in the mission database
      MSG_CANT_GET_OPTIONS,
      // unable to read option from the ini file
      MSG_INVALID_NUMBER_OF_SEGMENT_IN_ARGUMENT,
      // The number of argument in input is wrong
      MSG_CANT_GET_SEGMENT_CLUE,
      // Unable to read the segment clues in the database
      MSG_CANT_GET_CLUE_OF_ALL_SEGMENTS,
      // unable to read the clues of all required segments
      MSG_CANT_GET_SEGMENT_LAYOUT,
      // Unable to read the segment layout in the database
      MSG_CANT_GET_LAYOUT_OF_ALL_SEGMENTS,
      // unable to read the layout of all required segments
      MSG_CANT_COMPUTE_EXTERNAL_SCORE,
      // unable to compute external score
      MSG_CANT_GET_STATISTICS_OF_ALL_SEGMENTS,
      // unable to read the statistics of all required segments
      MSG_CANT_GET_SEGMENT_STATISTICS,
      // Unable to read the segment statistic in the database
      MSG_LANGUAGE_POINTER_NOT_VALID,
      // Unable to create language object
      MSG_CANT_CLASSIFY_CHUNKS_OF_SEGMENT,
      // Unable to classify the chunks of a segment
      MSG_LANGUAGE_FORBIDDEN,
      // one of the language is forbidden for the linguistic score process
      MSG_CANT_COMPUTE_CHUNK_MATCH_SCORE,
      // unable to compute chunk match score
      MSG_CANT_COMPUTE_MATCH_ZONE,
      // The match zone can't be computed waccording to lemmas number
      MSG_CANT_COMPUTE_MATCH_ZONE_SCORE,
      // unable to compute match zone score
      MSG_CANT_COMPUTE_MARK_CLUE,
      // unable to compute mark clue
      MSG_UNKNOWN_CHUNK_TYPE,
      // Unknown chunk type
      MSG_CANT_GET_CHUNK_ID_OF_SEGMENT,
      //unable to read chunk ID of the segment in the database
      MSG_CANT_GET_CHUNK_DESCRIPTION,
      //unable to read chunk descriptions in the database
      MSG_INVALID_NUMBER_OF_CHUNK_IN_INPUT,
      // The number of chunk to analyse is not correct
      MSG_CANT_GET_LEMMA_LIST_OF_CHUNK,
      // Unable to read the lemma decomposition of a chunk
      MSG_CANT_GET_LEMMA_DESCRIPTION,
      // Unable to get the description of a lemma
      MSG_CANT_CONVERT_STRING_INTO_NUMBER,
      // Unable to convert the string into a number
      MSG_CANT_SEARCH_LEMMA_LINK_FITTING_WITH_THRESHOLD,
      // Unable to search a lemma link that fits with the probability threshold
      MSG_CANT_COMPUTE_MATCHING_OF_WORD_BEGINNING,
      // Unable to compare beginning of words
      MSG_CANT_SEARCH_TRANSLATION_FOR_A_LEMMA,
      // Unable to search for some translation for a lemma
      MSG_CANT_GET_LEMMA_LINKS,
      // Unable to get lemma link in the database
      MSG_CANT_GET_LEMMA_LINK_DESCRIPTION,
      // Unable to get lemma link description in the database
      MSG_WORDS_ARE_BOTH_EMPTY,
      // The two words are both empty, the process is not valid
      MSG_CANT_REPLACE_DIACRITICS_CHARACTERS,
      // The diacritic characters can't be replaced
      MSG_CANT_GET_NGRAMS_ID,
      // Unable to get Ngram ID from the database
      MSG_BAD_VALUE_FOR_WINDOW_WIDTH_CANDIDATE_DENOMINATOR,
      // The value of m_shWindowWidthCandidateDenominatorOM is set at zero
      MSG_CANT_GET_NGRAMS_DESCRIPTIONS,
      // Unable to get the ngrams descriptions from the database
      MSG_INVALID_NGRAM_DEGREE_LIMIT_SETTINGS,
      // the limit of the min or max degree are badly defined
      MSG_POINTER_SHOULD_BE_NULL,
      // the pointer passed as input parameter should be initialized to NULL
      MSG_CANT_GET_SEGMENTS_IDS,
      // unable to read all the segment IDs of a given language
      MSG_CANT_SEARCH_NGRAM_LINK,
      // unable to compute the algorithm that search for ngram equivalent
      MSG_CANT_COMPUTE_CHI_TEST_ON_NGRAM_LINK,
      // unable to compute Chi test on a given ngram link
      MSG_CANT_SET_NGRAM_LINK,
      // unable to set an Ngram link in the database
      MSG_CANT_UPDATE_NGRAM_CLUES_IN_SEGMENTS_CONCERNED_BY_NGRAM_LINK,
      // unable to increment ngram clues in segments concerned by the ngram link
      MSG_UNKNOWN_EXCEPTION,
      // an exception throw during execution
      MSG_UNKNOWN_EXCEPTION_OPTION_LOADOPTIONS,
      // unknown exception in the loadoptions function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_GETBOOLEANVALUE,
      // unknown exception in the getbooleanvalue function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_GETUINTVALUE,
      // unknown exception in the getuintvalue function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_GETSHORTVALUE,
      // unknown exception in the getshortvalue function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_GETSTRINGVALUE,
      // unknown exception in the getstringvalue function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_GETLISTOFVALUE,
      // unknown exception in the getlistvalue function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_SETBOOLEANVALUE,
      // unknown exception in the setbooleanvalue function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_SETUINTVALUE,
      // unknown exception in the setbooleanvalue function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_SETSTRINGVALUE,
      // unknown exception in the setbooleanvalue function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_SETLISTOFVALUE,
      // unknown exception in the setlistvalue function in option manager
      MSG_UNKNOWN_EXCEPTION_OPTION_SAVEOPTIONS,
      // unknown exception in the saveoptions function in option manager
      MSG_LOCAL_SERVER_NOT_EXIST,
      // local server isn't connected
      MSG_CANT_OPEN_DATABASE,
      // unable to open the database
      MSG_CANT_OPEN_ALIGNMENT_DATABASE,
      //unable to open the alignment database
      MSG_CANT_GET_DATABASE_FILENAME,
      // unable to get the database filename
      MSG_CANT_DISPLAY_OPENING_ALIGNMENT_DATABASE_MMI,
      // unable to open the alignment database opening MMI
      MSG_CANT_DISPLAY_SEGMENTS,
      // unable to display segments
      MSG_CANT_CLOSE_DATABASE,
      //unable to close the alignment database opening MMI
      MSG_CANT_ACTIVATE_ITEMS_AND_BUTTONS,
      //unable to activate items and buttons
      MSG_CANT_GET_DATA_IN_OPEN_DOCUMENTS_PAIRS_MMI,
      // unable to get data in the open document pairs MMI
      MSG_CANT_ALIGN_DOCUMENTS_PAIRS,
      // Begin the Alignment documents pair
      MSG_BEGIN_ALIGNMENT_DOCUMENTS_PAIR,
      // End of the Alignment documents pair
      MSG_END_ALIGNMENT_DOCUMENTS_PAIR,
      // unable to align documents pairs
      MSG_CANT_OPEN_WAITING_MESSAGE_MMI,
      // unable to open waiting message MMI
      MSG_CANT_CLOSE_WAITING_MESSAGE_MMI,
      // unable to close waiting message MMI
      MSG_CANT_FETCH_SECTIONS_IN_INIFILE,
      // unable to fetch sections in the ini file
      MSG_CANT_FETCH_KEYS_AND_VALUES_IN_INIFILE,
      // unable to fetch keys and corresponding values in the ini file
      MSG_CANT_GET_STRING_VALUE,
      //unable to get string value
      MSG_CANT_GET_UINT_VALUE,
      //unable to get uint value
      MSG_CANT_GET_BOOLEAN_VALUE,
      //unable to get boolean value
      MSG_CANT_WRITE_BOOLEAN_VALUE,
      //unable to write boolean value,
      MSG_CANT_WRITE_UINT_VALUE,
      //unable to write uint value,
      MSG_CANT_WRITE_STRING_VALUE,
      //unable to write string value,
      MSG_CANT_SET_STRING_VALUE,
      //unable to set string value
      MSG_CANT_SET_UINT_VALUE,
      //unable to set uint value
      MSG_CANT_SET_BOOLEAN_VALUE,
      //unable to set boolean value
      MSG_CANT_WRITE_STRING_IN_INIFILE,
      //unable to write the options string in the ini file
      MSG_CANT_GET_STRING_LIST,
      //unable to get the options string list
      MSG_CANT_GET_CHUNKS_DESCRIPTION_OF_SEGMENT,
      //unable to get chunks description of the segment
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_DESCRIPTIONCHUNKSOFLANGUAGE,
      //unknown exception in the descriptionchunksoflanguage function in ChunkViewer manager
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_EMPTYGRID,
      //unknown exception in the emptygrid function in ChunkViewer manager
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_GETCOORDINATESFROMID,
      //unknown exception in the getcoordinatesfromid function in ChunkViewer manager
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_GETIDFROMCOORDINATES,
      //unknown exception in the getidfromcoordinates function in ChunkViewer manager
      MSG_CANT_GET_COORDINATES_FROM_ID,
      // unable to get the row and column coordinates of the chunk by the ID of the chunk
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_GETSTATUS,
      //unknown exception in the getstatus function in ChunkViewer manager
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_HIDEGRID,
      //unknown exception in the hidegrid function in ChunkViewer manager
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_MOVECLOSERCHUNKSOFLINKS,
      //unknown exception in the movecloserchunksoflinks function in ChunkViewer manager
      MSG_CANT_GET_ID_FROM_COORDINATES,
      //unable to get the ID of the chunk from the row and column coordinates of the chunk
      MSG_CANT_GET_STATUS,
      //unable to get the status of the chunk
      MSG_CANT_MANAGE_CHUNK_SELECTING,
      //unable to manage the chunk selecting
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_ONSELECTCHUNK,
      //unknown exception in the onselectchunk function in ChunkViewer manager
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_SETSTATUS,
      //unknown exception in the setstatus function in ChunkViewer manager
      MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_SHOWGRID,
      //unknown exception in the showgrid function in ChunkViewer manager
      MSG_CANT_DISPLAY_CRITERIA_MMI,
      //unable to display the criteria MMI
      MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_EDITCRITERIA,
      //unknown exception in the editcriteria function in CriteriaParameters manager
      MSG_CANT_DISPLAY_PARAMETERS_MMI,
      //unable to display parameters MMI
      MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_EDITPARAMETERS,
      //unknown exception in the EditParameters function in CriteriaParameters manager
      MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_DEFAULTCRITERIAVALUES,
      //unknown exception in the DefaultCriteriaValues function in CriteriaParameters manager
      MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_DEFAULTPARAMETERSVALUES,
      //unknown exception in the DefaultParametersValues function in CriteriaParameters manager
      MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_APPLYCRITERIA,
      //unknown exception in the editcriteria function in CriteriaParameters manager
      MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_APPLYPARAMETERS,
      //unknown exception in the editcriteria function in CriteriaParameters manager
      MSG_CANT_CLOSE_CRITERIA_MMI,
      //unable to close the criteria MMI
      MSG_CANT_CLOSE_DISPLAY_PARAMETERS_MMI,
      //unable to close the display parameters MMI
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_ACTIVATEITEMSANDBUTTONS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_OPENALIGNMENTDATABASE,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_DOCUMENTS_PAIRS_PROCESSING,
      //unable to manage the documents pairs processing
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_PROCESSDOCUMENTSPAIRS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_EQUIVALENTS_EXTRACTION,
      //unable to manage the equivalents extraction
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EXTRACTSEGMENTSANDCHUNKSEQUIVALENTS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_CHUNKS_EQUIVALENTS_EXTRACTION,
      //unable to manage the chunks equivalents extraction
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EXTRACTCHUNKSEQUIVALENTS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_WORK_PROGRESS_ESTIMATION,
      //unable to manage the work progress estimation
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_WORKPROGRESS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_EDIT_PARAMETERS,
      //unable to manage the edit parameters
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EDITPARAMETERS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_EDIT_CRITERIA,
      //unable to manage the edit criteria
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EDITCRITERIA,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_SEGMENTS_VIEW,
      //unable to manage the segments view
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWALLSEGMENTS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWNONALIGNEDSEGMENTS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_CHUNKS_VIEW,
      //unable to manage the chunks view
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWALLCHUNKS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWNONALIGNEDCHUNKS,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_CLOSE_PROJECT,
      //unable to close the project
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_CLOSEPROJECT,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_MANAGE_QUIT,
      //unable to manage the quit
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_QUIT,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_OPEN_ALIGNEMENT_DATABASE_MMI,
      //unable to open the alignment database
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_GETALIGNEMENTDATABASEFILE,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_OPEN_NEW_ALIGNEMENT_DATABASE_MMI,
      //unable to open the new alignment database
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_GETDOCUMENTSPAIRFILES,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_OPENQUITCONFIRMATION,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_OPENWAITINGMESSAGEWINDOW,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_CLOSEWAITINGMESSAGEWINDOW,
      //unknown exception in the activateitemsandbuttons function in MenuToolBar manager
      MSG_CANT_GET_SEGMENT_STATUS,
      //unable to get segment status
      MSG_CANT_MANAGE_SEGMENT_SELECTING,
      //unable to manage the segment selecting
      MSG_CANT_GET_SEGMENT_DESCRIPTION,
      //unable to get the segment description
      MSG_CANT_GET_SEGMENT_CHUNK_DESCRIPTION,
      //unable to get the segment chunk description
      MSG_CANT_FIND_TARGET_SEGMENT_DESCRIPTION_OF_LINK,
      //unable to find the target segment description of the segment link
      MSG_CANT_FIND_TARGET_CHUNK_DESCRIPTION_OF_LINK,
      //unable to find the target chunk description of the chunk link
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_SETFOCUSONSEGMENTACCORDINGTONUMBER,
      //unknown exception in the setfocusonsegmentaccordingtonumber function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_ONSELECTSEGMENT,
      //unknown exception in the onselectsegment function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_DISPLAYSEGMENTSOFLANGUAGE,
      //unknown exception in the displaysegmentoflanguage function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_MOVECLOSERSEGMENTSOFLINKS,
      //unknown exception in the moveclosersegmentsoflinks function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_SETSTATUS,
      //unknown exception in the setstatus function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GIVEINITIALPOSITION,
      //unknown exception in the giveinitialposition function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GETIDFROMCOORDINATES,
      //unknown exception in the getidfromcoordinates function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GETCOORDINATESFROMID,
      //unknown exception in the getcoordinatesfromid function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GETSTATUS,
      //unknown exception in the getstatus function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_SHOWGRID,
      //unknown exception in the showgrid function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_HIDEGRID,
      //unknown exception in the hidegrid function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_EMPTYGRID,
      //unknown exception in the emptygrid function in SegmentViewer manager
      MSG_UNKNOWN_EXCEPTION_WORKPROGRESSVIEWER_DISPLAYWORKPROGRESS,
      //unknown exception in the displayworkprogress function in WorkProgressViewer manager
      MSG_UNKNOWN_EXCEPTION_WORKPROGRESSVIEWER_CLOSE,
      //unknown exception in the close function in WorkProgressViewer manager
      MSG_CANT_GET_TOTAL_NUMBER_OF_SOURCE_SEGMENTS,
      //unable to get total number of source segments
      MSG_CANT_GET_TOTAL_NUMBER_OF_TARGET_SEGMENTS,
      //unable to get total number of target segments
      MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETTOTALNUMBEROFSEGMENTS,
      //unknown exception in the gettotalnumberofsegments function in WorkProgress manager
      MSG_CANT_GET_NUMBER_OF_ALIGNED_SEGMENTS,
      //unable to get number of aligned segments
      MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETNUMBEROFALIGNEDSEGMENTS,
      //unknown exception in the getnumberofalignedsegments function in WorkProgress manager
      MSG_CANT_GET_TOTAL_NUMBER_OF_SOURCE_CHUNKS,
      //unable to get total number of source chunks
      MSG_CANT_GET_TOTAL_NUMBER_OF_TARGET_CHUNKS,
      //unable to get total number of target chunks
      MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETTOTALNUMBEROFCHUNKS,
      //unknown exception in the gettotalnumberofchunks function in WorkProgress manager
      MSG_CANT_GET_NUMBER_OF_ALIGNED_CHUNKS,
      //unable to get number of aligned chunks
      MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETNUMBEROFALIGNEDCHUNKS,
      //unknown exception in the getnumberofalignedchunks function in WorkProgress manager
      MSG_CANT_DISCONNECT_SERVER,
      //unable to disconnect the server
      MSG_CANT_CONNECT_SERVER,
      //unable to disconnect the server
      MSG_UNKNOWN_EXCEPTION_SOFTWAREMANAGER_TERMINATION,
      //unknown exception in the termination function in Software manager
      MSG_UNKNOWN_EXCEPTION_SOFTWAREMANAGER_INITIALIZATION,
      //unknown exception in the initialization function in Software manager
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEALIGNMENTDATABASEOPENING,
      //unknown exception in the managealignmentdatabaseopening function in Aligner manager
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEDOCUMENTSPAIRSPROCESSING,
      //unknown exception in the manageadocumentspairsprocessing function in Aligner manager
      MSG_CANT_FETCH_NUMBER_OF_ALIGNED_SEGMENTS,
      //unable to fetch number of aligned segments
      MSG_CANT_DISPLAY_WORK_PROGRESS,
      //unable to display the work progress MMI
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECHUNKSELECTING,
      //unknown exception in the managechunkselecting function in Aligner manager
      MSG_CANT_EDIT_PARAMETERS,
      //unable to edit parameters
      MSG_CANT_APPLY_PARAMETERS_CHANGES,
      //unable to apply parameters changes
      MSG_CANT_STORE_PARAMETERS_VALUES_IN_MEMORY_AND_INI_FILE,
      //unable to store parameters values in memory and ini file
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEEDITPARAMETERS,
      //unknown exception in the manageeditparameters function in Aligner manager
      MSG_CANT_EDIT_CRITERIA,
      //unable to edit criteria
      MSG_CANT_APPLY_CRITERIA_CHANGES,
      //unable to apply criteria changes
      MSG_CANT_STORE_CRITERIA_VALUES_IN_MEMORY_AND_INI_FILE,
      //unable to store criteria values in memory and ini file
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEEDITCRITERIA,
      //unknown exception in the manageeditcriteria function in Aligner manager
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGESEGMENTSVIEW,
      //unknown exception in the managesegmentsview function in Aligner manager
      MSG_CANT_EMPTY_CHUNK_GRID,
      //unable to empty the chunk grid
      MSG_CANT_GET_SEGMENT_ID_FROM_COORDINATES,
      //unable to get segment ID from coordinates
      MSG_CANT_GET_LINK_ID_OF_SEGMENT,
      //unable to get link ID of segment
      MSG_CANT_GET_LINK_ID_OF_CHUNK_OF_SEGMENT,
      //unable to get link ID of chunk of the segment
      MSG_CANT_GET_SEGMENT_LINK_DESCRIPTION,
      //unable to get segment link description
      MSG_CANT_DISPLAY_CHUNKS_OF_SEGMENTS,
      //unable to display chunks of segments
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECHUNKSVIEW,
      //unknown exception in the managechunksview function in Aligner manager
      MSG_CANT_EMPTY_SEGMENT_GRID,
      //unable to empty the segment grid
      MSG_CANT_HIDE_SEGMENT_GRID,
      //unable to hide the segment grid
      MSG_CANT_HIDE_CHUNK_GRID,
      //unable to hide the chunk grid
      MSG_CANT_OPEN_QUIT_CONFIRMATION,
      //unable to open the quit confirmation MMI
      MSG_CANT_STOP_MEMORIA_MANAGER,
      //unable to stop the application
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEQUIT,
      //unknown exception in the managequit function in Aligner manager
      MSG_CANT_MAKE_GLOBAL_PAIR_ALIGNMENT_PROCESS,
      //unable to make the global pair alignment process
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEQUIVALENTSEXTRACTION,
      //unknown exception in the managequivalentsextraction function in Aligner manager
      MSG_CANT_GIVE_SEGMENT_INITIAL_POSITION,
      //unable to give the initial position of the segment
      MSG_CANT_GET_ALL_SOURCE_SEGMENTS_IDS,
      //unable to get all source segments IDs
      MSG_CANT_GET_NON_ALIGNED_SOURCE_SEGMENTS_IDS,
      //unable to get non aligned source segments IDs
      MSG_CANT_FILL_SEGMENT_GRID,
      //unable to fill segment grid
      MSG_CANT_FILL_CHUNK_GRID,
      //unable to fill chunk grid
      MSG_CANT_GET_ALL_TARGET_SEGMENTS_IDS,
      //unable to get all target segments IDs
      MSG_CANT_GET_NON_ALIGNED_TARGET_SEGMENTS_IDS,
      //unable to get non aligned target segments IDs
      MSG_CANT_DISPLAY_TARGET_SEGMENT_OF_LANGUAGE,
      //unable to display target segment of language
      MSG_CANT_MOVE_CLOSER_SEGMENTS_OF_LINKS,
      //unable to move closer segments of links
      MSG_UNKNOWN_EXCEPTION_ALIGNER_DISPLAYSEGMENTS,
      //unknown exception in the displaysegments function in Aligner manager
      MSG_CANT_FIND_SEGMENT_LINK_ID_FROM_SEGMENT_ID,
      //unable to find segment link ID from segment ID
      MSG_CANT_MAKE_SIMPLE_PAIR_ALIGNMENT_PROCESS,
      //unable to make simple pair alignment processus
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECHUNKSEQUIVALENTSEXTRACTION,
      //unknown exception in the managechunksequivalentsextraction function in Aligner manager
      MSG_CANT_GET_ALL_SOURCE_CHUNKS_IDS,
      //unable to get all source chunks IDs
      MSG_CANT_GET_NON_ALIGNED_SOURCE_CHUNKS_IDS,
      //unable to get non aligned chunks IDs
      MSG_CANT_DISPLAY_SOURCE_CHUNKS_OF_LANGUAGE,
      //unable to display source chunks of language
      MSG_CANT_GET_ALL_TARGET_CHUNKS_IDS,
      //unable to get all target chunks IDs
      MSG_CANT_GET_NON_ALIGNED_TARGET_CHUNKS_IDS,
      //unable to get non aligned target chunks IDs
      MSG_CANT_DISPLAY_TARGET_CHUNKS_OF_LANGUAGE,
      //unable to display target chunks of language
      MSG_CANT_GET_CHUNK_LINKS_IDS_FROM_SOURCE_AND_TARGET_SEGMENTS,
      //unable to get chunk links IDs from source and target segments
      MSG_CANT_GET_CHUNK_LINK_DESCRIPTION,
      //unable to get chunk link description
      MSG_CANT_MOVE_CLOSER_CHUNKS_OF_LINKS,
      //unable to move closer chunks of links
      MSG_UNKNOWN_EXCEPTION_ALIGNER_DISPLAYCHUNKSOFSEGMENTS,
      //unknown exception in the displaychunksofsegment function in Aligner manager
      MSG_CANT_ANALYSE_SOURCE_DOCUMENT,
      //unable to analyse the source document
      MSG_CANT_ANALYSE_TARGET_DOCUMENT,
      //unable to analyse the target document
      MSG_UNKNOWN_EXCEPTION_ALIGNER_ALIGNDOCUMENTSPAIRS,
      //unknown exception in the aligndocumentspairs function in Aligner manager
      MSG_CANT_FETCH_TOTAL_NUMBER_OF_SEGMENTS,
      //unable to fetch the total number of segments
      MSG_CANT_FETCH_TOTAL_NUMBER_OF_CHUNKS,
      //unable to fetch the total number of chunks
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGESEGMENTSELECTING,
      //unknown exception in the managesegmentselecting function in Aligner manager
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEWORKPROGRESSESTIMATION,
      //unknown exception in the manageworkprogressestimation function in Aligner manager
      MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECLOSEPROJECT,
      //unknown exception in the managecloseproject function in Aligner manager
      MSG_CANCEL,
      //query cancelled
      MSG_DEFAULT_VALUE_TAKEN,
      // the value was not in the ini file, default value taken
    
    
    
    la suite dans le prochain Post


    Jean Noël Martin

    samedi 31 janvier 2015 10:15
  • suite de Message

      //---------------------------------------------------------------
      //              ANALYSER  ERROR MESSAGES
      //---------------------------------------------------------------
      MSG_DOCUMENT_POINTER_NULL,
      // pointer on Document Manager is null
      MSG_PARSER_POINTER_NULL,
      // pointer on Parser Manager is null
      MSG_CHUNKER_POINTER_NULL,
      // pointer on Chunker is null
      MSG_NGRAMER_POINTER_NULL,
      // pointer on Ngramer is null
      MSG_SEGMENTATION_POINTER_NULL,
      // pointer on Segmentation is null
      MSG_COMPUTING_FOR_ALIGNMENENT_POINTER_NULL,
      // pointer on Computing For Alignment is null
      MSG_ANNEX_FUNCTION_POINTER_NULL,
      // pointer on Annex Function is null
      MSG_SEGMENTATION_CANNOT_SPLIT_INTO_SEGMENT,
      // unable to split into segment the bloc of text
      MSG_SEGMENTATION_CANNOT_ADD_SPACE_IN_SEGMENT,
      // unable to add space in list of word from class CSegment
      MSG_COMPUTING_FOR_ALIGNMENENT_CANNOT_MAKE_COMPUTE,
      // unable to make compute for alignment
      MSG_CHUNKER_CANNOT_SPLIT_INTO_CHUNK,
      // unable to split into chunk
      MSG_NGRAMER_CANNOT_SEARCH_NGRAM,
      // unable find Ngram in the text
      MSG_DOCUMENT_CANNOT_READ_BLOC,
      // unable to read a bloc of text (problem with Word API)
      MSG_PARSER_CANNOT_PARSE_BLOC,
      // unable to Parse a bloc of text (problem with Xelda API)
      MSG_NGRAMER_CANNOT_DELETE_NGRAM_DATABASE,
      // unable to delete Ngram in Mission Database
      MSG_ANNEX_FUNCTION_CANNOT_EXCLUDE_LEM_DATABASE,
      // unable to exclude LEMMA in Mission Database
      MSG_DOCUMENT_CANNOT_STOP_READER,
      // unable to stop the Reader (problem with Word API)
      MSG_DOCUMENT_CANNOT_CLOSE_DOCUMENT,
      // unable to close a document
      MSG_DOCUMENT_THERE_IS_NO_BLOC,
      // There is no bloc of text in the document (pBloc is null)
      MSG_DOCUMENT_NOT_ABLE_TO_OPEN_DOCUMENT,
      // unable to open the document
      MSG_DOCUMENT_NOT_ABLE_TO_START_READER,
      //  unable to start the Reader
      MSG_DATABASE_CANNOT_ADD_SEGMENT,
      // unable to add a segment in Mission Database
      MSG_OPTION_MANAGER_CANNOT_LOAD,
      // unable to load information which are in init file (Option Manager problem)
      MSG_POINTER_SEGMENT_NULL,
      // pointer on CSegment is null (cannot create a segment)
      MSG_MISSION_DATABASE_CANNOT_ERASE_NGRAMS,
      // unable to erase Ngrams in Mission Database
      MSG_DATABASE_CANNOT_EXCLUDE_LEM,
      // unable to exclude LEMMA in Mission Database
      MSG_OPTION_MANAGER_CANNOT_LOAD_INFO,
      //unable to load information which are in init file (Option Manager problem)
      MSG_CANT_INITIALIZE_READING,
      // Unable to initialize the reading of the document
      MSG_CANT_GET_CASE_PROPERTY,
      // Unable to get the case of a bloc of text
      MSG_CANT_GET_FONT_PROPERTIES,
      // Unable to get the font properties
      MSG_CANT_GET_BOLD_PROPERTY,
      // Unable to get the bold property
      MSG_CANT_GET_ITALIC_PROPERTY,
      // Unable to get the italic property
      MSG_CANT_GET_UNDERLINE_PROPERTY,
      // Unable to get the underline property
      MSG_CANT_GET_FONT_SIZE_PROPERTY,
      // Unable to get the font size property
      MSG_CANT_GET_FONT_NAME_PROPERTY,
      // Unable to get the font name property
      MSG_CANT_GET_FOREGROUND_COLOR_PROPERTY,
      // Unable to get the foreground color property
      MSG_CANT_GET_BACKGROUND_COLOR_PROPERTY,
      // Unable to get the background color property
      MSG_CANT_DETERMINE_IF_PARAGRAPH_IS_IN_ARRAY,
      // Unable to know if the paragraph is a part of an array
      MSG_CANT_START_WORD_API,
      // Unable to start the word API
      MSG_CANT_STOP_WORD_API,
      // Unable to stop the word API
      MSG_CANT_OPEN_DOCUMENT,
      //  Unable to open the document %s (std::wstring wsFullPathName)
      MSG_CANT_CLOSE_DOCUMENT,
      // Unable to close the document
      MSG_CANT_GO_TO_NEXT_BLOC,
      // Unable to read the following paragraph of the text
      MSG_CANT_GET_PARAGRAPH_LAYOUT,
      // Unable to get the layout of the paragraph %s (std::wstring wsText)
      MSG_CANT_CREATE_WORD_READER,
      // Unable to create the Word Reader
    
    
      //------------------------------------------------------------------------
      //                  ALIGNMENT
      //------------------------------------------------------------------------
    
      MSG_GRAMS_OCCURRENCE_POINTER_NOT_VALID,
      // Pointer on grams occurrence class not accessible
      MSG_ALIGNMENT_SEGMENT_BETWEEN_BOUNDS_POINTER_NOT_VALID,
      // Pointer on alignment between bounds class not accessible
      MSG_CANT_GET_SOURCE_SEGMENT_NUMBER,
      // Impossible d'obtenir le nombre de segment source dans la Database
      MSG_CANT_GET_TARGET_SEGMENT_NUMBER,
      // Impossible d'obtenir le nombre de segment target dans la Database
      MSG_CANT_EXECUTE_NGRAMS_ALIGNMENT,
      // Impossible d'obtenir le nombre de segment target dans la Database
      MSG_CANT_ALIGN_WITH_WINDOWS,
      // Impossible d'aligner les segments entre ceux déjà alignés
      MSG_CANT_ALIGN_WITH_ANCHORS,
      //Impossible d'aligner les segments à "Clues"
      MSG_CANT_ALIGN_BY_STATISTIC,
      //Impossible d'aligner par les elements statistics
      MSG_CANT_GET_SOURCE_SEGMENT_ID_IN_MISSION_DATABASE,
     //Impossible d'obtenir les segments sources
      MSG_CANT_GET_TARGET_SEGMENT_ID_IN_MISSION_DATABASE,
     //Impossible d'obtenir les segments target
      MSG_CANT_USED_CANDIDATE_FUNCTION,
      // Impossible d'utiliser Candidate function
      MSG_CANT_GET_LIST_OF_TARGET_SEGMENT_ID,
      // Can't have the list of segment id with a level of anchors from Mission Databse
      MSG_CANT_GET_LIST_OF_SOURCE_SEGMENT_ID,
      // Can't have the list of segment id with a level of anchors from Mission Databse
      MSG_CANT_GET_LIST_OF_SOURCE_SEGMENT_ALIGNED,
      // list of segments already aligned  not accessible
      MSG_CANT_GET_LIST_OF_TARGET_SEGMENT_ALIGNED,
      // list of segments already aligned not accessible
      MSG_CANT_GET_LIST_OF_SOURCE_SEGMENT_NOT_ALIGNED,
      // list of segment between aligned ones not accessible
      MSG_CANT_GET_LIST_OF_TARGET_SEGMENT_NOT_ALIGNED,
      // list of segment between aligned ones not accessible
      MSG_CANT_EXECUTE_SECURE_ANCHORS,
      //    Impossible d'executer secure Anchors
      MSG_CANT_ALIGN_BETWEEN_BOUNDS,
      // Impossible de réaliser la fonction Secure Anchors
      MSG_CANT_EXECUTE_SECURE_ANCHORS_WITH_CANDIDATE,
      // Impossible de réaliser la fonction Secure Anchors dans candidate
      MSG_CANT_INSERT_SEGMENT_RESULT_IN_MISSION_DATABASE,
      // Impossible d'inserer les element du segment dans la base
      MSG_CANT_EXECUTE_LINGUISTIC_SCORE,
      // Impossible d'executer linguistic score
      MSG_CANT_EXECUTE_SCTRUCTURE_SCORE,
      // Impossible d'executer structure score
      MSG_CANT_INSERT_SEGMENT_IN_DATABASE,
      // Impossible d'inserer les segments dans la base avec la fonction potentiel match
      MSG_CANT_INSERT_CHUNK_IN_DATABASE,
      // Impossible d'inserer les chunks dans la base avec la fonction potentiel match
      MSG_CANT_INSERT_LEMMA_IN_DATABASE,
      // Impossible d'inserer les Lmma dans la base avec la fonction potentiel match
      MSG_MISSION_DATABASE_POINTER_NOT_VALID,
      // the pointer on the mission database is not valid
      MSG_STRUCTURE_SEGMENT_ALIGNMENT_POINTER_NOT_VALID,
      // the pointer on the structure segment alignment class is not valid
      MSG_LINGUISTIC_SEGMENT_ALIGNMENT_POINTER_NOT_VALID,
      // the pointer on the linguistic segment alignment class is not valid
      MSG_POINTER_OF_LINGUISTIC_RESULT_UNABLE,
      // the pointer on the linguistic segment alignment result is not valid
      MSG_UNABLE_TO_GET_LINGUISTIC_RESULT,
      // the pointer on the linguistic segment alignment result is not valid
      MSG_UNABLE_TO_GET_STRUCTURAL_RESULT,
      // the pointer on the structural segment alignment result is not valid
      MSG_UNABLE_TO_INSERT_SEGMENT_LINK,
      // Impossible d'insérer dans la base de donnée
      MSG_POINTER_OF_STRUCTURAL_RESULT_UNABLE,
      // the pointer on the structural segment alignment result is not valid
      MSG_ERROR_MISSION_DATABASE_CANNOT_CREATE_LEMMA,
      // Error cannot create lemma in Mission Database
      MSG_ERROR_MISSION_DATABASE_CANNOT_SET_LEMMA_LINK,
      // Error cannot set Lemma Link in Mission Database
      MSG_ERROR_PARSER_MANAGER_CANNOT_GET_TRANSLATION,
      // Error cannot get translation of Lemma with Parser Manager
      MSG_ERROR_MISSION_DATABASE_CANNOT_GET_LEMMA_DESCRIPTION,
      // Error cannot get Lemma description in Mission Database
      MSG_ERROR_MISSION_DATABASE_CANNOT_GET_LIST_LEMMA_ID,
      // Error cannot get Lemma identifiants list in Mission Database
      MSG_ERROR_MISSION_DATABASE_POINTER_NULL,
      // Error Mission Database pointer null
      MSG_INVALID_WINDOW_WIDTH_CANDIDATE_DENOMINATOR_SETTINGS,
      // Bad setting for the WINDOW_WIDTH_CANDIDATE_DENOMINATOR settings of the CGRAMS_OCCURRENCE section
      MSG_GRAMS_OCCURENCE_POINTER_NOT_VALID,
      //The pointer on GramOccurence is not valid
      MSG_SEARCH_TRANSLATION_POINTER_NOT_VALID,
      //The pointer on SearchTranslation is not valid
      MSG_CANT_RESET_NGRAMS_CLUES_IN_ALL_SEGMENTS,
      //Can't reset NGrams Clues
      MSG_CANT_REMOVE_OLD_SEGMENT_LINKS,
      //Can't remove old segment links
      MSG_CANT_GET_ALL_SEGMENTS_IDS,
      //Can't get segment IDs
      MSG_CANT_COMPUTE_LINGUISTIC_SCORE_ON_SEGMENT_LINK,
      //Can't compute linguistic score
      MSG_CANT_COMPUTE_STRUCTURAL_SCORE_ON_SEGMENT_LINK,
      //Can't compute structural score
      MSG_CANT_SELECT_SEGMENTS_TO_ALIGN_ACCORDING_TO_CLUES,
      //Can't select segment to align according clues
      MSG_CANT_COMPUTE_NGRAMS_CLUES,
      //Can't compute NGram clues
      MSG_CANT_SET_TRANSLATION_FOR_LEMMAS,
      //Can't set translation of lemmas
      MSG_CANT_SET_SEGMENT_LINK_IN_DATABASE,
      //Can't set segment link in DB
      MSG_CANT_SET_CHUNK_LINK_IN_DATABASE,
      //Can't set chunk link in DB
      MSG_CANT_SET_LEMMA_LINK_IN_DATABASE,
      //Can't set lemma link in DB
      MSG_ERROR_FOR_NUMBER_CLUE,
      //Error for Number Clue
      MSG_ERROR_FOR_NGRAM_CLUE,
      // NGram
      MSG_ERROR_FOR_INTERNAL_CLUE,
      // Internal
      MSG_ERROR_FOR_EXTERNAL_CLUE,
      // External
      MSG_ERROR_CHECKING_POSITION,
      //Error Checking position
      MSG_CANT_UPDATE_SEGMENT_STATUS,
      //Unable to update segment status
      MSG_CANT_UPDATE_CHUNK_STATUS,
      //Unable to update chunk status
      MSG_PROBLEM_GETTING_ELEMENT_DESCRIPTION,
      //Problem getting element description
      MSG_ERROR_FINDING_LINK,
      //Error finding link
      MSG_ERROR_GETTING_LINK_DESCRIPTION,
      //error getting link description
      MSG_LIST_MUST_BE_OF_SAME_SIZE,
      //List must be of the same size
      MSG_CANT_ALIGN_WINDOW,
      //unable to align window
      MSG_CANT_COMPUTE_STATISTIC_SCORE_ON_SEGMENT_LINK,
      //Can't compute statistic score
      MSG_WRONG_ALIGNMENT_TYPE,
      // the alignment type is wrong
      MSG_CANT_GET_SEGMENT_LINK_IN_DATABASE,
      //Can't get segment link in DB
    	MSG_CANT_ALLOCATE_MATRIX,
    	//Can't allocate memory for the Matrix
      MSG_LEMMA_SCORE_POINTER_NOT_VALID,
      //The pointer on Lemma Score is not valid
    	MSG_CANT_COMPUTE_LEMMA_SCORE,
    	//Unable to compute the lemma score
    	MSG_CANT_GET_LIST_OF_LEMMA_DESCRIPTION,
    	//Unable to get the list of lemma description for a given segment
    	MSG_CANT_GET_NUMBERS,
    	//Can't get numbers in database
    	MSG_CANT_GET_NGRAMS,
    	//Can't get ngrams in database
    	MSG_CANT_GET_NGRAMS_LINK,
    	//Can't get ngrams link in database
    
    
    
      //------------------------------------------------------------------------
      //                  DATABASE
      //------------------------------------------------------------------------
      MSG_TSQLCONNECTION_POINTER_NOT_VALID,
      // the pointer on the TSQLConnection object is not valid
      MSG_TSQLQUERY_POINTER_NOT_VALID,
      // the pointer on the TSQLCQuery object is not valid
      MSG_TSQLCONNECTION_POINTER_NOT_NULL,
      // the pointer on the TSQLConnection object is not null
      MSG_TSQLQUERY_POINTER_NOT_NULL,
      // the pointer on the TSQLCQuery object is not null
      MSG_SERVER_IS_ALREADY_CONNECTED,
      // the server is already connected
      MSG_SERVER_IS_NOT_CONNECTED,
      // the server is not connected
      MSG_CANT_CONNECT_DATABASE,
      // the connection of the database has failed
      MSG_CANT_DISCONNECT_DATABASE,
      // the disconnection of the database has failed
      MSG_DATABASE_IS_ALREADY_CONNECTED,
      // the database is already connected
      MSG_DATABASE_IS_NOT_CONNECTED,
      // the database is not connected
      MSG_CANT_CREATE_DATABASE,
      // the database creation request has failed
      MSG_CANT_DELETE_DATABASE,
      // the database deletion request has failed
      MSG_CANT_ATTACH_DATABASE,
      // the database attachment has failed
      MSG_FILE_ALREADY_EXISTS,
      // the specified file already exists
      MSG_FILE_DOESNT_EXIST,
      // the specified file doesn't exist
      MSG_CANT_EXECUTE_SELECT_REQUEST,
      // the select request exection has failed
      MSG_CANT_EXECUTE_REQUEST,
      // the request execution has failed
      MSG_CANT_EXECUTE_SQL_SCRIPT,
      // the sql script execution has failed
      MSG_CANT_START_TRANSACTION,
      // the start transaction has failed
      MSG_CANT_COMMIT_TRANSACTION,
      // the transaction commit has failed
      MSG_CANT_ROLLBACK_TRANSACTION,
      // the transaction rollback has failed
      MSG_TRANSACTION_ALREADY_IN_PROGRESS,
      // a transaction is already in progress
      MSG_NO_TRANSACTION_IN_PROGRESS,
      // no transaction is in progress
      MSG_TSQLQUERY_IS_NOT_OPEN,
      // the TSQLQuery dataset is not open
      MSG_HIDDB_CONVERSION_ERROR,
      // the hiddb conversion has failed
      MSG_INTEGER_CONVERSION_ERROR,
      // the integer conversion has failed
      MSG_WIDESTRING_CONVERSION_ERROR,
      // the widestring conversion has failed
      MSG_CANT_CREATE_CONNECTION_COMPONENTS,
      // an error occured when creation connection components
      MSG_SELECT_RESULT_IS_NULL,
      // the result of a select request is null
      MSG_MORE_THAN_ONE_LEMMA_LINK_FOUND,
      // more than one lemma link is found
      MSG_CANT_MOVE_CHUNK,
      // the chunk can't be moved
      MSG_CANT_MOVE_SEGMENT,
      // the segment can't be moved
      MSG_CANT_GET_CHUNK_IDS_OF_SEGMENT,
      // no chunk ids for a segment is found
      MSG_CANT_FIND_TCLUES_OF_SEGMENT,
      // the segment clues is not found
      MSG_CANT_GET_NGRAM_DESCRIPTION,
      // the ngram description is not found
      MSG_CANT_CREATE_SEGMENT,
      // the segment can't be created
      MSG_CANT_GET_LIST_OF_LEMMA_DESCRIPTION_FROM_SEGMENT,
      // the list of lemma description is not found
    
      //------------------------------------------------------------------------
      //                  PARSER
      //------------------------------------------------------------------------
      MSG_PARSE_ERROR,
      // Error during Xelda Parsing
      MSG_ERROR_AT_PARSER_OPENING,
      // Error during Xelda opening
    
      NUMBER_OF_MESSAGES,
    } message_id;
    
    const wchar_t MSG_DATABASE_POINTER_NOT_VALID_TXT[] ={L"The pointer on the mission database is not valid\n"};
    const wchar_t MSG_CHUNK_MATCH_SCORE_POINTER_NOT_VALID_TXT[] ={L"the Chunk match score with lemma class can't be instantiated\n"};
    const wchar_t MSG_CANT_SUPPRESS_OLD_CHUNK_LINKS_OF_SEGMENT_LINK_TXT[] ={L"The chunk links of the segment link can't be suppressed\n"};
    const wchar_t MSG_CANT_GET_CHUNKS_OF_SEGMENT_TXT[] ={L"The segment decomposition into chunks is not accessible\n"};
    const wchar_t MSG_CHUNK_LIST_EMPTY_TXT[] ={L"at least a chunk list empty\n"};
    const wchar_t MSG_UNABLE_TO_COMPUTE_CHUNK_MATCH_SCORE_WITH_LEMMA_TXT[] ={L"chunk match score computing according to lemma comparison doesn't work\n"};
    const wchar_t MSG_CANT_WRITE_CHUNK_LINK_IN_DATABASE_TXT[] ={L"chunk link can't be inserted in the mission database\n"};
    const wchar_t MSG_CANT_WRITE_LEMMA_LINK_IN_DATABASE_TXT[] ={L"lemma link can't be inserted in the mission database\n"};
    const wchar_t MSG_CANT_GET_OPTIONS_TXT[] ={L"unable to read option from the ini file\n"};
    const wchar_t MSG_INVALID_NUMBER_OF_SEGMENT_IN_ARGUMENT_TXT[] ={L"The number of argument in input is wrong\n"};
    const wchar_t MSG_CANT_GET_SEGMENT_CLUE_TXT[] ={L"Unable to read the segment clues in the database\n"};
    const wchar_t MSG_CANT_GET_CLUE_OF_ALL_SEGMENTS_TXT[] ={L"unable to read the clues of all required segments\n"};
    const wchar_t MSG_CANT_GET_SEGMENT_LAYOUT_TXT[] ={L"Unable to read the segment layout in the database\n"};
    const wchar_t MSG_CANT_GET_LAYOUT_OF_ALL_SEGMENTS_TXT[] ={L"unable to read the layout of all required segments\n"};
    const wchar_t MSG_CANT_COMPUTE_EXTERNAL_SCORE_TXT[] ={L"unable to compute external score\n"};
    const wchar_t MSG_CANT_GET_STATISTICS_OF_ALL_SEGMENTS_TXT[] ={L"unable to read the statistics of all required segments\n"};
    const wchar_t MSG_CANT_GET_SEGMENT_STATISTICS_TXT[] ={L"Unable to read the segment statistic in the database\n"};
    const wchar_t MSG_LANGUAGE_POINTER_NOT_VALID_TXT[] ={L"Unable to create language object\n"};
    const wchar_t MSG_CANT_CLASSIFY_CHUNKS_OF_SEGMENT_TXT[] ={L"Unable to classify the chunks of a segment\n"};
    const wchar_t MSG_LANGUAGE_FORBIDDEN_TXT[] ={L"one of the language is forbidden for the linguistic score process\n"};
    const wchar_t MSG_CANT_COMPUTE_CHUNK_MATCH_SCORE_TXT[] ={L"unable to compute chunk match score\n"};
    const wchar_t MSG_CANT_COMPUTE_MATCH_ZONE_TXT[] ={L"The match zone can't be computed waccording to lemmas number\n"};
    const wchar_t MSG_CANT_COMPUTE_MATCH_ZONE_SCORE_TXT[] ={L"unable to compute match zone score\n"};
    const wchar_t MSG_CANT_COMPUTE_MARK_CLUE_TXT[] ={L"unable to compute mark clue\n"};
    const wchar_t MSG_UNKNOWN_CHUNK_TYPE_TXT[] ={L"Unknown chunk type\n"};
    const wchar_t MSG_CANT_GET_CHUNK_ID_OF_SEGMENT_TXT[] ={L"unable to read chunk ID of the segment in the database\n"};
    const wchar_t MSG_CANT_GET_CHUNK_DESCRIPTION_TXT[] ={L"unable to read chunk descriptions in the database\n"};
    const wchar_t MSG_INVALID_NUMBER_OF_CHUNK_IN_INPUT_TXT[] ={L"The number of chunk to analyse is not correct\n"};
    const wchar_t MSG_CANT_GET_LEMMA_LIST_OF_CHUNK_TXT[] ={L"Unable to read the lemma decomposition of a chunk\n"};
    const wchar_t MSG_CANT_GET_LEMMA_DESCRIPTION_TXT[] ={L"Unable to get the description of a lemma\n"};
    const wchar_t MSG_CANT_CONVERT_STRING_INTO_NUMBER_TXT[] ={L"Unable to convert the string into a number\n"};
    const wchar_t MSG_CANT_SEARCH_LEMMA_LINK_FITTING_WITH_THRESHOLD_TXT[] ={L"Unable to search a lemma link that fits with the probability threshold\n"};
    const wchar_t MSG_CANT_COMPUTE_MATCHING_OF_WORD_BEGINNING_TXT[] ={L"Unable to compare beginning of words\n"};
    const wchar_t MSG_CANT_SEARCH_TRANSLATION_FOR_A_LEMMA_TXT[] ={L"nable to search for some translation for a lemma\n"};
    const wchar_t MSG_CANT_GET_LEMMA_LINKS_TXT[] ={L"Unable to get lemma link in the database\n"};
    const wchar_t MSG_CANT_GET_LEMMA_LINK_DESCRIPTION_TXT[] ={L"Unable to get lemma link description in the database\n"};
    const wchar_t MSG_WORDS_ARE_BOTH_EMPTY_TXT[] ={L"The two words are both empty, the process is not valid\n"};
    const wchar_t MSG_CANT_REPLACE_DIACRITICS_CHARACTERS_TXT[] ={L"The diacritic characters can't be replaced\n"};
    const wchar_t MSG_CANT_GET_NGRAMS_ID_TXT[] ={L"Unable to get Ngram ID from the database\n"};
    const wchar_t MSG_BAD_VALUE_FOR_WINDOW_WIDTH_CANDIDATE_DENOMINATOR_TXT[] ={L"The value of m_shWindowWidthCandidateDenominatorOM is set at zero\n"};
    const wchar_t MSG_CANT_GET_NGRAMS_DESCRIPTIONS_TXT[] ={L"Unable to get the ngrams descriptions from the database\n"};
    const wchar_t MSG_INVALID_NGRAM_DEGREE_LIMIT_SETTINGS_TXT[] ={L"The limit of the min or max degree are badly defined\n"};
    const wchar_t MSG_POINTER_SHOULD_BE_NULL_TXT[] ={L"The pointer passed as input parameter should be initialized to NULL\n"};
    const wchar_t MSG_CANT_GET_SEGMENTS_IDS_TXT[] ={L"unable to read all the segment IDs of a given language\n"};
    const wchar_t MSG_CANT_SEARCH_NGRAM_LINK_TXT[] ={L"unable to compute the algorithm that search for ngram equivalent\n"};
    const wchar_t MSG_CANT_COMPUTE_CHI_TEST_ON_NGRAM_LINK_TXT[] ={L"unable to compute Chi test on a given ngram link\n"};
    const wchar_t MSG_CANT_SET_NGRAM_LINK_TXT[] ={L"unable to set an Ngram link in the database\n"};
    const wchar_t MSG_CANT_UPDATE_NGRAM_CLUES_IN_SEGMENTS_CONCERNED_BY_NGRAM_LINK_TXT[] ={L"unable to increment ngram clues in segments concerned by the ngram link\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_TXT[] ={L"an exception throw during execution\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_LOADOPTIONS_TXT[]={L"unknown exception in the loadoptions function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_GETBOOLEANVALUE_TXT[] ={L"unknown exception in the getbooleanvalue function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_GETUINTVALUE_TXT[] ={L"unknown exception in the getuintvalue function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_GETSHORTVALUE_TXT[] ={L"unknown exception in the getshortvalue function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_GETSTRINGVALUE_TXT[] ={L"unknown exception in the getstringvalue function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_GETLISTOFVALUE_TXT[] ={L"unknown exception in the getlistvalue function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_SETBOOLEANVALUE_TXT[] ={L"unknown exception in the setbooleanvalue function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_SETUINTVALUE_TXT[] ={L"unknown exception in the setuintvalue function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_SETSTRINGVALUE_TXT[] ={L"unknown exception in the setstringvalue function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_SETLISTOFVALUE_TXT[] ={L"unknown exception in the setlistvalue function in option manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_OPTION_SAVEOPTIONS_TXT[] ={L"unknown exception in the saveoptions function in option manager\n"};
    const wchar_t MSG_LOCAL_SERVER_NOT_EXIST_TXT[] ={L"local server isn't connected\n"};
    const wchar_t MSG_CANT_OPEN_DATABASE_TXT[] ={L"unable to open the database\n"};
    const wchar_t MSG_CANT_OPEN_ALIGNMENT_DATABASE_TXT[] ={L"unable to open the alignment database\n"};
    const wchar_t MSG_CANT_GET_DATABASE_FILENAME_TXT[] ={L"unable to get the database filename\n"};
    const wchar_t MSG_CANT_DISPLAY_OPENING_ALIGNMENT_DATABASE_MMI_TXT[] ={L"unable to open the alignment database opening MMI\n"};
    const wchar_t MSG_CANT_DISPLAY_SEGMENTS_TXT[] ={L"unable to display segments\n"};
    const wchar_t MSG_CANT_CLOSE_DATABASE_TXT[] ={L"unable to close the alignment database \n"};
    const wchar_t MSG_CANT_ACTIVATE_ITEMS_AND_BUTTONS_TXT[] ={L"unable to activate items and buttons\n"};
    const wchar_t MSG_CANT_GET_DATA_IN_OPEN_DOCUMENTS_PAIRS_MMI_TXT[] ={L"unable to get data in the open document pairs MMI\n"};
    const wchar_t MSG_CANT_ALIGN_DOCUMENTS_PAIRS_TXT[] ={L"unable to align documents pairs\n"};
    const wchar_t MSG_BEGIN_ALIGNMENT_DOCUMENTS_PAIR_TXT[] ={L"Start align documents pairs\n"};
    const wchar_t MSG_END_ALIGNMENT_DOCUMENTS_PAIR_TXT[] ={L"End of the alignment documents pairs\n"};
    const wchar_t MSG_CANT_OPEN_WAITING_MESSAGE_MMI_TXT[] ={L"unable to open waiting message MMI\n"};
    const wchar_t MSG_CANT_CLOSE_WAITING_MESSAGE_MMI_TXT[] ={L"unable to close waiting message MMI\n"};
    const wchar_t MSG_CANT_FETCH_SECTIONS_IN_INIFILE_TXT[] ={L"unable to fetch sections in the ini file\n"};
    const wchar_t MSG_CANT_FETCH_KEYS_AND_VALUES_IN_INIFILE_TXT[] ={L"unable to fetch keys and corresponding values in the ini file\n"};
    const wchar_t MSG_CANT_GET_STRING_VALUE_TXT[] ={L"unable to get string value\n"};
    const wchar_t MSG_CANT_GET_UINT_VALUE_TXT[] ={L"unable to get uint value\n"};
    const wchar_t MSG_CANT_GET_BOOLEAN_VALUE_TXT[] ={L"unable to get boolean value\n"};
    const wchar_t MSG_CANT_WRITE_BOOLEAN_VALUE_TXT[] ={L"unable to write boolean value\n"};
    const wchar_t MSG_CANT_WRITE_UINT_VALUE_TXT[] ={L"unable to write uint value\n"};
    const wchar_t MSG_CANT_WRITE_STRING_VALUE_TXT[] ={L"unable to write string value\n"};
    const wchar_t MSG_CANT_SET_STRING_VALUE_TXT[] ={L"unable to set string value\n"};
    const wchar_t MSG_CANT_SET_UINT_VALUE_TXT[] ={L"unable to set uint value\n"};
    const wchar_t MSG_CANT_SET_BOOLEAN_VALUE_TXT[] ={L"unable to set boolean value\n"};
    const wchar_t MSG_CANT_WRITE_STRING_IN_INIFILE_TXT[] ={L"unable to write the options string in the ini file\n"};
    const wchar_t MSG_CANT_GET_STRING_LIST_TXT[] ={L"unable to get the options string list\n"};
    const wchar_t MSG_CANT_GET_CHUNKS_DESCRIPTION_OF_SEGMENT_TXT[] ={L"unable to get chunks description of the segment\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_DESCRIPTIONCHUNKSOFLANGUAGE_TXT[] ={L"uunknown exception in the descriptionchunksoflanguage function in ChunkViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_EMPTYGRID_TXT[] ={L"unknown exception in the emptygrid function in ChunkViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_GETCOORDINATESFROMID_TXT[] ={L"unknown exception in the getcoordinatesfromid function in ChunkViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_GETIDFROMCOORDINATES_TXT[] ={L"UNKNOWN_EXCEPTION_CHUNKVIEWER_GETIDFROMCOORDINATES\n"};
    const wchar_t MSG_CANT_GET_COORDINATES_FROM_ID_TXT[] ={L"unable to get the row and column coordinates of the chunk by the ID of the chunk\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_GETSTATUS_TXT[] ={L"unknown exception in the getstatus function in ChunkViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_HIDEGRID_TXT[] ={L"unknown exception in the hidegrid function in ChunkViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_MOVECLOSERCHUNKSOFLINKS_TXT[] ={L"unknown exception in the movecloserchunksoflinks function in ChunkViewer manager\n"};
    const wchar_t MSG_CANT_GET_ID_FROM_COORDINATES_TXT[] ={L"unable to get the ID of the chunk from the row and column coordinates of the chunk\n"};
    const wchar_t MSG_CANT_GET_STATUS_TXT[] ={L"unable to get the status of the chunk\n"};
    const wchar_t MSG_CANT_MANAGE_CHUNK_SELECTING_TXT[] ={L"unable to manage the chunk selecting\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_ONSELECTCHUNK_TXT[] ={L"unknown exception in the onselectchunk function in ChunkViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_SETSTATUS_TXT[] ={L"unknown exception in the setstatus function in ChunkViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_SHOWGRID_TXT[] ={L"unknown exception in the showgrid function in ChunkViewer manager\n"};
    const wchar_t MSG_CANT_DISPLAY_CRITERIA_MMI_TXT[] ={L"unable to display the criteria MMI\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_EDITCRITERIA_TXT[] ={L"unknown exception in the editcriteria function in CriteriaParameters manager\n"};
    const wchar_t MSG_CANT_DISPLAY_PARAMETERS_MMI_TXT[] ={L"unable to display parameters MMI\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_EDITPARAMETERS_TXT[] ={L"unknown exception in the EditParameters function in CriteriaParameters manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_DEFAULTCRITERIAVALUES_TXT[] ={L"unknown exception in the DefaultCriteriaValues function in CriteriaParameters manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_DEFAULTPARAMETERSVALUES_TXT[] ={L"unknown exception in the DefaultParametersValues function in CriteriaParameters manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_APPLYCRITERIA_TXT[] ={L"unknown exception in the editcriteria function in CriteriaParameters manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_APPLYPARAMETERS_TXT[] ={L"unknown exception in the editcriteria function in CriteriaParameters manager\n"};
    const wchar_t MSG_CANT_CLOSE_CRITERIA_MMI_TXT[] ={L"unable to close the criteria MMI\n"};
    const wchar_t MSG_CANT_CLOSE_DISPLAY_PARAMETERS_MMI_TXT[] ={L"unable to close the display parameters MMI\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_ACTIVATEITEMSANDBUTTONS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_OPENALIGNMENTDATABASE_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_DOCUMENTS_PAIRS_PROCESSING_TXT[] ={L"unable to manage the documents pairs processing\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_PROCESSDOCUMENTSPAIRS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_EQUIVALENTS_EXTRACTION_TXT[] ={L"unable to manage the equivalents extraction\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EXTRACTSEGMENTSANDCHUNKSEQUIVALENTS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_CHUNKS_EQUIVALENTS_EXTRACTION_TXT[] ={L"unable to manage the chunks equivalents extraction\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EXTRACTCHUNKSEQUIVALENTS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_WORK_PROGRESS_ESTIMATION_TXT[] ={L"unable to manage the work progress estimation\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_WORKPROGRESS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_EDIT_PARAMETERS_TXT[] ={L"unable to manage the edit parameters\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EDITPARAMETERS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_EDIT_CRITERIA_TXT[] ={L"unable to manage the edit criteria\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EDITCRITERIA_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_SEGMENTS_VIEW_TXT[] ={L"unable to manage the segments view\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWALLSEGMENTS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWNONALIGNEDSEGMENTS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_CHUNKS_VIEW_TXT[] ={L"unable to manage the chunks view\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWALLCHUNKS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWNONALIGNEDCHUNKS_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_CLOSE_PROJECT_TXT[] ={L"unable to close the project\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_CLOSEPROJECT_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_MANAGE_QUIT_TXT[] ={L"unable to manage the quit\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_QUIT_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_OPEN_ALIGNEMENT_DATABASE_MMI_TXT[] ={L"unable to open the alignment database\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_GETALIGNEMENTDATABASEFILE_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_OPEN_NEW_ALIGNEMENT_DATABASE_MMI_TXT[] ={L"unable to open the new alignment database\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_GETDOCUMENTSPAIRFILES_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_OPENQUITCONFIRMATION_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_OPENWAITINGMESSAGEWINDOW_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_CLOSEWAITINGMESSAGEWINDOW_TXT[] ={L"unknown exception in the activateitemsandbuttons function in MenuToolBar manager\n"};
    const wchar_t MSG_CANT_GET_SEGMENT_STATUS_TXT[] ={L"unable to get segment status\n"};
    const wchar_t MSG_CANT_MANAGE_SEGMENT_SELECTING_TXT[] ={L"unable to manage the segment selecting\n"};
    const wchar_t MSG_CANT_GET_SEGMENT_DESCRIPTION_TXT[] ={L"unable to get the segment description\n"};
    const wchar_t MSG_CANT_GET_SEGMENT_CHUNK_DESCRIPTION_TXT[] ={L"unable to get the chunk description of segment\n"};
    const wchar_t MSG_CANT_FIND_TARGET_SEGMENT_DESCRIPTION_OF_LINK_TXT[] ={L"unable to find the target segment description of the segment link"};
    const wchar_t MSG_CANT_FIND_TARGET_CHUNK_DESCRIPTION_OF_LINK_TXT[] ={L"unable to find the target chunk description of the chunk link"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_SETFOCUSONSEGMENTACCORDINGTONUMBER_TXT[] ={L"unknown exception in the setfocusonsegmentaccordingtonumber function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_ONSELECTSEGMENT_TXT[] ={L"unknown exception in the onselectsegment function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_DISPLAYSEGMENTSOFLANGUAGE_TXT[] ={L"unknown exception in the displaysegmentoflanguage function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_MOVECLOSERSEGMENTSOFLINKS_TXT[] ={L"unknown exception in the moveclosersegmentsoflinks function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_SETSTATUS_TXT[] ={L"unknown exception in the setstatus function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GIVEINITIALPOSITION_TXT[] ={L"unknown exception in the giveinitialposition function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GETIDFROMCOORDINATES_TXT[] ={L"unknown exception in the getidfromcoordinates function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GETCOORDINATESFROMID_TXT[] ={L"unknown exception in the getcoordinatesfromid function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GETSTATUS_TXT[] ={L"unknown exception in the getstatus function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_SHOWGRID_TXT[] ={L"unknown exception in the showgrid function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_HIDEGRID_TXT[] ={L"unknown exception in the hidegrid function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_EMPTYGRID_TXT[] ={L"unknown exception in the emptygrid function in SegmentViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_WORKPROGRESSVIEWER_DISPLAYWORKPROGRESS_TXT[] ={L"unknown exception in the displayworkprogress function in WorkProgressViewer manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_WORKPROGRESSVIEWER_CLOSE_TXT[] ={L"unknown exception in the close function in WorkProgressViewer manager\n"};
    const wchar_t MSG_CANT_GET_TOTAL_NUMBER_OF_SOURCE_SEGMENTS_TXT[] ={L"unable to get total number of source segments\n"};
    const wchar_t MSG_CANT_GET_TOTAL_NUMBER_OF_TARGET_SEGMENTS_TXT[] ={L"unable to get total number of target segments\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETTOTALNUMBEROFSEGMENTS_TXT[] ={L"unknown exception in the gettotalnumberofsegments function in WorkProgress manager\n"};
    const wchar_t MSG_CANT_GET_NUMBER_OF_ALIGNED_SEGMENTS_TXT[] ={L"unable to get number of aligned segments\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETNUMBEROFALIGNEDSEGMENTS_TXT[] ={L"unknown exception in the getnumberofalignedsegments function in WorkProgress manager\n"};
    const wchar_t MSG_CANT_GET_TOTAL_NUMBER_OF_SOURCE_CHUNKS_TXT[] ={L"unable to get total number of source chunks\n"};
    const wchar_t MSG_CANT_GET_TOTAL_NUMBER_OF_TARGET_CHUNKS_TXT[] ={L"unable to get total number of target chunks\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETTOTALNUMBEROFCHUNKS_TXT[] ={L"unknown exception in the gettotalnumberofchunks function in WorkProgress manager\n"};
    const wchar_t MSG_CANT_GET_NUMBER_OF_ALIGNED_CHUNKS_TXT[] ={L"unable to get number of aligned chunks\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETNUMBEROFALIGNEDCHUNKS_TXT[] ={L"unknown exception in the getnumberofalignedchunks function in WorkProgress manager\n"};
    const wchar_t MSG_CANT_DISCONNECT_SERVER_TXT[] ={L"unable to disconnect the server\n"};
    const wchar_t MSG_CANT_CONNECT_SERVER_TXT[] ={L"unable to connect the server\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SOFTWAREMANAGER_TERMINATION_TXT[] ={L"unknown exception in the gtermination function in Software manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_SOFTWAREMANAGER_INITIALIZATION_TXT[] ={L"unknown exception in the initialization function in Software manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEALIGNMENTDATABASEOPENING_TXT[] ={L"unknown exception in the managealignmentdatabaseopening function in Aligner manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEDOCUMENTSPAIRSPROCESSING_TXT[] ={L"unknown exception in the manageadocumentspairsprocessing function in Aligner manager\n"};
    const wchar_t MSG_CANT_FETCH_NUMBER_OF_ALIGNED_SEGMENTS_TXT[] ={L"unable to fetch number of aligned segments\n"};
    const wchar_t MSG_CANT_DISPLAY_WORK_PROGRESS_TXT[] ={L"unable to display the work progress MMI\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECHUNKSELECTING_TXT[] ={L"unknown exception in the managechunkselecting function in Aligner manager\n"};
    const wchar_t MSG_CANT_EDIT_PARAMETERS_TXT[] ={L"unable to edit parameters\n"};
    const wchar_t MSG_CANT_APPLY_PARAMETERS_CHANGES_TXT[] ={L"unable to apply parameters changes\n"};
    const wchar_t MSG_CANT_STORE_PARAMETERS_VALUES_IN_MEMORY_AND_INI_FILE_TXT[] ={L"unable to store parameters values in memory and ini file\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEEDITPARAMETERS_TXT[] ={L"unknown exception in the manageeditparameters function in Aligner manager\n"};
    const wchar_t MSG_CANT_EDIT_CRITERIA_TXT[] ={L"unable to edit criteria\n"};
    const wchar_t MSG_CANT_APPLY_CRITERIA_CHANGES_TXT[] ={L"unable to apply criteria changes\n"};
    const wchar_t MSG_CANT_STORE_CRITERIA_VALUES_IN_MEMORY_AND_INI_FILE_TXT[] ={L"unable to store criteria values in memory and ini file\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEEDITCRITERIA_TXT[] ={L"unknown exception in the manageeditcriteria function in Aligner manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGESEGMENTSVIEW_TXT[] ={L"unknown exception in the managesegmentsview function in Aligner manager\n"};
    const wchar_t MSG_CANT_EMPTY_CHUNK_GRID_TXT[] ={L"unable to empty the chunk grid\n"};
    const wchar_t MSG_CANT_GET_SEGMENT_ID_FROM_COORDINATES_TXT[] ={L"unable to get segment ID from coordinates\n"};
    const wchar_t MSG_CANT_GET_LINK_ID_OF_SEGMENT_TXT[] ={L"unable to get link ID of segment\n"};
    const wchar_t MSG_CANT_GET_LINK_ID_OF_CHUNK_OF_SEGMENT_TXT[] ={L"unable to get link ID of chunk of segment\n"};
    const wchar_t MSG_CANT_GET_SEGMENT_LINK_DESCRIPTION_TXT[] ={L"unable to get segment link description\n"};
    const wchar_t MSG_CANT_DISPLAY_CHUNKS_OF_SEGMENTS_TXT[] ={L"unable to display chunks of segments\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECHUNKSVIEW_TXT[] ={L"unknown exception in the managechunksview function in Aligner manager\n"};
    const wchar_t MSG_CANT_EMPTY_SEGMENT_GRID_TXT[] ={L"unable to empty the segment grid\n"};
    const wchar_t MSG_CANT_HIDE_SEGMENT_GRID_TXT[] ={L"unable to hide the segment grid\n"};
    const wchar_t MSG_CANT_HIDE_CHUNK_GRID_TXT[] ={L"unable to hide the chunk grid\n"};
    const wchar_t MSG_CANT_OPEN_QUIT_CONFIRMATION_TXT[] ={L"unable to open the quit confirmation MMI\n"};
    const wchar_t MSG_CANT_STOP_MEMORIA_MANAGER_TXT[] ={L"unable to stop the application\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEQUIT_TXT[] ={L"unknown exception in the managequit function in Aligner manager\n"};
    const wchar_t MSG_CANT_MAKE_GLOBAL_PAIR_ALIGNMENT_PROCESS_TXT[] ={L"unable to make the global pair alignment process\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEQUIVALENTSEXTRACTION_TXT[] ={L"unknown exception in the managequivalentsextraction function in Aligner manager\n"};
    const wchar_t MSG_CANT_GIVE_SEGMENT_INITIAL_POSITION_TXT[] ={L"unable to give the initial position of the segment\n"};
    const wchar_t MSG_CANT_GET_ALL_SOURCE_SEGMENTS_IDS_TXT[] ={L"unable to get all source segments IDs\n"};
    const wchar_t MSG_CANT_GET_NON_ALIGNED_SOURCE_SEGMENTS_IDS_TXT[] ={L"unable to get non aligned source segments IDs\n"};
    const wchar_t MSG_CANT_FILL_SEGMENT_GRID_TXT[] ={L"unable to fill segment grid\n"};
    const wchar_t MSG_CANT_FILL_CHUNK_GRID_TXT[] ={L"unable to fill chunk grid\n"};
    const wchar_t MSG_CANT_GET_ALL_TARGET_SEGMENTS_IDS_TXT[] ={L"unable to get all target segments IDs\n"};
    const wchar_t MSG_CANT_GET_NON_ALIGNED_TARGET_SEGMENTS_IDS_TXT[] ={L"unable to get non aligned target segments IDs\n"};
    const wchar_t MSG_CANT_DISPLAY_TARGET_SEGMENT_OF_LANGUAGE_TXT[] ={L"unable to display target segment of language\n"};
    const wchar_t MSG_CANT_MOVE_CLOSER_SEGMENTS_OF_LINKS_TXT[] ={L"unable to move closer segments of links\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_DISPLAYSEGMENTS_TXT[] ={L"unknown exception in the displaysegments function in Aligner manager\n"};
    const wchar_t MSG_CANT_FIND_SEGMENT_LINK_ID_FROM_SEGMENT_ID_TXT[] ={L"unable to find segment link ID from segment ID\n"};
    const wchar_t MSG_CANT_MAKE_SIMPLE_PAIR_ALIGNMENT_PROCESS_TXT[] ={L"unable to make simple pair alignment processus\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECHUNKSEQUIVALENTSEXTRACTION_TXT[] ={L"unknown exception in the managechunksequivalentsextraction function in Aligner manager\n"};
    const wchar_t MSG_CANT_GET_ALL_SOURCE_CHUNKS_IDS_TXT[] ={L"unable to get all source chunks IDs\n"};
    const wchar_t MSG_CANT_GET_NON_ALIGNED_SOURCE_CHUNKS_IDS_TXT[] ={L"unable to get non aligned chunks IDs\n"};
    const wchar_t MSG_CANT_DISPLAY_SOURCE_CHUNKS_OF_LANGUAGE_TXT[] ={L"unable to display source chunks of language\n"};
    const wchar_t MSG_CANT_GET_ALL_TARGET_CHUNKS_IDS_TXT[] ={L"unable to get all target chunks IDs\n"};
    const wchar_t MSG_CANT_GET_NON_ALIGNED_TARGET_CHUNKS_IDS_TXT[] ={L"unable to get non aligned target chunks IDs\n"};
    const wchar_t MSG_CANT_DISPLAY_TARGET_CHUNKS_OF_LANGUAGE_TXT[] ={L"unable to display target chunks of language\n"};
    const wchar_t MSG_CANT_GET_CHUNK_LINKS_IDS_FROM_SOURCE_AND_TARGET_SEGMENTS_TXT[] ={L"unable to get chunk links IDs from source and target segments\n"};
    const wchar_t MSG_CANT_GET_CHUNK_LINK_DESCRIPTION_TXT[] ={L"unable to get chunk link description\n"};
    const wchar_t MSG_CANT_MOVE_CLOSER_CHUNKS_OF_LINKS_TXT[] ={L"unable to move closer chunks of links\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_DISPLAYCHUNKSOFSEGMENTS_TXT[] ={L"unknown exception in the displaychunksofsegment function in Aligner manager\n"};
    const wchar_t MSG_CANT_ANALYSE_SOURCE_DOCUMENT_TXT[] ={L"unable to analyse the source document\n"};
    const wchar_t MSG_CANT_ANALYSE_TARGET_DOCUMENT_TXT[] ={L"unable to analyse the target document\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_ALIGNDOCUMENTSPAIRS_TXT[] ={L"unknown exception in the aligndocumentspairs function in Aligner manager\n"};
    const wchar_t MSG_CANT_FETCH_TOTAL_NUMBER_OF_SEGMENTS_TXT[] ={L"unable to fetch the total number of segments\n"};
    const wchar_t MSG_CANT_FETCH_TOTAL_NUMBER_OF_CHUNKS_TXT[] ={L"unable to fetch the total number of chunks\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGESEGMENTSELECTING_TXT[] ={L"unknown exception in the managesegmentselecting function in Aligner manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEWORKPROGRESSESTIMATION_TXT[] ={L"unknown exception in the manageworkprogressestimation function in Aligner manager\n"};
    const wchar_t MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECLOSEPROJECT_TXT[] ={L"unknown exception in the managecloseproject function in Aligner manager\n"};
    const wchar_t MSG_CANCEL_TXT[] ={L"query cancelled\n"};
    const wchar_t MSG_DEFAULT_VALUE_TAKEN_TXT[] = {L"the value was not in the ini file, default value taken\n"};
    
    


    Jean Noël Martin

    samedi 31 janvier 2015 10:18
  • suite de Message:

    //----------------------------------------------------------------------------
    //              ANALYSER  ERROR MESSAGES
    //----------------------------------------------------------------------------
    
    const wchar_t MSG_DOCUMENT_POINTER_NULL_TXT[] ={L"pointer on Document Manager is null\n"};
    const wchar_t MSG_PARSER_POINTER_NULL_TXT[] ={L"pointer on Parser Manager is null\n"};
    const wchar_t MSG_CHUNKER_POINTER_NULL_TXT[] ={L"pointer on Chunker is null\n"};
    const wchar_t MSG_NGRAMER_POINTER_NULL_TXT[] ={L"pointer on Ngramer is null\n"};
    const wchar_t MSG_SEGMENTATION_POINTER_NULL_TXT[] ={L"pointer on Segmentation is null\n"};
    const wchar_t MSG_COMPUTING_FOR_ALIGNMENENT_POINTER_NULL_TXT[] ={L"pointer on Computing For Alignment is null\n"};
    const wchar_t MSG_ANNEX_FUNCTION_POINTER_NULL_TXT[] ={L"pointer on Annex Function is null\n"};
    const wchar_t MSG_SEGMENTATION_CANNOT_SPLIT_INTO_SEGMENT_TXT[] ={L"unable to split into segment the bloc of text\n"};
    const wchar_t MSG_SEGMENTATION_CANNOT_ADD_SPACE_IN_SEGMENT_TXT[] ={L"unable to add space in list of word from class CSegment\n"};
    const wchar_t MSG_COMPUTING_FOR_ALIGNMENENT_CANNOT_MAKE_COMPUTE_TXT[] ={L"unable to make compute for alignment\n"};
    const wchar_t MSG_CHUNKER_CANNOT_SPLIT_INTO_CHUNK_TXT[] ={L"unable to split into chunk\n"};
    const wchar_t MSG_NGRAMER_CANNOT_SEARCH_NGRAM_TXT[] ={L"unable find Ngram in the text\n"};
    const wchar_t MSG_DOCUMENT_CANNOT_READ_BLOC_TXT[] ={L"unable to read a bloc of text (problem with Word API)\n"};
    const wchar_t MSG_PARSER_CANNOT_PARSE_BLOC_TXT[] ={L"unable to Parse a bloc of text (problem with Xelda API)\n"};
    const wchar_t MSG_NGRAMER_CANNOT_DELETE_NGRAM_DATABASE_TXT[] ={L"unable to delete Ngram in Mission Database\n"};
    const wchar_t MSG_ANNEX_FUNCTION_CANNOT_EXCLUDE_LEM_DATABASE_TXT[] ={L"unable to exclude LEMMA in Mission Database\n"};
    const wchar_t MSG_DOCUMENT_CANNOT_STOP_READER_TXT[] ={L"unable to stop the Reader (problem with Word API)\n"};
    const wchar_t MSG_DOCUMENT_CANNOT_CLOSE_DOCUMENT_TXT[] ={L"unable to close a document\n"};
    const wchar_t MSG_DOCUMENT_THERE_IS_NO_BLOC_TXT[] ={L"There is no bloc of text in the document (pBloc is null)\n"};
    const wchar_t MSG_DOCUMENT_NOT_ABLE_TO_OPEN_DOCUMENT_TXT[] ={L"unable to open the document\n"};
    const wchar_t MSG_DOCUMENT_NOT_ABLE_TO_START_READER_TXT[] ={L"unable to start the Reader\n"};
    const wchar_t MSG_DATABASE_CANNOT_ADD_SEGMENT_TXT[] ={L"unable to add a segment in Mission Database\n"};
    const wchar_t MSG_OPTION_MANAGER_CANNOT_LOAD_TXT[] ={L"unable to load information which are in init file (Option Manager problem)\n"};
    const wchar_t MSG_POINTER_SEGMENT_NULL_TXT[] ={L"pointer on CSegment is null (cannot create a segment)\n"};
    const wchar_t MSG_MISSION_DATABASE_CANNOT_ERASE_NGRAMS_TXT[] ={L"unable to erase Ngrams in Mission Database\n"};
    const wchar_t MSG_DATABASE_CANNOT_EXCLUDE_LEM_TXT[] ={L"unable to exclude LEMMA in Mission Database\n"};
    const wchar_t MSG_OPTION_MANAGER_CANNOT_LOAD_INFO_TXT[] ={L"unable to load information which are in init file (Option Manager problem)\n"};
    const wchar_t MSG_CANT_INITIALIZE_READING_TXT[] ={L"Unable to initialize the reading of the document\n"};
    const wchar_t MSG_CANT_GET_CASE_PROPERTY_TXT[] ={L"Unable to get the case of a bloc of text\n"};
    const wchar_t MSG_CANT_GET_FONT_PROPERTIES_TXT[] ={L"Unable to get the font properties\n"};
    const wchar_t MSG_CANT_GET_BOLD_PROPERTY_TXT[] ={L"Unable to get the bold property\n"};
    const wchar_t MSG_CANT_GET_ITALIC_PROPERTY_TXT[] ={L"Unable to get the italic property\n"};
    const wchar_t MSG_CANT_GET_UNDERLINE_PROPERTY_TXT[] ={L"Unable to get the underline property\n"};
    const wchar_t MSG_CANT_GET_FONT_SIZE_PROPERTY_TXT[] ={L"Unable to get the font size property\n"};
    const wchar_t MSG_CANT_GET_FONT_NAME_PROPERTY_TXT[] ={L"Unable to get the font name property\n"};
    const wchar_t MSG_CANT_GET_FOREGROUND_COLOR_PROPERTY_TXT[] ={L"Unable to get the foreground color property\n"};
    const wchar_t MSG_CANT_GET_BACKGROUND_COLOR_PROPERTY_TXT[] ={L"Unable to get the background color property\n"};
    const wchar_t MSG_CANT_DETERMINE_IF_PARAGRAPH_IS_IN_ARRAY_TXT[] ={L"Unable to know if the paragraph is a part of an array\n"};
    const wchar_t MSG_CANT_START_WORD_API_TXT[] ={L"Unable to start the word API\n"};
    const wchar_t MSG_CANT_STOP_WORD_API_TXT[] ={L"Unable to stop the word API\n"};
    const wchar_t MSG_CANT_OPEN_DOCUMENT_TXT[] ={L"Unable to open the document %s (std::wstring wsFullPathName)\n"};
    const wchar_t MSG_CANT_CLOSE_DOCUMENT_TXT[] ={L"Unable to close the document\n"};
    const wchar_t MSG_CANT_GO_TO_NEXT_BLOC_TXT[] ={L"Unable to read the following paragraph of the text\n"};
    const wchar_t MSG_CANT_GET_PARAGRAPH_LAYOUT_TXT[] ={L"Unable to get the layout of the paragraph %s (std::wstring wsText)\n"};
    const wchar_t MSG_CANT_CREATE_WORD_READER_TXT[] ={L"Unable to create the Word Reader\n"};
    
      //---------------------------------------------------------------
      //             ALIGNMENT
      //---------------------------------------------------------------
    
    const wchar_t  MSG_GRAMS_OCCURRENCE_POINTER_NOT_VALID_TXT[] ={L"Pointer on grams occurrence class not accessible\n"};
    const wchar_t  MSG_ALIGNMENT_SEGMENT_BETWEEN_BOUNDS_POINTER_NOT_VALID_TXT[] ={L"Pointer on alignment between bounds class not accessible\n"};
    const wchar_t  MSG_CANT_GET_SOURCE_SEGMENT_NUMBER_TXT[] ={L"Impossible d'obtenir le nombre de segment source dans la Database\n"};
    const wchar_t  MSG_CANT_GET_TARGET_SEGMENT_NUMBER_TXT[] ={L"Impossible d'obtenir le nombre de segment target dans la Database\n"};
    const wchar_t  MSG_CANT_EXECUTE_NGRAMS_ALIGNMENT_TXT[] ={L"Impossible d'obtenir le nombre de segment target dans la Database\n"};
    const wchar_t  MSG_CANT_ALIGN_WITH_WINDOWS_TXT[] ={L"Impossible d'aligner les segments entre ceux déjà alignés\n"};
    const wchar_t  MSG_CANT_ALIGN_WITH_ANCHORS_TXT[] ={L"Impossible d'aligner les segments à Clues\n"};
    const wchar_t  MSG_CANT_ALIGN_BY_STATISTIC_TXT[] ={L"Impossible d'aligner par les elements statistics\n"};
    const wchar_t  MSG_CANT_GET_SOURCE_SEGMENT_ID_IN_MISSION_DATABASE_TXT[] ={L"Impossible d'obtenir les segments sources\n"};
    const wchar_t  MSG_CANT_GET_TARGET_SEGMENT_ID_IN_MISSION_DATABASE_TXT[] ={L"Impossible d'obtenir les segments target\n"};
    const wchar_t  MSG_CANT_USED_CANDIDATE_FUNCTION_TXT[] ={L"Impossible d'utiliser Candidate function\n"};
    const wchar_t  MSG_CANT_GET_LIST_OF_TARGET_SEGMENT_ID_TXT[] ={L" Can't have the list of segment id with a level of anchors from Mission Databse\n"};
    const wchar_t  MSG_CANT_GET_LIST_OF_SOURCE_SEGMENT_ID_TXT[] ={L"Can't have the list of segment id with a level of anchors from Mission Databse\n"};
    const wchar_t  MSG_CANT_GET_LIST_OF_SOURCE_SEGMENT_ALIGNED_TXT[] ={L"list of segments already aligned  not accessible\n"};
    const wchar_t  MSG_CANT_GET_LIST_OF_TARGET_SEGMENT_ALIGNED_TXT[] ={L"list of segments already aligned not accessible\n"};
    const wchar_t  MSG_CANT_GET_LIST_OF_SOURCE_SEGMENT_NOT_ALIGNED_TXT[] ={L"list of segment between aligned ones not accessible\n"};
    const wchar_t  MSG_CANT_GET_LIST_OF_TARGET_SEGMENT_NOT_ALIGNED_TXT[] ={L"list of segment between aligned ones not accessible\n"};
    const wchar_t  MSG_CANT_EXECUTE_SECURE_ANCHORS_TXT[] ={L"Impossible d'executer secure Anchors\n"};
    const wchar_t  MSG_CANT_ALIGN_BETWEEN_BOUNDS_TXT[] ={L"Impossible de réaliser la fonction Secure Anchors\n"};
    const wchar_t  MSG_CANT_EXECUTE_SECURE_ANCHORS_WITH_CANDIDATE_TXT[] ={L"Impossible de réaliser la fonction Secure Anchors dans candidate\n"};
    const wchar_t  MSG_CANT_INSERT_SEGMENT_RESULT_IN_MISSION_DATABASE_TXT[] ={L"Impossible d'inserer les element du segment dans la base\n"};
    const wchar_t  MSG_CANT_EXECUTE_LINGUISTIC_SCORE_TXT[] ={L"Impossible d'executer linguistic score\n"};
    const wchar_t  MSG_CANT_EXECUTE_SCTRUCTURE_SCORE_TXT[] ={L"Impossible d'executer structure score\n"};
    const wchar_t  MSG_CANT_INSERT_SEGMENT_IN_DATABASE_TXT[] ={L"Impossible d'inserer les segments dans la base avec la fonction potentiel match\n"};
    const wchar_t  MSG_CANT_INSERT_CHUNK_IN_DATABASE_TXT[] ={L"Impossible d'inserer les chunks dans la base avec la fonction potentiel match\n"};
    const wchar_t  MSG_CANT_INSERT_LEMMA_IN_DATABASE_TXT[] ={L"Impossible d'inserer les Lmma dans la base avec la fonction potentiel match\n"};
    const wchar_t  MSG_MISSION_DATABASE_POINTER_NOT_VALID_TXT[] ={L"the pointer on the mission database is not valid\n"};
    const wchar_t  MSG_STRUCTURE_SEGMENT_ALIGNMENT_POINTER_NOT_VALID_TXT[] ={L"the pointer on the structure segment alignment class is not valid\n"};
    const wchar_t  MSG_LINGUISTIC_SEGMENT_ALIGNMENT_POINTER_NOT_VALID_TXT[] ={L"the pointer on the linguistic segment alignment class is not valid\n"};
    const wchar_t  MSG_POINTER_OF_LINGUISTIC_RESULT_UNABLE_TXT[] ={L"the pointer on the linguistic segment alignment result is not valid\n"};
    const wchar_t  MSG_UNABLE_TO_GET_LINGUISTIC_RESULT_TXT[] ={L"the pointer on the linguistic segment alignment result is not valid\n"};
    const wchar_t  MSG_UNABLE_TO_GET_STRUCTURAL_RESULT_TXT[] ={L"the pointer on the structural segment alignment result is not valid\n"};
    const wchar_t  MSG_UNABLE_TO_INSERT_SEGMENT_LINK_TXT[] ={L"Impossible d'insérer dans la base de donnée\n"};
    const wchar_t  MSG_POINTER_OF_STRUCTURAL_RESULT_UNABLE_TXT[] ={L"the pointer on the structural segment alignment result is not valid\n"};
    const wchar_t  MSG_ERROR_MISSION_DATABASE_CANNOT_CREATE_LEMMA_TXT[] ={L"Error cannot create lemma in Mission Database\n"};
    const wchar_t  MSG_ERROR_MISSION_DATABASE_CANNOT_SET_LEMMA_LINK_TXT[] ={L"Error cannot set Lemma Link in Mission Database\n"};
    const wchar_t  MSG_ERROR_PARSER_MANAGER_CANNOT_GET_TRANSLATION_TXT[] ={L"Error cannot get translation of Lemma with Parser Manager\n"};
    const wchar_t  MSG_ERROR_MISSION_DATABASE_CANNOT_GET_LEMMA_DESCRIPTION_TXT[] ={L"Error cannot get Lemma description in Mission Database\n"};
    const wchar_t  MSG_ERROR_MISSION_DATABASE_CANNOT_GET_LIST_LEMMA_ID_TXT[] ={L"Error cannot get Lemma identifiants list in Mission Database\n"};
    const wchar_t  MSG_ERROR_MISSION_DATABASE_POINTER_NULL_TXT[] ={L"Error Mission Database pointer null\n"};
    const wchar_t  MSG_INVALID_WINDOW_WIDTH_CANDIDATE_DENOMINATOR_SETTINGS_TXT[] ={L"Bad setting for the WINDOW_WIDTH_CANDIDATE_DENOMINATOR settings of the CGRAMS_OCCURRENCE section\n"};
    const wchar_t  MSG_GRAMS_OCCURENCE_POINTER_NOT_VALID_TXT[] ={L"The pointer on GramOccurence is not valid\n"};
    const wchar_t  MSG_SEARCH_TRANSLATION_POINTER_NOT_VALID_TXT[] ={L"The pointer on SearchTranslation is not valid\n"};
    const wchar_t  MSG_CANT_RESET_NGRAMS_CLUES_IN_ALL_SEGMENTS_TXT[] ={L"Can't reset NGrams Clues\n"};
    const wchar_t  MSG_CANT_REMOVE_OLD_SEGMENT_LINKS_TXT[] ={L"Can't remove old segment links\n"};
    const wchar_t  MSG_CANT_GET_ALL_SEGMENTS_IDS_TXT[] ={L"Can't get segment IDs\n"};
    const wchar_t  MSG_CANT_COMPUTE_LINGUISTIC_SCORE_ON_SEGMENT_LINK_TXT[] ={L"Can't compute linguistic score\n"};
    const wchar_t  MSG_CANT_COMPUTE_STRUCTURAL_SCORE_ON_SEGMENT_LINK_TXT[] ={L"Can't compute structural score\n"};
    const wchar_t  MSG_CANT_SELECT_SEGMENTS_TO_ALIGN_ACCORDING_TO_CLUES_TXT[] ={L"Can't select segment to align according clues\n"};
    const wchar_t  MSG_CANT_COMPUTE_NGRAMS_CLUES_TXT[] ={L"Can't compute NGram clues\n"};
    const wchar_t  MSG_CANT_SET_TRANSLATION_FOR_LEMMAS_TXT[] ={L"Can't set translation of lemmas\n"};
    const wchar_t  MSG_CANT_SET_SEGMENT_LINK_IN_DATABASE_TXT[] ={L"Can't set segment link in DB\n"};
    const wchar_t  MSG_CANT_SET_CHUNK_LINK_IN_DATABASE_TXT[] ={L"Can't set chunk link in DB\n"};
    const wchar_t  MSG_CANT_SET_LEMMA_LINK_IN_DATABASE_TXT[] ={L"Can't set lemma link in DB\n"};
    const wchar_t  MSG_ERROR_FOR_NUMBER_CLUE_TXT[] ={L"Error for Number Clue\n"};
    const wchar_t  MSG_ERROR_FOR_NGRAM_CLUE_TXT[] ={L"NGram\n"};
    const wchar_t  MSG_ERROR_FOR_INTERNAL_CLUE_TXT[] ={L"Internal\n"};
    const wchar_t  MSG_ERROR_FOR_EXTERNAL_CLUE_TXT[] ={L"External\n"};
    const wchar_t  MSG_ERROR_CHECKING_POSITION_TXT[] ={L"Error Checking position\n"};
    const wchar_t  MSG_CANT_UPDATE_SEGMENT_STATUS_TXT[] ={L"Unable to update segment status\n"};
    const wchar_t  MSG_CANT_UPDATE_CHUNK_STATUS_TXT[] ={L"Unable to update chunk status\n"};
    const wchar_t  MSG_PROBLEM_GETTING_ELEMENT_DESCRIPTION_TXT[] ={L"Problem getting element description\n"};
    const wchar_t  MSG_ERROR_FINDING_LINK_TXT[] ={L"Error finding link\n"};
    const wchar_t  MSG_ERROR_GETTING_LINK_DESCRIPTION_TXT[] ={L"error getting link description\n"};
    const wchar_t  MSG_LIST_MUST_BE_OF_SAME_SIZE_TXT[] ={L"List must be of the same size\n"};
    const wchar_t  MSG_CANT_ALIGN_WINDOW_TXT[] ={L"Can't align window\n"};
    const wchar_t  MSG_CANT_COMPUTE_STATISTIC_SCORE_ON_SEGMENT_LINK_TXT[] ={L"Can't compute statistic score\n"};
    const wchar_t  MSG_WRONG_ALIGNMENT_TYPE_TXT[]={L"The alignment type is wrong\n"};
    const wchar_t  MSG_CANT_GET_SEGMENT_LINK_IN_DATABASE_TXT[] ={L"Can't get segment link in DB\n"};
    const wchar_t  MSG_CANT_ALLOCATE_MATRIX_TXT[] ={L"Can't allocate memory for the Matrix\n"};
    const wchar_t  MSG_LEMMA_SCORE_POINTER_NOT_VALID_TXT[] ={L"The pointer on Lemma Score is not valid\n"};
    const wchar_t  MSG_CANT_COMPUTE_LEMMA_SCORE_TXT[] ={L"Unable to compute the lemma score between two lemmas\n"};
    const wchar_t  MSG_CANT_GET_LIST_OF_LEMMA_DESCRIPTION_TXT[] ={L"Unable to get the list of lemma description for a given segment\n"};
    const wchar_t  MSG_CANT_GET_NUMBERS_TXT[] ={L"unable to get numbers of the segment"};
    const wchar_t  MSG_CANT_GET_NGRAMS_TXT[] ={L"unable to get ngrams of the segment"};
    const wchar_t  MSG_CANT_GET_NGRAMS_LINK_TXT[] ={L"unable to get ngrams link "};
    
    //------------------------------------------------------------------------
    //                  DATABASE
    //------------------------------------------------------------------------
    
    const wchar_t  MSG_TSQLCONNECTION_POINTER_NOT_VALID_TXT[] ={L"the pointer on the TSQLConnection object is not valid\n"};
    const wchar_t  MSG_TSQLQUERY_POINTER_NOT_VALID_TXT[] ={L"the pointer on the TSQLCQuery object is not valid\n"};
    const wchar_t  MSG_TSQLCONNECTION_POINTER_NOT_NULL_TXT[] ={L"the pointer on the TSQLConnection object is not null\n"};
    const wchar_t  MSG_TSQLQUERY_POINTER_NOT_NULL_TXT[] ={L"the pointer on the TSQLCQuery object is not null\n"};
    const wchar_t  MSG_SERVER_IS_ALREADY_CONNECTED_TXT[] ={L"the server is already connected\n"};
    const wchar_t  MSG_SERVER_IS_NOT_CONNECTED_TXT[] ={L"the server is not connected\n"};
    const wchar_t  MSG_CANT_CONNECT_DATABASE_TXT[] ={L"the connection of the database has failed\n"};
    const wchar_t  MSG_CANT_DISCONNECT_DATABASE_TXT[] ={L"the disconnection of the database has failed\n"};
    const wchar_t  MSG_DATABASE_IS_ALREADY_CONNECTED_TXT[] ={L"the database is already connected\n"};
    const wchar_t  MSG_DATABASE_IS_NOT_CONNECTED_TXT[] ={L"the database is not connected\n"};
    const wchar_t  MSG_CANT_CREATE_DATABASE_TXT[] ={L"the database creation request has failed\n"};
    const wchar_t  MSG_CANT_DELETE_DATABASE_TXT[] ={L"the database deletion request has failed\n"};
    const wchar_t  MSG_CANT_ATTACH_DATABASE_TXT[] ={L"the database attachment has failed\n"};
    const wchar_t  MSG_FILE_ALREADY_EXISTS_TXT[] ={L"the specified file already exists\n"};
    const wchar_t  MSG_FILE_DOESNT_EXIST_TXT[] ={L"the specified file doesn't exist\n"};
    const wchar_t  MSG_CANT_EXECUTE_SELECT_REQUEST_TXT[] ={L"the select request exection has failed\n"};
    const wchar_t  MSG_CANT_EXECUTE_REQUEST_TXT[] ={L"the request execution has failed\n"};
    const wchar_t  MSG_CANT_EXECUTE_SQL_SCRIPT_TXT[] ={L"the sql script execution has failed\n"};
    const wchar_t  MSG_CANT_START_TRANSACTION_TXT[] ={L"the start transaction has failed\n"};
    const wchar_t  MSG_CANT_COMMIT_TRANSACTION_TXT[] ={L"the transaction commit has failed\n"};
    const wchar_t  MSG_CANT_ROLLBACK_TRANSACTION_TXT[] ={L"the transaction rollback has failed\n"};
    const wchar_t  MSG_TRANSACTION_ALREADY_IN_PROGRESS_TXT[] ={L"a transaction is already in progress\n"};
    const wchar_t  MSG_NO_TRANSACTION_IN_PROGRESS_TXT[] ={L"no transaction is in progress\n"};
    const wchar_t  MSG_TSQLQUERY_IS_NOT_OPEN_TXT[] ={L"the TSQLQuery dataset is not open\n"};
    const wchar_t  MSG_HIDDB_CONVERSION_ERROR_TXT[] ={L"the hiddb conversion has failed\n"};
    const wchar_t  MSG_INTEGER_CONVERSION_ERROR_TXT[] ={L"the integer conversion has failed\n"};
    const wchar_t  MSG_WIDESTRING_CONVERSION_ERROR_TXT[] ={L"the widestring conversion has failed\n"};
    const wchar_t  MSG_CANT_CREATE_CONNECTION_COMPONENTS_TXT[] ={L"an error occured when creation connection components\n"};
    const wchar_t  MSG_SELECT_RESULT_IS_NULL_TXT[] ={L"the result of a select request is null\n"};
    const wchar_t  MSG_MORE_THAN_ONE_LEMMA_LINK_FOUND_TXT[] ={L"more than one lemma link is found\n"};
    const wchar_t  MSG_CANT_MOVE_CHUNK_TXT[] ={L"the chunk can't be moved\n"};
    const wchar_t  MSG_CANT_MOVE_SEGMENT_TXT[] ={L"the segment can't be moved\n"};
    const wchar_t  MSG_CANT_GET_CHUNK_IDS_OF_SEGMENT_TXT[] ={L"no chunk ids for a segment is found\n"};
    const wchar_t  MSG_CANT_FIND_TCLUES_OF_SEGMENT_TXT[] ={L"the segment clues is not found\n"};
    const wchar_t  MSG_CANT_GET_NGRAM_DESCRIPTION_TXT[] ={L"the ngram description is not found\n"};
    const wchar_t  MSG_CANT_CREATE_SEGMENT_TXT[] ={L"the segment can't be created\n"};
    const wchar_t  MSG_CANT_GET_LIST_OF_LEMMA_DESCRIPTION_FROM_SEGMENT_TXT[] ={L"the list of lemma description is not found\n"};
    
    //------------------------------------------------------------------------
    //                  PARSER
    //------------------------------------------------------------------------
    
    const wchar_t  MSG_PARSE_ERROR_TXT[] ={L"Error during Xelda Parsing\n"};
    const wchar_t  MSG_ERROR_AT_PARSER_OPENING_TXT[] ={L"Error during Xelda opening\n"};
    
    const wchar_t * const MessageIdent[NUMBER_OF_MESSAGES] =
    {
      L"",
      (wchar_t *)&MSG_DATABASE_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_CHUNK_MATCH_SCORE_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_CANT_SUPPRESS_OLD_CHUNK_LINKS_OF_SEGMENT_LINK_TXT,
      (wchar_t *)&MSG_CANT_GET_CHUNKS_OF_SEGMENT_TXT,
      (wchar_t *)&MSG_CHUNK_LIST_EMPTY_TXT,
      (wchar_t *)&MSG_UNABLE_TO_COMPUTE_CHUNK_MATCH_SCORE_WITH_LEMMA_TXT,
      (wchar_t *)&MSG_CANT_WRITE_CHUNK_LINK_IN_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_WRITE_LEMMA_LINK_IN_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_GET_OPTIONS_TXT,
      (wchar_t *)&MSG_INVALID_NUMBER_OF_SEGMENT_IN_ARGUMENT_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENT_CLUE_TXT,
      (wchar_t *)&MSG_CANT_GET_CLUE_OF_ALL_SEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENT_LAYOUT_TXT,
      (wchar_t *)&MSG_CANT_GET_LAYOUT_OF_ALL_SEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_EXTERNAL_SCORE_TXT,
      (wchar_t *)&MSG_CANT_GET_STATISTICS_OF_ALL_SEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENT_STATISTICS_TXT,
      (wchar_t *)&MSG_LANGUAGE_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_CANT_CLASSIFY_CHUNKS_OF_SEGMENT_TXT,
      (wchar_t *)&MSG_LANGUAGE_FORBIDDEN_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_CHUNK_MATCH_SCORE_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_MATCH_ZONE_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_MATCH_ZONE_SCORE_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_MARK_CLUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_CHUNK_TYPE_TXT,
      (wchar_t *)&MSG_CANT_GET_CHUNK_ID_OF_SEGMENT_TXT,
      (wchar_t *)&MSG_CANT_GET_CHUNK_DESCRIPTION_TXT,
      (wchar_t *)&MSG_INVALID_NUMBER_OF_CHUNK_IN_INPUT_TXT,
      (wchar_t *)&MSG_CANT_GET_LEMMA_LIST_OF_CHUNK_TXT,
      (wchar_t *)&MSG_CANT_GET_LEMMA_DESCRIPTION_TXT,
      (wchar_t *)&MSG_CANT_CONVERT_STRING_INTO_NUMBER_TXT,
      (wchar_t *)&MSG_CANT_SEARCH_LEMMA_LINK_FITTING_WITH_THRESHOLD_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_MATCHING_OF_WORD_BEGINNING_TXT,
      (wchar_t *)&MSG_CANT_SEARCH_TRANSLATION_FOR_A_LEMMA_TXT,
      (wchar_t *)&MSG_CANT_GET_LEMMA_LINKS_TXT,
      (wchar_t *)&MSG_CANT_GET_LEMMA_LINK_DESCRIPTION_TXT,
      (wchar_t *)&MSG_WORDS_ARE_BOTH_EMPTY_TXT,
      (wchar_t *)&MSG_CANT_REPLACE_DIACRITICS_CHARACTERS_TXT,
      (wchar_t *)&MSG_CANT_GET_NGRAMS_ID_TXT,
      (wchar_t *)&MSG_BAD_VALUE_FOR_WINDOW_WIDTH_CANDIDATE_DENOMINATOR_TXT,
      (wchar_t *)&MSG_CANT_GET_NGRAMS_DESCRIPTIONS_TXT,
      (wchar_t *)&MSG_INVALID_NGRAM_DEGREE_LIMIT_SETTINGS_TXT,
      (wchar_t *)&MSG_POINTER_SHOULD_BE_NULL_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENTS_IDS_TXT,
      (wchar_t *)&MSG_CANT_SEARCH_NGRAM_LINK_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_CHI_TEST_ON_NGRAM_LINK_TXT,
      (wchar_t *)&MSG_CANT_SET_NGRAM_LINK_TXT,
      (wchar_t *)&MSG_CANT_UPDATE_NGRAM_CLUES_IN_SEGMENTS_CONCERNED_BY_NGRAM_LINK_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_LOADOPTIONS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_GETBOOLEANVALUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_GETUINTVALUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_GETSHORTVALUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_GETSTRINGVALUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_GETLISTOFVALUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_SETBOOLEANVALUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_SETUINTVALUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_SETSTRINGVALUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_SETLISTOFVALUE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_OPTION_SAVEOPTIONS_TXT,
      (wchar_t *)&MSG_LOCAL_SERVER_NOT_EXIST_TXT,
      (wchar_t *)&MSG_CANT_OPEN_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_OPEN_ALIGNMENT_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_GET_DATABASE_FILENAME_TXT,
      (wchar_t *)&MSG_CANT_DISPLAY_OPENING_ALIGNMENT_DATABASE_MMI_TXT,
      (wchar_t *)&MSG_CANT_DISPLAY_SEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_CLOSE_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_ACTIVATE_ITEMS_AND_BUTTONS_TXT,
      (wchar_t *)&MSG_CANT_GET_DATA_IN_OPEN_DOCUMENTS_PAIRS_MMI_TXT,
      (wchar_t *)&MSG_CANT_ALIGN_DOCUMENTS_PAIRS_TXT,
      (wchar_t *)&MSG_BEGIN_ALIGNMENT_DOCUMENTS_PAIR_TXT,
      (wchar_t *)&MSG_END_ALIGNMENT_DOCUMENTS_PAIR_TXT,
      (wchar_t *)&MSG_CANT_OPEN_WAITING_MESSAGE_MMI_TXT,
      (wchar_t *)&MSG_CANT_CLOSE_WAITING_MESSAGE_MMI_TXT,
      (wchar_t *)&MSG_CANT_FETCH_SECTIONS_IN_INIFILE_TXT,
      (wchar_t *)&MSG_CANT_FETCH_KEYS_AND_VALUES_IN_INIFILE_TXT,
      (wchar_t *)&MSG_CANT_GET_STRING_VALUE_TXT,
      (wchar_t *)&MSG_CANT_GET_UINT_VALUE_TXT,
      (wchar_t *)&MSG_CANT_GET_BOOLEAN_VALUE_TXT,
      (wchar_t *)&MSG_CANT_WRITE_BOOLEAN_VALUE_TXT,
      (wchar_t *)&MSG_CANT_WRITE_UINT_VALUE_TXT,
      (wchar_t *)&MSG_CANT_WRITE_STRING_VALUE_TXT,
      (wchar_t *)&MSG_CANT_SET_STRING_VALUE_TXT,
      (wchar_t *)&MSG_CANT_SET_UINT_VALUE_TXT,
      (wchar_t *)&MSG_CANT_SET_BOOLEAN_VALUE_TXT,
      (wchar_t *)&MSG_CANT_WRITE_STRING_IN_INIFILE_TXT,
      (wchar_t *)&MSG_CANT_GET_STRING_LIST_TXT,
      (wchar_t *)&MSG_CANT_GET_CHUNKS_DESCRIPTION_OF_SEGMENT_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_DESCRIPTIONCHUNKSOFLANGUAGE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_EMPTYGRID_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_GETCOORDINATESFROMID_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_GETIDFROMCOORDINATES_TXT,
      (wchar_t *)&MSG_CANT_GET_COORDINATES_FROM_ID_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_GETSTATUS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_HIDEGRID_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_MOVECLOSERCHUNKSOFLINKS_TXT,
      (wchar_t *)&MSG_CANT_GET_ID_FROM_COORDINATES_TXT,
      (wchar_t *)&MSG_CANT_GET_STATUS_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_CHUNK_SELECTING_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_ONSELECTCHUNK_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_SETSTATUS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CHUNKVIEWER_SHOWGRID_TXT,
      (wchar_t *)&MSG_CANT_DISPLAY_CRITERIA_MMI_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_EDITCRITERIA_TXT,
      (wchar_t *)&MSG_CANT_DISPLAY_PARAMETERS_MMI_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_EDITPARAMETERS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_DEFAULTCRITERIAVALUES_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_DEFAULTPARAMETERSVALUES_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_APPLYCRITERIA_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_CRITERIAPARAMETERS_APPLYPARAMETERS_TXT,
      (wchar_t *)&MSG_CANT_CLOSE_CRITERIA_MMI_TXT,
      (wchar_t *)&MSG_CANT_CLOSE_DISPLAY_PARAMETERS_MMI_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_ACTIVATEITEMSANDBUTTONS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_OPENALIGNMENTDATABASE_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_DOCUMENTS_PAIRS_PROCESSING_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_PROCESSDOCUMENTSPAIRS_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_EQUIVALENTS_EXTRACTION_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EXTRACTSEGMENTSANDCHUNKSEQUIVALENTS_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_CHUNKS_EQUIVALENTS_EXTRACTION_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EXTRACTCHUNKSEQUIVALENTS_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_WORK_PROGRESS_ESTIMATION_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_WORKPROGRESS_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_EDIT_PARAMETERS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EDITPARAMETERS_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_EDIT_CRITERIA_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_EDITCRITERIA_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_SEGMENTS_VIEW_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWALLSEGMENTS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWNONALIGNEDSEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_CHUNKS_VIEW_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWALLCHUNKS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_VIEWNONALIGNEDCHUNKS_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_CLOSE_PROJECT_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_CLOSEPROJECT_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_QUIT_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_QUIT_TXT,
      (wchar_t *)&MSG_CANT_OPEN_ALIGNEMENT_DATABASE_MMI_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_GETALIGNEMENTDATABASEFILE_TXT,
      (wchar_t *)&MSG_CANT_OPEN_NEW_ALIGNEMENT_DATABASE_MMI_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_GETDOCUMENTSPAIRFILES_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_OPENQUITCONFIRMATION_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_OPENWAITINGMESSAGEWINDOW_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_MENUTOOLBARMANAGER_CLOSEWAITINGMESSAGEWINDOW_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENT_STATUS_TXT,
      (wchar_t *)&MSG_CANT_MANAGE_SEGMENT_SELECTING_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENT_DESCRIPTION_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENT_CHUNK_DESCRIPTION_TXT,
      (wchar_t *)&MSG_CANT_FIND_TARGET_SEGMENT_DESCRIPTION_OF_LINK_TXT,
      (wchar_t *)&MSG_CANT_FIND_TARGET_CHUNK_DESCRIPTION_OF_LINK_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_SETFOCUSONSEGMENTACCORDINGTONUMBER_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_ONSELECTSEGMENT_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_DISPLAYSEGMENTSOFLANGUAGE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_MOVECLOSERSEGMENTSOFLINKS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_SETSTATUS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GIVEINITIALPOSITION_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GETIDFROMCOORDINATES_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GETCOORDINATESFROMID_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_GETSTATUS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_SHOWGRID_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_HIDEGRID_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SEGMENTVIEWER_EMPTYGRID_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_WORKPROGRESSVIEWER_DISPLAYWORKPROGRESS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_WORKPROGRESSVIEWER_CLOSE_TXT,
      (wchar_t *)&MSG_CANT_GET_TOTAL_NUMBER_OF_SOURCE_SEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_GET_TOTAL_NUMBER_OF_TARGET_SEGMENTS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETTOTALNUMBEROFSEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_GET_NUMBER_OF_ALIGNED_SEGMENTS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETNUMBEROFALIGNEDSEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_GET_TOTAL_NUMBER_OF_SOURCE_CHUNKS_TXT,
      (wchar_t *)&MSG_CANT_GET_TOTAL_NUMBER_OF_TARGET_CHUNKS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETTOTALNUMBEROFCHUNKS_TXT,
      (wchar_t *)&MSG_CANT_GET_NUMBER_OF_ALIGNED_CHUNKS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_WORKPROGRESS_GETNUMBEROFALIGNEDCHUNKS_TXT,
      (wchar_t *)&MSG_CANT_DISCONNECT_SERVER_TXT,
      (wchar_t *)&MSG_CANT_CONNECT_SERVER_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SOFTWAREMANAGER_TERMINATION_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_SOFTWAREMANAGER_INITIALIZATION_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEALIGNMENTDATABASEOPENING_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEDOCUMENTSPAIRSPROCESSING_TXT,
      (wchar_t *)&MSG_CANT_FETCH_NUMBER_OF_ALIGNED_SEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_DISPLAY_WORK_PROGRESS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECHUNKSELECTING_TXT,
      (wchar_t *)&MSG_CANT_EDIT_PARAMETERS_TXT,
      (wchar_t *)&MSG_CANT_APPLY_PARAMETERS_CHANGES_TXT,
      (wchar_t *)&MSG_CANT_STORE_PARAMETERS_VALUES_IN_MEMORY_AND_INI_FILE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEEDITPARAMETERS_TXT,
      (wchar_t *)&MSG_CANT_EDIT_CRITERIA_TXT,
      (wchar_t *)&MSG_CANT_APPLY_CRITERIA_CHANGES_TXT,
      (wchar_t *)&MSG_CANT_STORE_CRITERIA_VALUES_IN_MEMORY_AND_INI_FILE_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEEDITCRITERIA_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGESEGMENTSVIEW_TXT,
      (wchar_t *)&MSG_CANT_EMPTY_CHUNK_GRID_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENT_ID_FROM_COORDINATES_TXT,
      (wchar_t *)&MSG_CANT_GET_LINK_ID_OF_SEGMENT_TXT,
      (wchar_t *)&MSG_CANT_GET_LINK_ID_OF_CHUNK_OF_SEGMENT_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENT_LINK_DESCRIPTION_TXT,
      (wchar_t *)&MSG_CANT_DISPLAY_CHUNKS_OF_SEGMENTS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECHUNKSVIEW_TXT,
      (wchar_t *)&MSG_CANT_EMPTY_SEGMENT_GRID_TXT,
      (wchar_t *)&MSG_CANT_HIDE_SEGMENT_GRID_TXT,
      (wchar_t *)&MSG_CANT_HIDE_CHUNK_GRID_TXT,
      (wchar_t *)&MSG_CANT_OPEN_QUIT_CONFIRMATION_TXT,
      (wchar_t *)&MSG_CANT_STOP_MEMORIA_MANAGER_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEQUIT_TXT,
      (wchar_t *)&MSG_CANT_MAKE_GLOBAL_PAIR_ALIGNMENT_PROCESS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEQUIVALENTSEXTRACTION_TXT,
      (wchar_t *)&MSG_CANT_GIVE_SEGMENT_INITIAL_POSITION_TXT,
      (wchar_t *)&MSG_CANT_GET_ALL_SOURCE_SEGMENTS_IDS_TXT,
      (wchar_t *)&MSG_CANT_GET_NON_ALIGNED_SOURCE_SEGMENTS_IDS_TXT,
      (wchar_t *)&MSG_CANT_FILL_SEGMENT_GRID_TXT,
      (wchar_t *)&MSG_CANT_FILL_CHUNK_GRID_TXT,
      (wchar_t *)&MSG_CANT_GET_ALL_TARGET_SEGMENTS_IDS_TXT,
      (wchar_t *)&MSG_CANT_GET_NON_ALIGNED_TARGET_SEGMENTS_IDS_TXT,
      (wchar_t *)&MSG_CANT_DISPLAY_TARGET_SEGMENT_OF_LANGUAGE_TXT,
      (wchar_t *)&MSG_CANT_MOVE_CLOSER_SEGMENTS_OF_LINKS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_DISPLAYSEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_FIND_SEGMENT_LINK_ID_FROM_SEGMENT_ID_TXT,
      (wchar_t *)&MSG_CANT_MAKE_SIMPLE_PAIR_ALIGNMENT_PROCESS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECHUNKSEQUIVALENTSEXTRACTION_TXT,
      (wchar_t *)&MSG_CANT_GET_ALL_SOURCE_CHUNKS_IDS_TXT,
      (wchar_t *)&MSG_CANT_GET_NON_ALIGNED_SOURCE_CHUNKS_IDS_TXT,
      (wchar_t *)&MSG_CANT_DISPLAY_SOURCE_CHUNKS_OF_LANGUAGE_TXT,
      (wchar_t *)&MSG_CANT_GET_ALL_TARGET_CHUNKS_IDS_TXT,
      (wchar_t *)&MSG_CANT_GET_NON_ALIGNED_TARGET_CHUNKS_IDS_TXT,
      (wchar_t *)&MSG_CANT_DISPLAY_TARGET_CHUNKS_OF_LANGUAGE_TXT,
      (wchar_t *)&MSG_CANT_GET_CHUNK_LINKS_IDS_FROM_SOURCE_AND_TARGET_SEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_GET_CHUNK_LINK_DESCRIPTION_TXT,
      (wchar_t *)&MSG_CANT_MOVE_CLOSER_CHUNKS_OF_LINKS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_DISPLAYCHUNKSOFSEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_ANALYSE_SOURCE_DOCUMENT_TXT,
      (wchar_t *)&MSG_CANT_ANALYSE_TARGET_DOCUMENT_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_ALIGNDOCUMENTSPAIRS_TXT,
      (wchar_t *)&MSG_CANT_FETCH_TOTAL_NUMBER_OF_SEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_FETCH_TOTAL_NUMBER_OF_CHUNKS_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGESEGMENTSELECTING_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGEWORKPROGRESSESTIMATION_TXT,
      (wchar_t *)&MSG_UNKNOWN_EXCEPTION_ALIGNER_MANAGECLOSEPROJECT_TXT,
      (wchar_t *)&MSG_CANCEL_TXT,
      (wchar_t *)&MSG_DEFAULT_VALUE_TAKEN_TXT,
      //----------------------------------------------------------------------------
      //              ANALYSER  ERROR MESSAGES
      //----------------------------------------------------------------------------
    
      (wchar_t *)&MSG_DOCUMENT_POINTER_NULL_TXT,
      (wchar_t *)&MSG_PARSER_POINTER_NULL_TXT,
      (wchar_t *)&MSG_CHUNKER_POINTER_NULL_TXT,
      (wchar_t *)&MSG_NGRAMER_POINTER_NULL_TXT,
      (wchar_t *)&MSG_SEGMENTATION_POINTER_NULL_TXT,
      (wchar_t *)&MSG_COMPUTING_FOR_ALIGNMENENT_POINTER_NULL_TXT,
      (wchar_t *)&MSG_ANNEX_FUNCTION_POINTER_NULL_TXT,
      (wchar_t *)&MSG_SEGMENTATION_CANNOT_SPLIT_INTO_SEGMENT_TXT,
      (wchar_t *)&MSG_SEGMENTATION_CANNOT_ADD_SPACE_IN_SEGMENT_TXT,
      (wchar_t *)&MSG_COMPUTING_FOR_ALIGNMENENT_CANNOT_MAKE_COMPUTE_TXT,
      (wchar_t *)&MSG_CHUNKER_CANNOT_SPLIT_INTO_CHUNK_TXT,
      (wchar_t *)&MSG_NGRAMER_CANNOT_SEARCH_NGRAM_TXT,
      (wchar_t *)&MSG_DOCUMENT_CANNOT_READ_BLOC_TXT,
      (wchar_t *)&MSG_PARSER_CANNOT_PARSE_BLOC_TXT,
      (wchar_t *)&MSG_NGRAMER_CANNOT_DELETE_NGRAM_DATABASE_TXT,
      (wchar_t *)&MSG_ANNEX_FUNCTION_CANNOT_EXCLUDE_LEM_DATABASE_TXT,
      (wchar_t *)&MSG_DOCUMENT_CANNOT_STOP_READER_TXT,
      (wchar_t *)&MSG_DOCUMENT_CANNOT_CLOSE_DOCUMENT_TXT,
      (wchar_t *)&MSG_DOCUMENT_THERE_IS_NO_BLOC_TXT,
      (wchar_t *)&MSG_DOCUMENT_NOT_ABLE_TO_OPEN_DOCUMENT_TXT,
      (wchar_t *)&MSG_DOCUMENT_NOT_ABLE_TO_START_READER_TXT,
      (wchar_t *)&MSG_DATABASE_CANNOT_ADD_SEGMENT_TXT,
      (wchar_t *)&MSG_OPTION_MANAGER_CANNOT_LOAD_TXT,
      (wchar_t *)&MSG_POINTER_SEGMENT_NULL_TXT,
      (wchar_t *)&MSG_MISSION_DATABASE_CANNOT_ERASE_NGRAMS_TXT,
      (wchar_t *)&MSG_DATABASE_CANNOT_EXCLUDE_LEM_TXT,
      (wchar_t *)&MSG_OPTION_MANAGER_CANNOT_LOAD_INFO_TXT,
    
      (wchar_t *)&MSG_CANT_INITIALIZE_READING_TXT,
      (wchar_t *)&MSG_CANT_GET_CASE_PROPERTY_TXT,
      (wchar_t *)&MSG_CANT_GET_FONT_PROPERTIES_TXT,
      (wchar_t *)&MSG_CANT_GET_BOLD_PROPERTY_TXT,
      (wchar_t *)&MSG_CANT_GET_ITALIC_PROPERTY_TXT,
      (wchar_t *)&MSG_CANT_GET_UNDERLINE_PROPERTY_TXT,
      (wchar_t *)&MSG_CANT_GET_FONT_SIZE_PROPERTY_TXT,
      (wchar_t *)&MSG_CANT_GET_FONT_NAME_PROPERTY_TXT,
      (wchar_t *)&MSG_CANT_GET_FOREGROUND_COLOR_PROPERTY_TXT,
      (wchar_t *)&MSG_CANT_GET_BACKGROUND_COLOR_PROPERTY_TXT,
      (wchar_t *)&MSG_CANT_DETERMINE_IF_PARAGRAPH_IS_IN_ARRAY_TXT,
      (wchar_t *)&MSG_CANT_START_WORD_API_TXT,
      (wchar_t *)&MSG_CANT_STOP_WORD_API_TXT,
      (wchar_t *)&MSG_CANT_OPEN_DOCUMENT_TXT,
      (wchar_t *)&MSG_CANT_CLOSE_DOCUMENT_TXT,
      (wchar_t *)&MSG_CANT_GO_TO_NEXT_BLOC_TXT,
      (wchar_t *)&MSG_CANT_GET_PARAGRAPH_LAYOUT_TXT,
      (wchar_t *)&MSG_CANT_CREATE_WORD_READER_TXT,
    
      //---------------------------------------------------------------
      //             ALIGNMENT
      //---------------------------------------------------------------
    
      (wchar_t *)&MSG_GRAMS_OCCURRENCE_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_ALIGNMENT_SEGMENT_BETWEEN_BOUNDS_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_CANT_GET_SOURCE_SEGMENT_NUMBER_TXT,
      (wchar_t *)&MSG_CANT_GET_TARGET_SEGMENT_NUMBER_TXT,
      (wchar_t *)&MSG_CANT_EXECUTE_NGRAMS_ALIGNMENT_TXT,
      (wchar_t *)&MSG_CANT_ALIGN_WITH_WINDOWS_TXT,
      (wchar_t *)&MSG_CANT_ALIGN_WITH_ANCHORS_TXT,
      (wchar_t *)&MSG_CANT_ALIGN_BY_STATISTIC_TXT,
      (wchar_t *)&MSG_CANT_GET_SOURCE_SEGMENT_ID_IN_MISSION_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_GET_TARGET_SEGMENT_ID_IN_MISSION_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_USED_CANDIDATE_FUNCTION_TXT,
      (wchar_t *)&MSG_CANT_GET_LIST_OF_TARGET_SEGMENT_ID_TXT,
      (wchar_t *)&MSG_CANT_GET_LIST_OF_SOURCE_SEGMENT_ID_TXT,
      (wchar_t *)&MSG_CANT_GET_LIST_OF_SOURCE_SEGMENT_ALIGNED_TXT,
      (wchar_t *)&MSG_CANT_GET_LIST_OF_TARGET_SEGMENT_ALIGNED_TXT,
      (wchar_t *)&MSG_CANT_GET_LIST_OF_SOURCE_SEGMENT_NOT_ALIGNED_TXT,
      (wchar_t *)&MSG_CANT_GET_LIST_OF_TARGET_SEGMENT_NOT_ALIGNED_TXT,
      (wchar_t *)&MSG_CANT_EXECUTE_SECURE_ANCHORS_TXT,
      (wchar_t *)&MSG_CANT_ALIGN_BETWEEN_BOUNDS_TXT,
      (wchar_t *)&MSG_CANT_EXECUTE_SECURE_ANCHORS_WITH_CANDIDATE_TXT,
      (wchar_t *)&MSG_CANT_INSERT_SEGMENT_RESULT_IN_MISSION_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_EXECUTE_LINGUISTIC_SCORE_TXT,
      (wchar_t *)&MSG_CANT_EXECUTE_SCTRUCTURE_SCORE_TXT,
      (wchar_t *)&MSG_CANT_INSERT_SEGMENT_IN_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_INSERT_CHUNK_IN_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_INSERT_LEMMA_IN_DATABASE_TXT,
      (wchar_t *)&MSG_MISSION_DATABASE_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_STRUCTURE_SEGMENT_ALIGNMENT_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_LINGUISTIC_SEGMENT_ALIGNMENT_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_POINTER_OF_LINGUISTIC_RESULT_UNABLE_TXT,
      (wchar_t *)&MSG_UNABLE_TO_GET_LINGUISTIC_RESULT_TXT,
      (wchar_t *)&MSG_UNABLE_TO_GET_STRUCTURAL_RESULT_TXT,
      (wchar_t *)&MSG_UNABLE_TO_INSERT_SEGMENT_LINK_TXT,
      (wchar_t *)&MSG_POINTER_OF_STRUCTURAL_RESULT_UNABLE_TXT,
      (wchar_t *)&MSG_ERROR_MISSION_DATABASE_CANNOT_CREATE_LEMMA_TXT,
      (wchar_t *)&MSG_ERROR_MISSION_DATABASE_CANNOT_SET_LEMMA_LINK_TXT,
      (wchar_t *)&MSG_ERROR_PARSER_MANAGER_CANNOT_GET_TRANSLATION_TXT,
      (wchar_t *)&MSG_ERROR_MISSION_DATABASE_CANNOT_GET_LEMMA_DESCRIPTION_TXT,
      (wchar_t *)&MSG_ERROR_MISSION_DATABASE_CANNOT_GET_LIST_LEMMA_ID_TXT,
      (wchar_t *)&MSG_ERROR_MISSION_DATABASE_POINTER_NULL_TXT,
      (wchar_t *)&MSG_INVALID_WINDOW_WIDTH_CANDIDATE_DENOMINATOR_SETTINGS_TXT,
      (wchar_t *)&MSG_GRAMS_OCCURENCE_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_SEARCH_TRANSLATION_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_CANT_RESET_NGRAMS_CLUES_IN_ALL_SEGMENTS_TXT,
      (wchar_t *)&MSG_CANT_REMOVE_OLD_SEGMENT_LINKS_TXT,
      (wchar_t *)&MSG_CANT_GET_ALL_SEGMENTS_IDS_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_LINGUISTIC_SCORE_ON_SEGMENT_LINK_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_STRUCTURAL_SCORE_ON_SEGMENT_LINK_TXT,
      (wchar_t *)&MSG_CANT_SELECT_SEGMENTS_TO_ALIGN_ACCORDING_TO_CLUES_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_NGRAMS_CLUES_TXT,
      (wchar_t *)&MSG_CANT_SET_TRANSLATION_FOR_LEMMAS_TXT,
      (wchar_t *)&MSG_CANT_SET_SEGMENT_LINK_IN_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_SET_CHUNK_LINK_IN_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_SET_LEMMA_LINK_IN_DATABASE_TXT,
      (wchar_t *)&MSG_ERROR_FOR_NUMBER_CLUE_TXT,
      (wchar_t *)&MSG_ERROR_FOR_NGRAM_CLUE_TXT,
      (wchar_t *)&MSG_ERROR_FOR_INTERNAL_CLUE_TXT,
      (wchar_t *)&MSG_ERROR_FOR_EXTERNAL_CLUE_TXT,
      (wchar_t *)&MSG_ERROR_CHECKING_POSITION_TXT,
      (wchar_t *)&MSG_CANT_UPDATE_SEGMENT_STATUS_TXT,
      (wchar_t *)&MSG_CANT_UPDATE_CHUNK_STATUS_TXT,
      (wchar_t *)&MSG_PROBLEM_GETTING_ELEMENT_DESCRIPTION_TXT,
      (wchar_t *)&MSG_ERROR_FINDING_LINK_TXT,
      (wchar_t *)&MSG_ERROR_GETTING_LINK_DESCRIPTION_TXT,
      (wchar_t *)&MSG_LIST_MUST_BE_OF_SAME_SIZE_TXT,
      (wchar_t *)&MSG_CANT_ALIGN_WINDOW_TXT,
      (wchar_t *)&MSG_CANT_COMPUTE_STATISTIC_SCORE_ON_SEGMENT_LINK_TXT,
      (wchar_t *)&MSG_WRONG_ALIGNMENT_TYPE_TXT,
      (wchar_t *)&MSG_CANT_GET_SEGMENT_LINK_IN_DATABASE_TXT,
    	(wchar_t *)&MSG_CANT_ALLOCATE_MATRIX_TXT,
     	(wchar_t *)&MSG_LEMMA_SCORE_POINTER_NOT_VALID_TXT,
    	(wchar_t *)&MSG_CANT_COMPUTE_LEMMA_SCORE_TXT,
    	(wchar_t *)&MSG_CANT_GET_LIST_OF_LEMMA_DESCRIPTION_TXT,
    	(wchar_t *)&MSG_CANT_GET_NUMBERS_TXT,
    	(wchar_t *)&MSG_CANT_GET_NGRAMS_TXT,
    	(wchar_t *)&MSG_CANT_GET_NGRAMS_LINK_TXT,
    
    //------------------------------------------------------------------------
    //                  DATABASE
    //------------------------------------------------------------------------
      (wchar_t *)&MSG_TSQLCONNECTION_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_TSQLQUERY_POINTER_NOT_VALID_TXT,
      (wchar_t *)&MSG_TSQLCONNECTION_POINTER_NOT_NULL_TXT,
      (wchar_t *)&MSG_TSQLQUERY_POINTER_NOT_NULL_TXT,
      (wchar_t *)&MSG_SERVER_IS_ALREADY_CONNECTED_TXT,
      (wchar_t *)&MSG_SERVER_IS_NOT_CONNECTED_TXT,
      (wchar_t *)&MSG_CANT_CONNECT_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_DISCONNECT_DATABASE_TXT,
      (wchar_t *)&MSG_DATABASE_IS_ALREADY_CONNECTED_TXT,
      (wchar_t *)&MSG_DATABASE_IS_NOT_CONNECTED_TXT,
      (wchar_t *)&MSG_CANT_CREATE_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_DELETE_DATABASE_TXT,
      (wchar_t *)&MSG_CANT_ATTACH_DATABASE_TXT,
      (wchar_t *)&MSG_FILE_ALREADY_EXISTS_TXT,
      (wchar_t *)&MSG_FILE_DOESNT_EXIST_TXT,
      (wchar_t *)&MSG_CANT_EXECUTE_SELECT_REQUEST_TXT,
      (wchar_t *)&MSG_CANT_EXECUTE_REQUEST_TXT,
      (wchar_t *)&MSG_CANT_EXECUTE_SQL_SCRIPT_TXT,
      (wchar_t *)&MSG_CANT_START_TRANSACTION_TXT,
      (wchar_t *)&MSG_CANT_COMMIT_TRANSACTION_TXT,
      (wchar_t *)&MSG_CANT_ROLLBACK_TRANSACTION_TXT,
      (wchar_t *)&MSG_TRANSACTION_ALREADY_IN_PROGRESS_TXT,
      (wchar_t *)&MSG_NO_TRANSACTION_IN_PROGRESS_TXT,
      (wchar_t *)&MSG_TSQLQUERY_IS_NOT_OPEN_TXT,
      (wchar_t *)&MSG_HIDDB_CONVERSION_ERROR_TXT,
      (wchar_t *)&MSG_INTEGER_CONVERSION_ERROR_TXT,
      (wchar_t *)&MSG_WIDESTRING_CONVERSION_ERROR_TXT,
      (wchar_t *)&MSG_CANT_CREATE_CONNECTION_COMPONENTS_TXT,
      (wchar_t *)&MSG_SELECT_RESULT_IS_NULL_TXT,
      (wchar_t *)&MSG_MORE_THAN_ONE_LEMMA_LINK_FOUND_TXT,
      (wchar_t *)&MSG_CANT_MOVE_CHUNK_TXT,
      (wchar_t *)&MSG_CANT_MOVE_SEGMENT_TXT,
      (wchar_t *)&MSG_CANT_GET_CHUNK_IDS_OF_SEGMENT_TXT,
      (wchar_t *)&MSG_CANT_FIND_TCLUES_OF_SEGMENT_TXT,
      (wchar_t *)&MSG_CANT_GET_NGRAM_DESCRIPTION_TXT,
      (wchar_t *)&MSG_CANT_CREATE_SEGMENT_TXT,
      (wchar_t *)&MSG_CANT_GET_LIST_OF_LEMMA_DESCRIPTION_FROM_SEGMENT_TXT,
    
    //------------------------------------------------------------------------
    //                  PARSER
    //------------------------------------------------------------------------
      (wchar_t *)&MSG_PARSE_ERROR_TXT,
      (wchar_t *)&MSG_ERROR_AT_PARSER_OPENING_TXT
    };
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    	class CMessage
    	{
    		public:
    			CMessage::CMessage();
    			CMessage::~CMessage();
    			wchar_t* CMessage::Message(message_id id);
    	};
    };
    //------------------------------------------------------------------------------
    
    #endif


    Jean Noël Martin

    samedi 31 janvier 2015 10:20
  • LinkDecription.h

    /*******************************************************************************
     * NOM: 
     * ROLE: 
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef LINK_DESCRIPTION_H
    #define LINK_DESCRIPTION_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Collections::Generic;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    	class CLinkDescription
    	{
    	public:
    		long long         llLinkID;                 //  Identifiant du lien
    		std::list<hidDB>  ListSourceID;             //  liste d'identifiants source
    		std::list<hidDB>  ListTargetID;             //  liste d'identifiants target
    		short             shProbability;            //  Probabilité du lien
    		enStatusM         Status;
    
    		CLinkDescription::CLinkDescription();
    		CLinkDescription::~CLinkDescription();
    	};
    };
    /*_____GLOBAL-DATA____________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    #endif /* LINK_DESCRIPTION_H */
    
    

    WordManager.h

    /*******************************************************************************
     * NOM: WordManager.h
     * ROLE:
     * HISTORIQUE:
        * 05/05/2001, yab, initial version
    *******************************************************************************/
    #ifndef WORDMANAGER_H
    #define WORDMANAGER_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    	enum
    	{
    		START_READER = 1,
    		STOP_READER,
    		OPEN_DOCUMENT,
    		CLOSE_DOCUMENT,
    		INITIALIZE_POINT_BLOC,
    		READ_BLOC,
    		GO_NEXT_BLOC
    	};
    /*_____CLASS-DEFINITION_______________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    	using namespace System::Runtime::InteropServices;
    	namespace Word = Microsoft::Office::Interop::Word;
    
    	public ref class CWManager
    	{
    	
    	public:
    		CWManager::CWManager();
    		CWManager::~CWManager();
    		void CWManager::OnDocumentOpen(void);
    		static Word::Application^ objApplication = gcnew Word::Application;
    		static Word::Document^ objDocument = gcnew Word::Document;
    		static Word::Documents^ objDocuments = objApplication->Documents;
    		static Word::Paragraphs^ objParagraphs;
    		static Word::Paragraph^ objParagraph;
    //		property objParagraph->Format^ ParagraphFormat;
    		erc CWManager::GetNbWords();
    		erc CWManager::StartWordApi();
    		erc CWManager::StopWordApi();
    		erc CWManager::OpenWordDocument( System::String^ wsFullPathName/*, Word::Application^ objApplication, Word::Document^ objDocument, Word::Documents^ objDocuments*/);
    		static void CWManager::StartDocAnalysis( System::ComponentModel::BackgroundWorker^  backgroundWorker1, System::String^ wsFullPathName, long ulNbWord, bool bNewDoc/*, Word::Application^ objApplication, Word::Document^ objDocument, Word::Documents^ objDocuments*/);
    		static void CWManager::CloseDocument( System::ComponentModel::BackgroundWorker^  backgroundWorker1, Word::Application^ objApplication, Word::Document^ objDocument, Word::Documents^ objDocuments);
    		erc CWManager::InitializePointBloc(bool & bIsTextEmpty);
    		erc CWManager::ReadBloc( CBlocM^ pBloc);
    		erc CWManager::GoNextBloc(bool & bIsEndOfText);
    	private:
    		
    	};
    }
    #endif

    ParserManager.h

    /*******************************************************************************
     * NOM: 
     * ROLE: 
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef PARSERMANAGER_H
    #define PARSERMANAGER_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    
    #define LEMMA_TRANSLATION_NUMBER 100
    #define LEMMA_SIZE 256
    #define WORD_NUMBER_OF_A_BLOC 5000
    
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    /*_____CLASS-DEFINITION_______________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    	enum class enParserManagerError
    	{
    		PARSE_BLOC = 1,
    		GET_TRANSLATIONS_OF_SOURCE_LEMMA
    	};
    	
    	ref class CParserManager
    	{
    		private :
    			enLanguageM m_Language;
    			void *m_pXeldaManager;
    		public :
    			CParserManager::CParserManager();
    			CParserManager::~CParserManager();
    			erc CParserManager::Brill_ParseBloc(  wchar_t * pBlocText, List<stAnalysedWordM^>^ pListAnalysedWord, unsigned long ulWordNumber, long iPos);
    			erc CParserManager::ParserAnalyse( List<stAnalysedWordM^>^ pListAnalysedWord, List< CAnalysedWordM^>^ pListWord, unsigned long ulWordNumber);
    			erc CParserManager::InitParserManager(enLanguageM Language);
    			void CParserManager::QualifPivot( stAnalysedWordM^ pListAnalysedWord, int ulWordNumber);
    			int CParserManager::BTranscodePartOfSpeech( char* NextStr, char* str, char* word, char* pPOS, char* pFlex, int* iStatus);
    			erc CParserManager::ParseBloc( wchar_t* wsBloc, List<CAnalysedWordM^>^ pListWord);
    			char* CParserManager::strtolower( char *str);
    	};
    };
    #endif /* PARSERMANAGER_H */
    
    

    chunker.h

    /*******************************************************************************
    * NOM: Chunker.h
    * ROLE:
    * HISTORIQUE:
    * 05/05/2003, yab, initial version
    *******************************************************************************/
    #ifndef CHUNKER_H
    #define CHUNKER_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    
    
    
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    #define OPTION_SECTION_CCHUNKER                               L"CCHUNKER"
    
    #define OPTION_KEYNAME_VERB_FRENCH                            L"VERB_FRENCH"
    #define OPTION_KEYNAME_NOUN_FRENCH                            L"NOUN_FRENCH"
    #define OPTION_KEYNAME_PRESTOPPER_FRENCH                      L"PRESTOPPER_FRENCH"
    #define OPTION_KEYNAME_POSTSTOPPER_FRENCH                     L"POSTSTOPPER_FRENCH"
    #define OPTION_KEYNAME_FUNCT_FRENCH                           L"FUNCT_FRENCH"
    #define OPTION_KEYNAME_LEMMA_NON_STOPPER_FRENCH               L"LEMMA_NON_STOPPER_FRENCH"
    
    
    #define OPTION_KEYNAME_VERB_ENGLISH                           L"VERB_ENGLISH"
    #define OPTION_KEYNAME_NOUN_ENGLISH                           L"NOUN_ENGLISH"
    #define OPTION_KEYNAME_PRESTOPPER_ENGLISH                     L"PRESTOPPER_ENGLISH"
    #define OPTION_KEYNAME_POSTSTOPPER_ENGLISH                    L"POSTSTOPPER_ENGLISH"
    #define OPTION_KEYNAME_FUNCT_ENGLISH                          L"FUNCT_ENGLISH"
    #define OPTION_KEYNAME_LEMMA_STOPPER_ENGLISH                  L"LEMMA_STOPPER_ENGLISH"
    
    
    #define OPTION_KEYNAME_VERB_SPANISH                           L"VERB_SPANISH"
    #define OPTION_KEYNAME_NOUN_SPANISH                           L"NOUN_SPANISH"
    #define OPTION_KEYNAME_PRESTOPPER_SPANISH                     L"PRESTOPPER_SPANISH"
    #define OPTION_KEYNAME_POSTSTOPPER_SPANISH                    L"POSTSTOPPER_SPANISH"
    #define OPTION_KEYNAME_FUNCT_SPANISH                          L"FUNCT_SPANISH"
    #define OPTION_KEYNAME_LEMMA_NON_STOPPER_SPANISH              L"LEMMA_NON_STOPPER_SPANISH"
    
    
    #define OPTION_KEYNAME_VERB_ITALIAN                           L"VERB_ITALIAN"
    #define OPTION_KEYNAME_NOUN_ITALIAN                           L"NOUN_ITALIAN"
    #define OPTION_KEYNAME_PRESTOPPER_ITALIAN                     L"PRESTOPPER_ITALIAN"
    #define OPTION_KEYNAME_POSTSTOPPER_ITALIAN                    L"POSTSTOPPER_ITALIAN"
    #define OPTION_KEYNAME_FUNCT_ITALIAN                          L"FUNCT_ITALIAN"
    #define OPTION_KEYNAME_LEMMA_NON_STOPPER_ITALIAN              L"LEMMA_NON_STOPPER_ITALIAN"
    
    
    #define OPTION_KEYNAME_VERB_GERMAN                            L"VERB_GERMAN"
    #define OPTION_KEYNAME_NOUN_GERMAN                            L"NOUN_GERMAN"
    #define OPTION_KEYNAME_PRESTOPPER_GERMAN                      L"PRESTOPPER_GERMAN"
    #define OPTION_KEYNAME_POSTSTOPPER_GERMAN                     L"POSTSTOPPER_GERMAN"
    #define OPTION_KEYNAME_FUNCT_GERMAN                           L"FUNCT_GERMAN"
    #define OPTION_KEYNAME_LEMMA_NON_STOPPER_GERMAN               L"LEMMA_NON_STOPPER_GERMAN"
    
    /*_____GLOBAL-TYPES___________________________________________________________*/
    
    /*_____GLOBAL-DATA____________________________________________________________*/
    
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    
    /*_____CLASS-DEFINITION_______________________________________________________*/
    	enum class enCChunkerMethod
        {
    		SPLIT_INTO_CHUNK =1,
        };
    
    	ref class CChunker
    	{
    		private:
    			List<enPOSM> m_ListPosVerb;                 //Pos List for verb chunk type
    			List<enPOSM> m_ListPosNoun;                 //Pos List for noun chunk type
    			List<enPOSM> m_ListPostStopper;             //Pos List for poststopper chunk type
    			List<enPOSM> m_ListPreStopper;              //Pos List for prestopper chunk type
    			List<enPOSM> m_ListPosFunct;                //Pos List for function chunk type
    			List<System::String^>^ pm_wsListLemmaNonStopper;//Lemma Stopper list
        
    		public:
    			CChunker::CChunker();
    			CChunker::~CChunker();
    			enPOSM^ CChunker::TestPosType( CAnalysedWordM^ pWord);
    			erc CChunker::SplitIntoChunk( CAnalysedSegmentM^ pSegment, System::String^ id);
    			CAnalysedChunkM^ CChunker::AnalyseCurrentVerbSyntagme( CLinguisticSegmentM^ pLinguisticSegment, List<CAnalysedWordM^>::Enumerator itWord, CAnalysedChunkM^ pCurrentChunk, int& Step, enPOSM^ DrivingPos, bool bMarkOngoing, bool bPivotPending);
    			CAnalysedChunkM^ CChunker::AnalyseCurrentNounSyntagme( CLinguisticSegmentM^ pLinguisticSegment, List<CAnalysedWordM^>::Enumerator itWord, CAnalysedChunkM^ pCurrentChunk, int & Step, enPOSM^ DrivingPos, bool bMarkOngoing, bool bPivotPending);
    			CAnalysedChunkM^ CChunker::InitiateCurrentNounSyntagme( CLinguisticSegmentM^ pLinguisticSegment, List<CAnalysedWordM^>::Enumerator itWord, CAnalysedChunkM^ pCurrentChunk, int& Step, enPOSM^ DrivingPos, bool bMarkOngoing, bool bPivotPending);
    			CAnalysedChunkM^ CChunker::ProcessCurrentDeclencheur( int& Step, enPOSM^ Curpos, CAnalysedChunkM^ pCurrentChunk, List<CAnalysedWordM^>::Enumerator itWord, enPOSM^ DrivingPos, bool& processed, bool& bIsPalned);
    			CAnalysedChunkM^ CChunker::ProcessCurrentFunct( int& Step, enPOSM^ Curpos, CAnalysedChunkM^ pCurrentChunk, List<CAnalysedWordM^>::Enumerator itWord, CAnalysedWordM^ pNextWord, enPOSM^ DrivingPos, bool& processed, int& nNum, int& nColor);
    			CAnalysedChunkM^ CChunker::ProcessCurrentOther( int& Step, enPOSM^ Curpos, bool& processed, CAnalysedChunkM^ pCurrentChunk, List<CAnalysedWordM^>::Enumerator itWord, enPOSM^ DrivingPos, int& nColor);
    			CAnalysedChunkM^ CChunker::InitiateCurrentVerbSyntagme( CLinguisticSegmentM^ pLinguisticSegment, List<CAnalysedWordM^>::Enumerator itWord, CAnalysedChunkM^ pCurrentChunk, int& Step, enPOSM^ DrivingPos, bool bMarkOngoing, bool bPivotPending);
    			bool CChunker::SwitchBaseName( enPOSM Curpos, CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pPreviousWord, CAnalysedWordM^ pWord, CAnalysedWordM^  pNextWord, CAnalysedWordM^  p2NextWord, CAnalysedWordM^  p3NextWord, int& Step, int& nColor, int& nMark, int& nNamed, int& assoonas);
    			bool CChunker::SwitchName( enPOSM Curpos, CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, CAnalysedWordM^ pNextWord, CAnalysedWordM^ p2NextWord, int& Step, int& nNum, enPOSM^ DrivingPos);
    			bool CChunker::SwitchBaseVerb( enPOSM Curpos, CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, CAnalysedWordM^ pNextWord, CAnalysedWordM^ p2NextWord, CAnalysedWordM^ p3NextWord, int& Step, int& assoonas, enPOSM^ DrivingPos, int& nNum);
    			bool CChunker::SwitchVerb( enPOSM Curpos, CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, CAnalysedWordM^ pNextWord, CAnalysedWordM^ p2NextWord, int& Step, enPOSM^ DrivingPOs);
    
    			//                                1                              2                      3                          4                          5                           6                           7
    			void CChunker::CaseNounForNoun( CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, CAnalysedWordM^ pNextWord, CAnalysedWordM^ p2NextWord, CAnalysedWordM^ p3NextWord, CAnalysedWordM^ p4NextWord, int& Step );
    			void CChunker::CaseNbForNoun( CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord,  CAnalysedWordM^ pNextWord,  CAnalysedWordM^ p2NextWord, int& Step, int& nNum);
    			void CChunker::CaseEntityForNoun( CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, CAnalysedWordM^ pNextWord, CAnalysedWordM^ p2NextWord, CAnalysedWordM^ p3NextWord, CAnalysedWordM^ p4NextWord, int& Step, int& nNamed);
    			void CChunker::InitiateCurrentFunct( int& Step, CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, enPOSM^ DrivngPos, enPOSM^ Curpos, bool& processed);
    			//                                          1          2                               3                      4                5               6
    			void CChunker::InitiateCurrentDeclencheur( int& Step, CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, bool& processed, enPOSM^ Curpos, enPOSM^ DrivingPos);
    			void CChunker::InitiateCurrentOther( int& Step, enPOSM^ Curpos, bool& processed, CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, enPOSM^ DrivingPos, int& nNum);
    			CAnalysedChunkM^ CChunker::PoseStopmark( CAnalysedSegmentM^ pSegment, CAnalysedWordM^ pWord);
    			CAnalysedChunkM^ CChunker::SetChunk( CAnalysedChunkM^ pCurrentChunk, CAnalysedSegmentM^ pSegment, enPOSM^ DrivingPos);
    			bool CChunker::IsSameChunkType( enChunkTypeM TypeOfPreviousWord, CAnalysedWordM^ pWord);
    			void CChunker::InitiateCurrentOther( int& Step, enPOSM^ Curpos, bool &processed, CAnalysedChunkM^ pCurrentChunk, CAnalysedWordM^ pWord, CAnalysedWordM^ pNextWord, CAnalysedWordM^ p2NextWoird, enPOSM^ DrivingPos);
    			enChunkTypeM^ CChunker::NewPosType(CAnalysedWordM^ pWord, CAnalysedWordM^ pNextWord);
    			CAnalysedWordM^ CChunker::SetMark( System::String^ wsMark, enPOSM POS, int len);
    			void CChunker::InitiateChunk( enPOSM^ DrivingPos, enChunkTypeM^ ChunkType, CAnalysedSegmentM^ pSegment, CAnalysedChunkM^ pPreviousChunk, CAnalysedChunkM^ pCurrentChunk);
    			void CChunker::TerminateChunk( CAnalysedWordM^ pWord, CAnalysedChunkM^ pChunk, int iSize, CAnalysedSegmentM^ pSegment);
    	};
    };
    #endif /* CHUNKER_H */

    StrConv.h

    //---------------------------------------------------------------------------
    #ifndef StrConvH
    #define StrConvH
    //---------------------------------------------------------------------------
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    	ref class CStrConv
    	{
    	private:
    	public:
    		CStrConv::CStrConv();
    		CStrConv::~CStrConv();
    		static unsigned long long CreateReturnCode( enTYPEM iType, int iMessageCode, enModuleIDM iModuleId, int iClassId, int iFunctionId, enError iReturnFunction);
    		void CStrConv::ChangeMsgRc(int iType, int iMessageCode, unsigned __int64 *pdwReturnCode);
    		wchar_t* CStrConv::wuncode ( char *orig);
    		void CStrConv::WideToChar ( std::wstring in , char *out);
    		int CStrConv::FindUnderscore( char* pWord);
    		wchar_t* CStrConv::NormString( const wchar_t* String);
    		bool CStrConv::isOdd( float data);
    		static void CStrConv::StrFreeA(char * s);
    		static void CStrConv::StrFreeW(wchar_t * s);
    		static char* CStrConv::awcstombs(wchar_t  *sczW);
    		static wchar_t* CStrConv::ambstowcs(char const *sczA);
    		static char* CStrConv::StrAllocThrowA(size_t cchSize);
    		void CStrConv::StrWcharCpy( char* pText, wchar_t* pWchar);
    		char* CStrConv::StrAlpha( char* pWord);
    		static struct SplittM CStrConv::StrToNextSection( char* pWord, char cSplit1, char cSplit2);
    		int CStrConv::FindDash( char* pWord);
    		float CStrConv::FindUppercase( char* pWord);
    		int CStrConv::CountUppercase( char* pWord);
    		bool CStrConv::HasNum( char*pText);
    		int CStrConv::findln( char* ptr);
    	};
    };
    #endif
    

    Event.h

    /*******************************************************************************
    * FILE NAME: Event.h
    * PURPOSE:   This file contains class definitions of CEvent class.
    * HISTORY:
    * Date        Version                   Author
    * 14/05/2003  initial version :1.0      Shridhar
    *******************************************************************************/
    
    #ifndef EventH
    #define EventH
    //---------------- CLASS DEFINITIONS OF CEvent----------------------------------
    //--------------------------- INCLUDE-FILES ------------------------------------
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    	using namespace std;
    	ref class CEvent
    	{
    		public:         // User declarations
    			CEvent::CEvent();
    			CEvent::~CEvent();
    			unsigned long long CEvent::PopEventMessage(unsigned long long dwReturnCodeId, ...);
    			unsigned long long CEvent::SetEventMessage(unsigned long long dwReturnCodeId, ...);
    			unsigned long long CEvent::GetEventMessage(std::wstring *psMessageBuffer, unsigned long long *pdwReturnCodeId, ...);
    			unsigned long long CEvent::HandleEventLog(unsigned long long dwReturnCodeId, ...);
    	};    // End of CEvent class definition
    };
    
    //------------------------------------------------------------------------------
    
    #endif
    

    Option.h

    /*******************************************************************************
     * FILE NAME: Option.h
     * PURPOSE:   This file contains class definitions of COption class.
     * HISTORY:
     * Date        Version                   Author
     * 14/05/2003  initial version :1.0      Shrawani
    *******************************************************************************/
    
    #ifndef OptionDLLH
    #define OptionDLLH
    #define LIST_DELIMITER L","
    //--------------------------- INCLUDE-FILES ------------------------------------
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    	using namespace std;
    
    //---------------- CLASS DEFINITIONS OF COption---------------------------------
    	enum class enOption
    	{
    		UTILITY_OPTION_MANAGER_COPTION_METHOD
    	};
    
    	// List of the type stOPTIONSTRUCTURE
    	enum class COptionMethod
    	{
    		LOAD_OPTIONS,
    		GET_BOOLEAN_VALUE,
    		GET_UINT_VALUE,
    		GET_SHORT_VALUE,
    		GET_STRING_VALUE,
    		GET_LIST_OF_VALUE,
    		SET_BOOLEAN_VALUE,
    		SET_UINT_VALUE,
    		SET_STRING_VALUE,
    		SET_LIST_OF_VALUE,
    		SAVE_OPTIONS,
    		GET_STRING_LIST
    	};
    
    	ref class COption
    	{
    	public:
    		COption::COption();
    		FILE* COption::initOption( FILE*);
    		COption::~COption();
    		static unsigned long long COption::LoadOptions();
    		static unsigned long long COption::GetBooleanValue( System::String^ sSectionName, System::String^ sKeyName, bool bDefaultValue, bool *pbValue);
    		static unsigned long long COption::GetUIntValue( System::String^ sSectionName, System::String^ sKeyName, unsigned int dwDefaultValue, unsigned int *pdwValue);
    		static unsigned long long COption::GetShortValue( System::String^ sSectionName, System::String^ sKeyName, short dwDefaultValue, short *pdwValue);
    		static unsigned long long COption::GetStringValue( System::String^ sSectionName, System::String^ sKeyName, System::String^ sStrDefaultValue, std::wstring *psStrValue);
    		static unsigned long long COption::GetListOfValue(List<stElementDescriptionM^>^ pstListOptionEx);
    		static unsigned long long COption::SetBooleanValue( System::String^ sSectionName, System::String^ sKeyName, bool bValue);
    		static unsigned long long COption::SetUIntValue( System::String^ sSectionName, System::String^ sKeyName, unsigned int dwValue);
    		static unsigned long long COption::SetStringValue( System::String^ sSectionName, System::String^ sKeyName, wstring sStrValue);
    		static unsigned long long COption::SetListOfValue( List<stElementDescriptionM^> stListOptionEx);
    		static unsigned long long COption::SaveOptions();
    		static unsigned long long COption::SetListOfValue( List<stElementDescriptionM^>^ pstListOptionEx);
    		static unsigned long long COption::GetStringList( System::String^ sSectionName, System::String^ sKeyName, List<System::String^>^ pwsDefaultList, List<System::String^>^ pwsList);
    	};   // End of COption class definition
    };
    
    //------------------------------------------------------------------------------
    #endif


    Jean Noël Martin

    samedi 31 janvier 2015 10:33
  • Suite des headers

    Exception.h

    //---------------------------------------------------------------------------
    #ifndef ExceptionH
    #define ExceptionH
    //---------------------------------------------------------------------------
    class Doc_exception : public std::exception
    {
    public:
        Doc_exception::Doc_exception( const char * Msg, int Line );
        Doc_exception::~Doc_exception() throw();
        const char * Doc_exception::what() const throw();
    private:
        std::string msg;
    };
    
    class BlockingException : public std::exception
    {
    public:
       BlockingException::BlockingException( const char * Msg, int Line );
       BlockingException::~BlockingException()  throw();
       const char * BlockingException::what() const throw();
    private:
        std::string msg;
    };
    #endif
    

    Segmentation.h

    /*******************************************************************************
     * NOM: Segmentation.h
     * ROLE: Split into segment a list of word
     * HISTORIQUE:
     * 25/05/2003, yab, initial version
    *******************************************************************************/
    #ifndef SEGMENTATION_H
    #define SEGMENTATION_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    
    
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    #define OPTION_SECTION_CSEGMENT                               L"CSEGMENT"
    #define OPTION_KEYNAME_LIST_END_SENT                          L"LIST_END_SENT"
    
    #define SPACE_WORD                                            L" "
    #define SPACE_LEMMA                                           L"SpLem"
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    
    /*_____CLASS-DEFINITION_______________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    	enum class enCSegmentationMethod
    	{
    		SPLIT_INTO_SEGMENT =1,
    		ADD_SPACE,
    	};
    
    	ref class CSegmentation
    	{
    		private :
    			List<enPOSM> m_ListEndSentPos;
    		public:
    			CSegmentation();
    			~CSegmentation();
    			static erc SplitIntoSegment( enLanguageM Language, List<CAnalysedWordM^>^  pListWord, List<CAnalysedSegmentM^>^ pListSegment);
    			erc AddSpaces( CLinguisticSegmentM^ pLinguisticSegment);
    	};
    };
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    #endif /* SEGMENTATION_H */

    Database.h

    /*******************************************************************************
     * NOM:
     * ROLE:
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef DATABASE_H
    #define DATABASE_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    
    typedef unsigned short sidDB;
    
    // Database limits
    #define MAX_JOIN            40 // Nombre maximum de jointure (correction FA 37)
    
    // Key word for request
    #define SELECT              L"SELECT "
    #define DELETEFROM          L"DELETE FROM "
    #define STAR                L"*"
    #define INSERT              L"INSERT INTO "
    #define VALUES              L" VALUES"
    #define UPDATE              L"UPDATE "
    #define SET                 L" SET "
    #define FROM                L" FROM "
    #define WHERE               L" WHERE "
    #define DANS                L" IN "
    #define ORDERBY             L" ORDER BY "
    #define AND                 L" AND "
    #define OR                  L" OR "
    #define PB                  L"("
    #define PE                  L")"
    #define CO                  L","
    #define QM                  L"'"
    #define Q2M                 L"\""
    #define EQ                  L" = "
    #define DOT                 L"."
    #define COUNTSTAR           L"COUNT(*)"
    #define COUNT_PB_DIST       L"COUNT (DISTINCT "
    #define SUM_PB              L"SUM("
    #define ISNULL              L" IS NULL"
    #define NULLVALUE           L"NULL"
    #define NULLVAL             L"null"
    #define BLANK               L" "
    #define ASRESULT            L" as LM_Result"
    
    #define DIFFERENT           L" <> "
    #define GREATER             L" > "
    #define LOWER               L" < "
    #define GREATER_EQ          L" >= "
    #define LOWER_EQ            L" <= "
    
    #define INC1                L" + 1"
    
    #define ZEROVALUE           0
    
    // Lemma status
    #define LEM_ST_NOT_EXCLUDED 0
    #define LEM_ST_EXCLUDED     1
    
    // Word  and NGram occurence
    #define FIRST_OCCURRENCE    1
    #define FIST_OCCURRENCE    L"1"
    
    // Segment alignment status
    #define SEG_AL_ST_UNDEF     0
    #define SEG_AL_ST_EXCLUDED  1
    #define SEG_AL_ST_NOALIGNED 2
    #define SEG_AL_ST_ALIGNED   3
    #define SEG_ST_NOALIGNED L"2"
    // Chunk alignment status
    #define CHK_AL_ST_UNDEF     0
    #define CHK_AL_ST_EXCLUDED  1
    #define CHK_AL_ST_NOALIGNED 2
    #define CHK_AL_ST_ALIGNED   3
    #define CHK_AL_NOALIGNED L"2"
    // Segment link alignment status
    #define SEG_LNK_AL_ST_UNDEF 0
    #define SEG_LNK_AL_ST_MANU  1
    #define SEG_LNK_AL_ST_AUTO  2
    
    // Chunk link alignment status
    #define CHK_LNK_AL_ST_UNDEF 0
    #define CHK_LNK_AL_ST_MANU  1
    #define CHK_LNK_AL_ST_AUTO  2
    
    // General Values For AlignmentStatus
    #define AL_ST_UNDEF      0
    #define AL_ST_EXCLUDED   1
    #define AL_ST_NOALIGNED  2
    #define AL_ST_MANU       3
    #define AL_ST_AUTO       4
    #define AL_ST_FORMER     5
    
    
    // Group values
    #define GRP_FALSE 0
    #define GRP_TRUE  1
    
    // Key word for table names
    #define WI_TABLE            L"T_WORK_INFORMATION"
    #define SC_TABLE            L"T_SEG_CHUNK"
    #define SW_TABLE            L"T_SEG_WORD"
    #define WORD_TABLE          L"T_WORD"
    #define LEM_TABLE           L"T_LEMMA"
    #define ELEMENT_CHK         L"T_ELEMENT_CHK"
    #define ELEMENT_LNK_TABLE   L"T_ELEMENT_LINKS"
    #define ELEMENT_TABLE       L"T_ELEMENT_SEMANTIQUE"
    #define SEG_TABLE           L"T_SEGMENT"
    #define CLUES_TABLE         L"T_CLUES"
    #define LAYOUT_TABLE        L"T_LAYOUT"
    #define CHK_TABLE           L"T_CHUNK"
    #define CT_TABLE            L"T_CHUNK_TYPE"
    #define CW_TABLE            L"T_CHUNK_WORD"
    #define PARA_TABLE          L"T_PARAGRAPH"
    
    // Key word for attributes of table CLUES
    #define CLUES_ID_CLUES      L"nuIdClues"
    #define CLUES_EXT_SCORES    L"siExternalScore"
    #define CLUES_INT_SCORES    L"siInternalScore"
    #define CLUES_NB_NGRAM      L"siNbNgram"
    #define CLUES_NB_NUMBER     L"siNbNumber"
    
    // Key word for attributes of table LAYOUT
    #define LAYOUT_ID_LAYOUT      L"nuIdLayout"
    #define LAYOUT_IN_ARRAY       L"cInArray"
    #define LAYOUT_ID_STYLE_NAME  L"siIdStyleName"
    #define LAYOUT_ID_FONT_NAME   L"siIdFontName"
    #define LAYOUT_FONT_SIZE      L"siFontSize"
    #define LAYOUT_BOLD           L"cBold"
    #define LAYOUT_ITALIC         L"cItalic"
    #define LAYOUT_UNDERLINE      L"cUnderline"
    #define LAYOUT_UPPERCASE      L"cUpperCase"
    #define LAYOUT_FG_COLOR       L"iFGColor"
    #define LAYOUT_BG_COLOR       L"iBGColor"
    
    // Key word for attributes of table STYLE_NAME
    #define STYLE_N_ID_STYLE_NAME L"siIdStyleName"
    #define STYLE_N_LABEL          L"vcLabel"
    
    // Key word for attributes of table FONT_NAME
    #define FONT_N_ID_FONT_NAME   L"siIdFontName"
    #define FONT_N_LABEL          L"vcLabel"
    
    // Key word for attributes of table SEGMENT
    #define SEG_ID_SEG          L"nuIdSeg"
    #define SEG_TYPE            L"cType"
    #define SEG_ALIGN_STATUS    L"cAlignStatus"
    #define SEG_NOT_RECOMPOSED  L"cNotRecomposed"
    #define SEG_COVERAGE        L"siCoverage"
    #define SEG_INIT_POS        L"iInitPos"
    #define SEG_SIZE_IN_CHAR    L"siSizeInChar"
    #define SEG_SIZE_IN_WORDS   L"siSizeInWords"
    #define SEG_ID_PREV         L"nuIdPrev"
    #define SEG_ID_NEXT         L"nuIdNext"
    #define SEG_ID_LAYOUT       L"nuIdLayout"
    #define SEG_ID_CLUES        L"nuIdClues"
    #define SEG_ID_DOC          L"siIdDoc"
    #define SEG_TYPE_DOC        L"siIdTypD"
    #define SEG_ID_LANG         L"siIdLang"
    
    // Key word for attributes of table SEGMENT_WORD
    #define SW_ID_SEG_WORD      L"nuIdSegWord"
    #define SW_ID_SEG           L"nuIdSeg"
    #define SW_ID_WORD          L"nuIdWord"
    #define SW_WORD_RANK        L"siWordRank"
    #define SW_CHUNK_NUM        L"siChunkNum"
    #define SW_ID_LAYOUT        L"nuIdLayout"
    #define SW_WORD_ADAPT       L"cWordAdapted"
    
    // Key word for attributes of table SEG_CHUNK
    #define SC_ID_SEG_CHK       L"nuIdSegChk"
    #define SC_ID_SEG           L"nuIdSeg"
    #define SC_ID_CHUNK         L"nuIdChunk"
    #define SC_INIT_POS         L"iInitPos"
    #define SC_ID_PREV          L"nuIdPrev"
    #define SC_ID_NEXT          L"nuIdNext"
    #define SC_MATCH_STATUS     L"cMatchStatus"
    #define SC_ALIGN_STATUS     L"cAlignStatus"
    
    // Key word for attributes of table T_SEG_ELEMENT
    #define SN_ID_SEGNGRAM      L"nuIdSegNGram"
    #define SN_ID_SEG           L"nuIdSeg"
    #define SN_ID_NGRAM         L"nuIdNGram"
    
    // Key word for attributes of table SEG_GROUP
    #define SG_ID_SEGGRP        L"nuIdSegGrp"
    #define SG_ID_GRP           L"nuIdGrpSeg"
    #define SG_ID_SEG           L"nuIdSeg"
    #define SG_SEG_RANK         L"siSegRank"
    
    // Key word for attributes of table ELEMENT_SEMANTIQUE
    #define SEMANTIQUE_ID_ELEMN L"nuIdElemn"
    #define TYPE_ELEMENT        L"nuIdTypeElement"
    #define SN_NB_CHUNK         L"SiNbChunk"
    #define ELEMENT_OCCURRENCE  L"NuIdOccurence"
    #define NU_ID_PAR           L"NuIdPar"
    #define VC_NAME             L"vcName"
    #define WS_TEXTE            L"wsText"
    #define ELMN_FONCTIONNEMENT L"NuIdFonctionnelement"
    #define ELEMENT_ID_DOC      L"siIdD"
    #define ELEMENT_ID_LANG     L"siIdLang"
    
    
    // Key word for attributes of table ELEMENT_WORD
    #define NW_ID_ELEMENT_WORD  L"nuIdElemntWord"
    #define NW_ID_ELEMENT       L"nuIdElemnt"
    #define NW_ID_WORD          L"nuIdWord"
    #define NW_STRING           L"vcString"
    #define NW_ID_POS           L"siIdPOS"
    #define NW_WORD_RANK        L"siWordRank"
    
    // Key word for attributes of table ELEMENT_CHK
    #define EC_ID_ELEMN_CHK     L"nuIdElemnChk"
    #define EC_ID_ELEMN         L"nuIdElemn"
    #define EC_ID_CHK           L"nuIdChunk"
    #define EC_CHUNK_RANK       L"siChkRank"
    
    // Key word for attributes of table ELEMENT_LINKS
    #define NL_ID_ELEMN_LNK     L"nuIdElemnLink"
    #define NL_ID_ELEMN_SRC     L"nuIdElemnSrc"
    #define NL_ID_PARAGRAPH     L"nuIdParagraph"
    #define NL_ID_DOC           L"iIdDoc"
    #define VC_NAME             L"vcName"
    
    // Key word for attributes of table CHUNK
    #define CHK_ID_CHK          L"nuIdChunk"
    #define CHK_NB_WORD         L"siNbWord"
    #define CHK_ID_CHK_TYPE     L"nuIdChunkType"
    #define CHK_TEXT            L"vcText"
    #define CHK_ID_CHK_DRV_POS  L"nuIdDrivingPos"
    #define CHK_ID_LANG         L"siIdLang"
    
    // Key word for attributes of table CHUNK_TYPE
    #define CT_ID_CHK_TYPE      L"nuIdChunkType"
    #define CT_LABEL            L"vcLabel"
    
    // Key word for attributes of table CHUNK_WORD
    #define CW_ID_CHK_WORD      L"nuIdChkWord"
    #define CW_ID_CHUNK         L"nuIdChunk"
    #define CW_ID_WORD          L"nuIdWord"
    #define CW_STRING           L"vcString"
    #define CW_ID_POS           L"siIdPOS"
    #define CW_WORD_RANK        L"siWordRank"
    
    // Key word for attributes of table CHUNK_GROUP
    #define CG_ID_CHKGRP        L"nuIdChkGrp"
    #define CG_ID_GRP           L"nuIdGrpChunk"
    #define CG_ID_CHUNK         L"nuIdChunk"
    #define CG_CHUNK_RANK       L"siChkRank"
    
    // Key word for attributes of table WORD
    #define WORD_ID_WORD        L"nuIdWord"
    #define WORD_STRING         L"vcString"
    #define WORD_ID_POS         L"siIdPOS"
    #define WORD_OCCURRENCE     L"siOccurrence"
    #define WORD_ID_LANG        L"siIdLang"
    #define WORD_ID_LEMMA       L"nuIdLemma"
    
    // Key word for attributes of table LEMMA
    #define LEM_ID_LEMMA        L"nuIdLemma"
    #define LEM_STRING          L"vcString"
    #define LEM_EXCLUDED        L"cExcluded"
    #define LEM_ID_POS          L"siIdPOS"
    #define LEM_ID_GENDER       L"siIdGender"
    #define LEM_ID_LANG         L"siIdLang"
    #define LEM_ID_TYP_DOC      L"siIdTypD"  //SIIDTYPD
    #define LEM_ID_DOC          L"siIdD"
    
    // Key word for attributes of table WORK_INFORMATION
    #define WI_DOCUMENT         L"vcDocument"
    #define WI_ID_SRC_LANG      L"siIdSrcLang"
    #define WI_ID_TYPE_DOC      L"siIdTypDoc"
    #define WI_ID_DOC           L"siIdDocument"
    // Key word for attributes of table PARA_TABLE
    #define PA_ID               L"nuIdPar"
    #define PA_IDENT            L"vcLabel"
    #define PA_TEXT             L"vcPar"
    #define PA_DOCID            L"iIdDoc"
    // Key word for ini file reading
    #define SECTION_DB_SCRIPT   L"DB_SCRIPTS"
    #define KEYNAME_CREATION_MISSION_DB_SCRIPT L"CREATE_MDB_SQL"
    
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    
    //static enSERVER_STATUS       m_enSrvStatus;        //Status of the server in the enum enSERVER_STATUS
    //static enDatabaseServer      m_enSrvType;          //Type of server define in the enum enDatabaseServer
    static std::wstring          m_wsSrvName;       //Name of the server.
    static std::wstring          m_wsSrvLogin;      //Login of the user
    static std::wstring          m_wsSrvPassword;   //Password string of the user
    static std::wstring          m_wsName;          //Name of the server.
    static std::wstring          m_wsDBName;
    static std::wstring          m_wsLogin;         //Login of the user
    static std::wstring          m_wsPassword;      //Password string of the user
    static std::wstring          m_wsHost;
    static std::wstring          m_wsUserName;
    static std::wstring          m_wsDescription;   //Description text (free field)
    //static enDATABASE_STATUS     m_enStatus;        //Status of the server in the enum enSERVER_STATUS
    //static enDATABASE_TYPE       m_enType;          //Type of server define in the enum enDatabaseServer
    
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    /*Class         CDatabase                                                                                               */
    /*--------------------------------------------------------------------------------------------------------------------------------*/
    //DATA
    //  CLASS CDatabase
    //    (Private)
    //    m_wsDBName			  	Name of the database.
    //    m_enType     				Type of database define in the enum enDATABASE_TYPE
    //	  m_wsLogin   		  		Login of the user for this database
    // 	  m_wsPassword      		Password string of the user for this database
    //	  m_enStatus	    		Status of the database in the enum enDATABASE_STATUS
    ////  m_wsDescription		    Description text (free field)
    	public ref class CDatabase
    	{
    	public:
    		CDatabase();
    		~CDatabase();
    		static std::wstring SetDBName(std::wstring wsDBName);
    		static void SetLogin(std::wstring wsLogin);
    		static void SetPassword(std::wstring wsPassword);
    		static void SetType(enDATABASE_TYPE enType);
    		static void SetStatus(enDATABASE_STATUS enStatus);
    		std::wstring GetDBName();
    		std::wstring GetLogin();
    		std::wstring GetPassword();
    		enDATABASE_TYPE GetType();
    		enDATABASE_STATUS GetStatus();
    	};
    };
    //ATAD
    /*_____GLOBAL-DATA____________________________________________________________*/
    
    
    
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    
    #endif /* DATABASE_H */
    
    Suite dans le prochain Post


    Jean Noël Martin

    samedi 31 janvier 2015 10:39
  • suite des headers:

    InterbaseManagerM.hpp

    /*******************************************************************************
     * NOM: 
     * ROLE: 
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef INTERBASEMANAGERM_H
    #define INTERBASEMANAGERM_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    /*_____GLOBAL-TYPES___________________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    	using namespace System::Data::Sql;
    	using namespace System::Data::SqlClient;
    	using namespace System::Runtime::InteropServices;
    	using namespace msclr::interop;
    
    	ref class CInterbaseManagerM
    	{
    	public:
    		static SqlCommand^ myCommand;
    		static SqlDataReader^ myReader;
    		static SqlConnection^ myConnexion;
    		static SqlTransaction^ myTransaction;
    		CInterbaseManagerM::CInterbaseManagerM();
    		CInterbaseManagerM::~CInterbaseManagerM();
    		static void Display( Exception^ exception);
    		static void CInterbaseManagerM::StartTransaction( SqlCommand^ wsRequest);
    		static void CInterbaseManagerM::StartInsertion( System::String^ wsTable_Name);
    		static erc CInterbaseManagerM::ConnectServer(System::String^ wsUserName, System::String^ wsPassword, System::String^ wsHost);
    		static erc CInterbaseManagerM::DisconnectServer();
    		static erc CInterbaseManagerM::DisconnectDatabase();
    		static void CInterbaseManagerM::ConnectDatabase();
    		static int CInterbaseManagerM::GetIdentifier( System::String^ wsTable_Name, System::String^ wsPadName, System::String^ wsRowName);
    		static void CInterbaseManagerM::CommitTransaction();
    		static void CInterbaseManagerM::edit( char* final_err_buff );
    		static void CInterbaseManagerM::ExecuteRequest( SqlCommand^ wsRequest, unsigned long * dwNbResultFound);
    		static void CInterbaseManagerM::ExecuteSelectRequest( SqlCommand^ wsRequest, unsigned long * dwNbResultFound);
    		static void CInterbaseManagerM::CloseInsertion( System::String^ wsTable_Name);
    		static int CInterbaseManagerM::GetInteger(int Row);
    		static void CInterbaseManagerM::InititiateDatabase();
    		static std::wstring CInterbaseManagerM::GetString( int Row);
    		static void CInterbaseManagerM::CloseReader();
    	}; 
    };
    #endif
    

    MissionDatabaseManager.h

    //--------------------------------------------------------------------------------------------------------------------------------
    /* Global conception    : 06-12-2003 ; 19:01:55                                                                                   */
    // Specification        : 05-12-2003  14:54:40
    // ALITEC
    // Rue Leonard de vinci
    // 53061 LAVAL CEDEX 09
    // (c) Copyright ALITEC
    //--------------------------------------------------------------------------------------------------------------------------------
    /*******************************************************************************
     * NOM:
     * ROLE:
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef MISSION_DATABASE_MANAGER_H
    #define MISSION_DATABASE_MANAGER_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    //CONST
    //  FIRST_ELEMENT   0
    using namespace std;
    #define FIRST_ELEMENT   0
    #define END_REQUEST   L"END"
    #define ALIGNER_DOCUMENT   L"'Document Pair'"
    #define OPTION_DB_DIRECTORY  L"DBDirectory"
    #define OPTION_SERVER_INFORMATION L"ServerInformation"
    /*_____GLOBAL-TYPES___________________________________________________________*/
    //--------------------------------------------------------------------------------------------------------------------------------
    //Class         CSegmentChunk
    //--------------------------------------------------------------------------------------------------------------------------------
    //  CLASS CSegmentChunk This class is used to fill the value of the map list used for reading fastly the chunk of segment in order of the chained list
    ref class CSegmentChunkM
    {
    //    (Public)
          public:
            CSegmentChunkM()
            {
              ;
            }
            ~CSegmentChunkM()
            {
              ;
            }
    //      m_hidIdChunk          Unique identifier of the chunk
    //      m_Status              Alignment status of the chunk
    //      m_lInitialPosition    Initial position of the chunk in the segment
    //      m_hidIdNext           Identifier of the segment chunk link of the next chunk
            hidDB      m_hidIdChunk;
            enStatusM^ m_Status;
            long       m_lInitialPosition;
            hidDB      m_hidIdNext;
    //    (Private)
          private:
    };
    //ATAD
    //--------------------------------------------------------------------------------------------------------------------------------
    //Class         CSegmentSatus
    //--------------------------------------------------------------------------------------------------------------------------------
    //  CLASS CSegmentStatus This class is used to fill the value of the map list used for reading fastly the chunk of segment in order of the chained list
    //    (Public)
    //      m_hidIdChunk       Unique identifier of the chunk
    //      m_hidIdNext        Identifier of the segment chunk link of the next chunk
    //    (Private)
    	ref class CSegmentStatusM
    	{
    		public:
            CSegmentStatusM()
            {
                ;
            }
            ~CSegmentStatusM()
            {
                ;
            }
            hidDB   m_hidIdNext;        //Identifier of the next segment
            int     m_iStatus;          //Identifier of the segment chunk link of the next chunk
    	};
    
    //--------------------------------------------------------------------------------------------------------------------------------
    //Class         CMDBManager
    //--------------------------------------------------------------------------------------------------------------------------------
    //  CLASS CMDBManager
    //    (Public)
    //      ENUM ERR_MDBManager                   Class Error code
    //        ERR_UNKNOWN_SERVER_TYPE             Server type not recognized
    //        ERR_SERVER_NOT_CONNECTED            Connection to the Server is not established
    //
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    	enum class ERR_MDBManager                     //Class Error code
    	{
    		ERR_UNKNOWN_SERVER_TYPE,              //Server type not recognized                          0
    		ERR_SERVER_NOT_CONNECTED,             //Connection to the Server is not established
    		ERR_LEMMA_NOT_UNIQUE,                 //There is several identical Lemma
    		ERR_WORD_NOT_UNIQUE,                  //There is several identical Word
    		ERR_CHUNK_NOT_UNIQUE,                 //There is several identical Chunk
    		ERR_NGRAM_NOT_UNIQUE,                 //There is several identical NGram
    		ERR_SEG_CHUNK_NOT_FOUND,              //The seg_chunk is not found
    		ERR_MAP_VALUE_SEG_CHUNK_EMPTY,        //The map value for the seg_chunk is empty
    		ERR_SEGMENT_LIST_INCOHERENT,          //The source and target segment list are incoherent
    		ERR_LEMMA_LINK_NOT_FOUND,             //No Lemma link found.
    		ERR_LEMMA_LINK_NOT_UNIQUE,            //Lemma link not unique.                              10
    		ERR_NGRAM_LINK_NOT_UNIQUE,            //NGram link not unique.
    		ERR_SEG_NOT_FOUND,                    //The Seg is not found
    		ERR_MAP_VALUE_SEG_EMPTY,              //The map value for the chunk is empty
    		ERR_NEXT_NOT_ALIGN_SEG_NOT_FOUND,     //The next Seg is not found
    		ERR_MAP_VALUE_NOT_ALIGN_SEG_EMPTY,    //The map value for the chunk is empty
    		ERR_SEGMENT_LINK_NOT_UNIQUE,          //Segment link not unique.
    		ERR_CHUNK_LINK_NOT_UNIQUE,            //Chunk link not unique.
    		ERR_FONT_NOT_UNIQUE,                  //There is several identical Word
    		ERR_MAX_JOIN_REACHED,                 //The capacity of MAX JOIN is reached
    		ERR_CANT_MOVE_CHUNK,                  //The chunk can't be moved                             20
    		ERR_CANT_MOVE_SEGMENT,                //The segment can't be moved
    		ERR_CANT_GET_CHUNK_IDS_OF_SEGMENT,    //No chunk ids for a segment is found
    		ERR_CANT_FIND_TCLUES_OF_SEGMENT,      //The segment clues is not found
    		ERR_GET_CHUNKS_DESCRIPTION_OF_SEGMENT,//The chunk description is not found
    		ERR_CANT_GET_NGRAM_DESCRIPTION,       //The ngram description is not found
    		ERR_CANT_CREATE_SEGMENT,              //The segment can't be created
    		ERR_CANT_GET_SEGMENT_LAYOUT,          //The segment layout is not found
    		ERR_CANT_GET_SEGMENT_STATISTICS,      //The segment statistics are not found
    		ERR_CANT_GET_SEGMENT_DESCRIPTION,     //The segment description is not found
    		ERR_CANT_GET_LIST_OF_LEMMA_DESCRIPTION_FROM_SEGMENT //The list of lemma description is not found
    	};
    
    	enum class enFUNCTION_ID
    	{
    		SET_WHOLE_SEGMENT_LINK_DESCRIPTION = 1,
    		DOES_A_LEMMA_LINK_FIT_PROBABILITY_THRESHOLD,
    		MOVE_CHUNK_OF_SEGMENT,
    		MOVE_SEGMENT,
    		GET_CHUNK_IDS_OF_SEGMENT,
    		GET_SEGMENTS_CLUES,
    		GET_CHUNKS_DESCRIPTION_OF_SEGMENT,
    		GET_NGRAM_DESCRIPTION,
    		CREATE_SEGMENT_AND_ALL_ITS_SUB_ELEMENT,
    		GET_SEGMENTS_LAYOUT,
    		GET_SEGMENTS_STATISTICS,
    		GET_SEGMENTS_DESCRIPTION,
    		UPDATE_SEGMENT_LINK,
    		UPDATE_CHUNK_LINK,
    		GET_LIST_OF_LEMMA_DESCRIPTIONS_FROM_SEGMENT_ID
    	};
    
    	enum class enCLASS_ID
    	{
    		CMDB_MANAGER = 1
    	};
    	
    	ref class CMDBManager
    	{
    		public:
    			enLanguageM                     m_SourceLanguage;  //Source language of the mission database
    			CMDBManager::CMDBManager();
    			CMDBManager::~CMDBManager();
    			erc CMDBManager::initMDBManager();
    ////////////////////////////////////////////////////////////////////////////////
    //  Server
    ////////////////////////////////////////////////////////////////////////////////
    			static erc CMDBManager::ConnectServer( System::String^ wsServerFullname, enDatabaseServerM DatabaseServer, System::String^ wsLogin, System::String^ wsPassword);
    			static erc CMDBManager::DisconnectServer();
    			static wchar_t * CMDBManager::itoa( int i, wchar_t* pDoc2);
    ////////////////////////////////////////////////////////////////////////////////
    //  Database
    ////////////////////////////////////////////////////////////////////////////////
    			erc CMDBManager::OpenDatabase( System::String^ wsDatabaseFullPathName, System::String^ wsSourceFile, enLanguageM SourceLanguage, unsigned long dwNbResultFound);
    			erc CMDBManager::CreateDatabase( System::String^ wsDatabaseFullPathName, enLanguageM SourceLanguage, enStatusM Status);
    			erc CMDBManager::InitiateDatabase( System::String^ wsCurrentSource, enLanguageM SourceLanguage);
    			static void CMDBManager::SetStatusDocument( int iIdDoc, int Stat);
    			erc CMDBManager::CloseDatabase();
    			static erc CMDBManager::CreateSegmentProposition( enLanguageM Language, hidDB hidSegmentID, std::list<CElementSemantiqueM^> &ListProposition);
    ////////////////////////////////////////////////////////////////////////////////
    //  Segment
    ////////////////////////////////////////////////////////////////////////////////
    			static erc CreateSegmentAndAllItsSubelement( CAnalysedSegmentM^ pAnalysedSegment);
    			static erc IsSegmentStillInTheDatabase( CAnalysedSegmentM^ pAnalysedSegment);
    ////////////////////////////////////////////////////////////////////////////////
    //  Divers
    ////////////////////////////////////////////////////////////////////////////////
    			erc CreateParagraph( std::wstring wsParagraphe, std::wstring wsIdentifier);
    			static erc CreateSegmentLayout(CLayout^ pSegmentLayout,hidDB &hidNewLayout);
    			static erc CreateSegmentLemmas( enLanguageM Language, List<CAnalysedWordM^> ListAnalysedWord);
    			static erc CreateSegmentWords( enLanguageM Language, hidDB hidSegmentID, List<CAnalysedWordM^> ListAnalysedWord);
    			static erc CreateSegmentChunks( enLanguageM Language, hidDB hidSegmentID, List<CAnalysedChunkM^> ListChunk);
    			static std::wstring ShapeWString(std::wstring s);
    	};
    };
    #endif /* MISSION_DATABASE_MANAGER_H */

    annexeFonctions.h

    /*******************************************************************************
     * NOM: AnnexFunction.h
     * ROLE: 
     * HISTORIQUE:
        * 05/05/2003, yab, initial version
    *******************************************************************************/
    #ifndef ANNEXFUNCTIONS_H
    #define ANNEXFUNCTIONS_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    #define OPTION_SECTION_CANNEX_FUNCTION                       L"CANNEX_FUNCTION"
    #define OPTION_KEYNAME_THRESHOLD_VARIABLE                    L"THRESHOLD_VARIABLE"
    #define THRESHOLD_DEFAULT                                    5
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    /*_____CLASS-DEFINITION_______________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    	enum enCAnnexFunctionsMethod
    	{
    		EXCLUDE_LEM =1,
    	};
    
    	ref class CAnnexFunctions
    	{
    		private:
    		public:
    			CAnnexFunctions::CAnnexFunctions();
    			CAnnexFunctions::~CAnnexFunctions();
    			erc ExcludedLEM( SpecificationLoader::CMDBManager^ pDatabase, long lNumberWordOfDoc, enLanguageM Language);
    	};
    };
    
    #endif /* ANNEXFUNCTIONS_H */

    conputingForAlignement.h

    /*******************************************************************************
     * NOM: ComputingForAlignment.h
     * ROLE:
     * HISTORIQUE:
        * 27/05/2003, yab, initial version
    *******************************************************************************/
    #ifndef COMPUTINGFORALIGNMENT_H
    #define COMPUTINGFORALIGNMENT_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    
    	enum class enCComputingMethod
    	{
    		COMPUTE_EXT_INT_SCORE =1,
    		COMPUTE_NUMBER_SCORE,
    	};
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    /*_____CLASS-DEFINITION_______________________________________________________*/
    	ref class CComputingForAlignment
    	{
    		private:
    		public:
    			CComputingForAlignment::CComputingForAlignment();
    			CComputingForAlignment::~CComputingForAlignment();
    			erc ComputeExtIntScore( CAnalysedSegmentM^ pSegment);
    			erc ComputeNumberScore( CAnalysedSegmentM^ pSegment);
    	};
    };
    #endif /* COMPUTINGFORALIGNMENT_H */

    SchedulerGlobal.h

    /*******************************************************************************
     * NOM: SchedulerGlobal.h
     * ROLE:
     * HISTORIQUE:
     * 05/05/2003, yab, initial version
    *******************************************************************************/
    #ifndef SCHEDULERGLOBAL_H
    #define SCHEDULERGLOBAL_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    /*_____CLASS-DEFINITION_______________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    	namespace Word = Microsoft::Office::Interop::Word;
    
    	enum class enCSchedulerGlobalMethod
    	{
    		GLOBAL_ANALYSE =1,              // 1
    		ANALYSE_CSCHEDULER_GLOBAL,      // 2
    	};
    
    	ref class CSchedulerGlobal
    	{
    		private:
    		public:
    			System::String^									wsIdentifier;
    			List<CElementSemantiqueM^>^                     pListProposition;
    			CAnalysedSegmentM                               NewSegment;
    			CLinguisticSegmentM                             NewLinguisticSegment;
    			enLanguageM                                     m_Language;
    			System::String^	                                wsActualUnivers;
    			System::String^                                 m_sSourceLanguage;
    			System::String^                                 wsNextUnivers;
    			CSchedulerGlobal::CSchedulerGlobal();
    			CSchedulerGlobal::~CSchedulerGlobal();
    			void CSchedulerGlobal::InitAnalyse();
    			erc CSchedulerGlobal::AnalyseBlocText(CBlocM^ pBloc, List<CAnalysedSegmentM^>^ pListSegment, erc ulTotalNbWords, bool bNewDoc);
    			erc CSchedulerGlobal::Analyse( System::String^);
    			erc CSchedulerGlobal::AnalyseSegment(  CAnalysedSegmentM^ pSegment, CAnalysedChunkM^ pChunkSujet, bool bTitle, bool &bIsStopped, bool &bIsFirst, System::String^ wsNextUnivers, CMDBManager^ pDatabase, erc ulTotalNbWords, bool* pbNewSegment, int nSegment, int iNum, System::String^ paragraph);
    			static void CSchedulerGlobal::ProcessUnivers( CAnalysedSegmentM^ pSegment, bool bIsFirst, bool bTitle, System::String^ wsNextUnivers);
    			static bool CSchedulerGlobal::isAInitIdentifier( CBlocM^ pBloc, System::String^ wsText, System::String^ wsNxIdentifier, bool bIsProcessed, System::String^ wsNextUnivers, System::String^ wsIdentifier);
    	};
    };
    #endif /* SCHEDULERGLOBAL_H */
    

    Proposition.h

    /*******************************************************************************
     * NOM: Proposition.h
     * ROLE:
     * HISTORIQUE:
     * 05/05/2003, yab, initial version
    *******************************************************************************/
    #ifndef PROPOSITION_H
    #define PROPOSITION_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    /*_____CLASS-DEFINITION_______________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    	namespace Word = Microsoft::Office::Interop::Word;
    
    	ref class CProposition
    	{
    		public:
    			CProposition::CProposition();
    			CProposition::~CProposition();
    			static CAnalysedWordM^ CProposition::PoseMark( System::String^ str, enPOSM^ pos, int ulLength);
    			void CProposition::AnalysePrecondition( List<CAnalysedChunkM^>::Enumerator itChunk, List<CAnalysedWordM^>::Enumerator  itWord, CElementSemantiqueM^ pCurrentElement, CAnalysedSegmentM^ pSegment, System::String^ wsNextUnivers, CAnalysedChunkM^ pChunk, CAnalysedChunkM^ pChunkSujet, enChunkTypeM Curpos, int &Step, bool bTitle, bool* pbNewSegment, bool &bIsInList, bool bPivoted, bool &bNounPending, bool &processed, int &iPredicate, System::String^ wsChunk, CAnalysedWordM^ pWord, CAnalysedChunkM^ pPreviousChunk, CAnalysedChunkM^ pCurrentChunk, CAnalysedChunkM^ pNextChunk, CAnalysedChunkM^ pNext2Chunk, CAnalysedChunkM^ pNext3Chunk);
    			void CProposition::AnalyseQualificateur( List<CAnalysedChunkM^>::Enumerator itChunk, List<CAnalysedWordM^>::Enumerator  itWord, CAnalysedSegmentM^ pSegment, System::String^ wsNextUnivers, CElementSemantiqueM^ pCurrentElement, CElementSemantiqueM^ pPreviousElement, CLinguisticSegmentM^ pLinguisticSegment, CAnalysedChunkM^ pChunk, CAnalysedChunkM^ pChunkSujet, enChunkTypeM Curpos, int &Step, bool bTitle, bool &bMarkDeleted, bool &bNewSegmentOngoing, bool* pbNewSegment, bool &bIsInList, bool bPivoted, bool &bNounPending, bool &processed, int &iPredicate, System::String^ wsChunk, CAnalysedWordM^ pWord, CAnalysedChunkM^ pPreviousChunk, CAnalysedChunkM^ pCurrentChunk, CAnalysedChunkM^ pNextChunk, CAnalysedChunkM^ pNext2Chunk, CAnalysedChunkM^ pNext3Chunk);
    			void CProposition::AnalysePredicat( List<CAnalysedChunkM^>::Enumerator itChunk, List<CAnalysedWordM^>::Enumerator  itWord, CAnalysedSegmentM^ pSegment, System::String^ wsNextUnivers, CElementSemantiqueM^ pCurrentElement, CElementSemantiqueM^ pPreviousElement, CLinguisticSegmentM^ pLinguisticSegment, CAnalysedChunkM^ pChunk, CAnalysedChunkM^ pChunkSujet, enChunkTypeM Curpos, int &Step, bool bTitle, bool &bIsStopped, bool* pbNewSegment, bool &bIsInList, bool &bNewSegmentOngoing, bool &bIsPredicatAllocated, bool &bMarkDeleted, bool bPivoted, bool &bNounPending, bool &processed, int &iPredicate, System::String^ wsChunk, CAnalysedWordM^ pWord, CAnalysedChunkM^ pPreviousChunk, CAnalysedChunkM^ pCurrentChunk, CAnalysedChunkM^ pNextChunk, CAnalysedChunkM^ pNext2Chunk, CAnalysedChunkM^ pNext3Chunk);
    			void CProposition::AnalyseOther( List<CAnalysedChunkM^>::Enumerator itChunk, List<CAnalysedWordM^>::Enumerator itWord, CElementSemantiqueM^ pCurrentElement, CElementSemantiqueM^ pPreviousElement, CLinguisticSegmentM^ pLinguisticSegment, System::String^ wsNextUnivers ,CAnalysedChunkM^ pChunk, CAnalysedChunkM^ pChunkSujet, enChunkTypeM Curpos, int &Step, bool bTitle, bool* pbNewSegment, bool &bIsInList, bool &bNewSegmentOngoing, bool &bIsPredicatAllocated, bool &bMarkDeleted, bool bPivoted, bool &bNounPending, bool &processed, int &iPredicate, std::wstring wsChunk, CAnalysedWordM^ pWord, CAnalysedChunkM^ pPreviousChunk, CAnalysedChunkM^ pCurrentChunk, CAnalysedChunkM^ pNextChunk, CAnalysedChunkM^ pNext2Chunk);
    			void CProposition::InitiateProposition( List<CAnalysedChunkM^>::Enumerator itChunk, CAnalysedSegmentM^ pSegment, CElementSemantiqueM^ pCurrentElement, CElementSemantiqueM^ pPreviousElement, CLinguisticSegmentM^ pLinguisticSegment, CAnalysedChunkM^ pChunk, bool* pbNewSegment, bool &bNounPending, bool &bIsInList, bool &bIsPredicatAllocated, bool &bIsPreconditionAllocated , bool &bWasPredicatAllocated, bool &bWasPreconditionAllocated, enChunkTypeM Curpos, int &iAlloc, int &Step, System::String^ &wsChunk, CAnalysedWordM^ pWord, CAnalysedChunkM^ pPreviousChunk, CAnalysedChunkM^ pCurrentChunk, CAnalysedChunkM^ pNextChunk, CAnalysedChunkM^ pNext2Chunk);
    			void CProposition::ProcessPassiveFromPresentParticiple( List<CAnalysedChunkM^>::Enumerator itChunk, List<CAnalysedWordM^>::Enumerator  itWord, CAnalysedSegmentM^ pSegment, System::String^ wsNextUnivers, CElementSemantiqueM^ pProposition, CLinguisticSegmentM^ pLinguisticSegment, CAnalysedChunkM^ pChunkSujet, int Step, bool bTitle, bool* pbNewSegment, bool &bIsStopped, CAnalysedChunkM^ pCurrentChunk, CAnalysedChunkM^ pPreviousChunk);
    			bool CProposition::ProcessPassiveFromPassive( List<CAnalysedWordM^>::Enumerator itWord, CAnalysedSegmentM^ pSegment, System::String^ wsNextUnivers, CElementSemantiqueM^ pProposition, CLinguisticSegmentM^ pLinguisticSegment, CAnalysedChunkM^ pChunkSujet, int Step, bool bTtitle, bool* pbNewSegment, bool &bIsStopped, List<CAnalysedChunkM^>::Enumerator itChunk, CAnalysedChunkM^ pCurrentChunk, CAnalysedChunkM^ pPreviousChunk);
    			void CProposition::ExecutePassiveAndFormatResult(  List<CAnalysedChunkM^>::Enumerator itChunk, List<CAnalysedWordM^>::Enumerator itWord, CAnalysedSegmentM^ pSegment, System::String^  wsNextUnivers, CAnalysedSegmentM^ pInternalSegment, CElementSemantiqueM^ pProposition, CLinguisticSegmentM^ pLinguisticSegment, CLinguisticSegmentM^ pNewLinguisticSegment, CAnalysedChunkM^ pChunkSujet, int Step, bool bTitle, bool * pbNewSegment, bool &bIsStopped, CAnalysedChunkM^ pCurrentChunk, CAnalysedChunkM^ pPreviousChunk);
    			static erc CProposition::ExtractQPCA( CAnalysedSegmentM^ pSegment, System::String^  wsNextUnivers, CAnalysedChunkM^ pChunkSujet, bool bTitle, bool* pbNewSegment, int iIdDoc);
    	};
    };
    #endif /* PROPOSITION_H */

    Fin des headers


    Jean Noël Martin

    samedi 31 janvier 2015 11:11
  • L'option /P à résolu le problème

    Jean Noël Martin

    samedi 31 janvier 2015 11:18
  • /P ne règle rien au problème, elle bloque la compilation au pré-processing, donc avant la compilation.

    Le but c'est de voir d(ou sort l'utilisation de la std::list sur des objets managés.

    Donc, il faut regarder dans le fichier xxx.i généré pour voir d'où ça sort. Et accessoirement, ça met tout dans un seul fichier.


    Paul Bacelar, Ex - MVP VC++

    dimanche 1 février 2015 22:04
    Modérateur
  • ou trouver le fichier xxx.i ?

    La génération a démarré 02/02/2015 20:52:56.
         1>Projet "D:\usr\Specification Loader\dev\ALN_Kernel\make\SpecificationLoader\SpecificationLoader\SpecificationLoader.vcxproj" sur le nœud 2 (ClCompile cible(s)).
         1>GenerateTargetFrameworkMonikerAttribute:
           La cible est ignorée "GenerateTargetFrameworkMonikerAttribute", car tous les fichiers de sortie sont à jour par rapport aux fichiers d'entrée.
           ClCompile:
             C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin\CL.exe /c /I\usr\WordNet\src\include /I\usr\WordNet\src\include /I\usr\WordNet\src\lib /I"\usr\Specification Loader\dev\DBMS\OnLineDBManager\ibpp-2-5-3-1-src\core" /I"\usr\Specification Loader\dev\WordNet\com" /I"\usr\Specification Loader\dev\Linguistic\DocumentManager\com" /I"\usr\Specification Loader\dev\Utility\OptionManager\com" /I"\usr\Specification Loader\dev\Linguistic\Analyser\com" /I"\usr\Specification Loader\dev\Utility\IniFileManager\com" /I"\usr\Specification Loader\dev\DBMS\MissionDBManager\com" /I"\usr\Specification Loader\dev\DBMS\DBMSManager\com" /I"\usr\Specification Loader\dev\Linguistic\WordReader\com" /I"\usr\Specification Loader\dev\ALN_Kernel\make" /I"\usr\Specification Loader\dev\Linguistic\ParserManager\com" /I"\usr\Specification Loader\dev\ALN_Kernel\make\SpecificationLoader\SpecificationLoader" /I"\usr\Specification Loader\dev\Linguistic\Alignment\com" /I"\usr\Specification Loader\dev\Utility\com" /I"\usr\Specification Loader\dev\Common\com" /AI"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0" /Zi /clr /nologo /W3 /WX- /O2 /Oy- /D WIN32 /D NDEBUG /D _UNICODE /D UNICODE /EHa /MD /GS /fp:precise /Zc:wchar_t /Zc:forScope /Yu"StdAfx.h" /Fp"Release\SpecificationLoader.pch" /Fo"Release\\" /Fd"Release\vc100.pdb" /TP /FU"D:\program files\Microsoft Visual Studio 10.0\Visual Studio Tools for Office\PIA\Office14\Microsoft.Office.Interop.Word.dll" /FU"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Core.dll" /FU"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Data.dll" /FU"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.DirectoryServices.dll" /FU"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.dll" /FU"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Drawing.dll" /FU"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Windows.Forms.dll" /FU"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Xml.dll" /analyze- /errorReport:prompt ..\..\..\..\Linguistic\Analyser\src\Proposition.cpp /clr:nostdlib /P 
             Proposition.cpp
             Toutes les sorties sont à jour.
         1>Génération du projet "D:\usr\Specification Loader\dev\ALN_Kernel\make\SpecificationLoader\SpecificationLoader\SpecificationLoader.vcxproj" terminée (ClCompile cible(s)).
    
    La génération a réussi.
    
    Temps écoulé 00:00:01.22
    

    est ce celui ci?


    Jean Noël Martin


    lundi 2 février 2015 11:47
  • Il est sur le disque, dans le système de fichier.

    S'il n'est pas régénéré, faites un clean avant.


    Paul Bacelar, Ex - MVP VC++

    mardi 3 février 2015 22:52
    Modérateur
  • Je l'ai trouvé dans le répertoire de génération. Si je le clean les fichier précompilés vont être perdus

    Jean Noël Martin

    mercredi 4 février 2015 09:52
  • Le compilateur régénérera ces fichiers, c'est fait pour.

    En analysant le contenu du fichier xxx.i, vous devriez voir où est utilisé la std::list<SpecificationLoader::CElementSemantiqueM ^> qui pose problème.


    Paul Bacelar, Ex - MVP VC++


    mercredi 4 février 2015 14:40
    Modérateur
  • Oui je comprend mais je n'ai toujours pas d'info sur l'endroit ou chercher

    Jean Noël Martin

    mercredi 4 février 2015 21:09
  • Dans le fichier xxxx.i, c'est du C++ standard.

    Paul Bacelar, Ex - MVP VC++

    jeudi 5 février 2015 11:07
    Modérateur
  • et que dois je faire pour le changer?

    Jean Noël Martin

    jeudi 5 février 2015 19:21
  • Maintenant que j'ai converti Proposition en Managé l'erreur à disparu

    Jean Noël Martin

    • Marqué comme réponse JeanNoel53 vendredi 6 février 2015 08:14
    vendredi 6 février 2015 08:14
  • Avant de changer, il faut savoir pourquoi.

    En ayant le pourquoi, on peut corriger l'erreur.


    Paul Bacelar, Ex - MVP VC++

    lundi 9 février 2015 09:55
    Modérateur
  • Super, c'est tombé en "marche".

    Maintenant, vous avez plus qu'à serrer les fesses à la moindre modification.

    Maitrisez un minimum votre projet, sinon, vous allez droit dans le mur.


    Paul Bacelar, Ex - MVP VC++

    • Marqué comme réponse JeanNoel53 jeudi 12 février 2015 10:48
    lundi 9 février 2015 09:57
    Modérateur