none
Toujours dans ma conversion RRS feed

  • Question

  • bonjour,

    J'avance dans ma conversion du code de Java; Je bloque actuellement dans la conversion de la 7° primitive sur 9. je suis arrête à la ligne  3802 pour un fichier qui comporte 4500 LOCS.

    je vous donne le source dans l'état , numéroté sur les lignes en erreur, et le message d'erreur

       
        /*------------------------------------------------------------------------------*/
        /*Name          ParseObjects                                                    */
        /*Role          Check the cherence of the objects Objects                       */
        /*Interface                                                                     */
        /*In                                                                            */
        /*In/Out        pSegment                                                        */
        /*Result        bStatus                                                         */
        /*------------------------------------------------------------------------------*/
            
        bool BuildComponents::ParseObjects( CAnalysedSegment* pSegment)
        { // 0
            std::list<preconditionNormalized*>::iterator itPrecondition;
    		std::list<CObjet*>::iterator itObjet;
    		std::list<predicatNormalized*>::iterator itPredicat;
    		std::list<CAnalysedWord*>::iterator itWord;
    		std::list<std::wstring*>::iterator itString;
    
    		std::list<preconditionNormalized*> listeAPreconditionToCompare;
    		std::list<preconditionNormalized*>* pListPrecondition;
    		std::list<predicatNormalized*> listPredicatNormalized;
    		std::list<CObjet*> listObjectsNormalized;
    		
    		std::list<CAnalysedWord*> color;
    		preconditionNormalized PreconditionToCompare;
            preconditionNormalized* pPrecondition;
    		predicatNormalized predicat;
    		predicatNormalized* pPredicat;
            CObjet RefObject;
    		CObjet* pObjet;
            CAnalysedWord Word;
    		CAnalysedWord* pWord;
            CObjet objet;
    		CObjet NewObject;
    		std::wstring* pString;
    		std::string sPhrase;
    
            int i = 0;
            int j = 0;
            int k = 0;
            int l = 0;
            int iPred = 0;
            int iSize1 = 0;
            int iSize3 = 0;
            int value;
    		int* iiValue;
            std::wstring sKeyName = L"";
            std::wstring wsText = L"";
            std::wstring Reference = L"";
            std::wstring wsRefName = L"";
            std::wstring Identifiant = L"";
    		std::wstring wsBuffer;
    		std::wstring wsWord;
            int Occurence = 0;
            bool bColorIsCoherent = true;
            bool bValueIsCoherent = true;
            // on procède en deux temps: d'abord les predicats puis les préconditions
            // dans chacune on cherche les éléments qui peuvent être contradictoire
            // et on réévalue les cardianlités en fonction des héritages
            // il faut pouvoir parser la ListWord qu'on constitue au départ
            // on commence par les prédicats
    		pListPrecondition = new std::list<preconditionNormalized*>();
            listeAPreconditionToCompare = *pListPrecondition;
            listObjectsNormalized = pSegment->pLinguisticSegment->listObjectsNormalized;
    		itObjet = listObjectsNormalized.begin();
            while ( itObjet != listObjectsNormalized.end())
            { // 1
                pObjet = * itObjet;
    			objet = *pObjet;;
                if( objet.inherit == NULL && objet.nValue != 2 && objet.nValue != 4)
                { // 2
                    sKeyName = objet.Name;
                }
                i++;
            } // 1
            listePredicatNormalized = pSegment->pLinguisticSegment->ListPredicatNormalized;
    		itPredicat = listePredicatNormalized.begin();
    		while( itPredicat != listePredicatNormalized.end() && sKeyName != L"")
            { // 1
                // il faut d'abord rechercher l'identifiant de l'objet
                 pPredicat = *itPredicat;
    			 predicat = *pPredicat;
                 wsText = predicat.Comment;
                 itWord = predicat.Word.begin();
                 while( itWord != predicat.Word.end() && sKeyName != L"")
    			 { // 2
    				 pWord = *itWord;
    				 Word = *pWord;
                     std::wstring wComment = objet.Text;
                     if( objet.Name == sKeyName)
                     { // 3
                         //on met à jour l'origine de l'heritage
                         predicat.Occurence += 3;
                     } // 3
                     std::wstring wsWord = Word.wsWord;
                     switch( Word.POS)
                     { // 3
                         case POS_NB:
                             itObjet = listObjectsNormalized.begin();
                             while( itObjet != listObjectsNormalized.end())
                             { // 4
                                 // on ne prend à ce stade que le premier objet
                                 // en fait pour diagnostiquer tous les risques d'incohérence il faut boucler sur tous les objets
                                 pObjet = *itObjet;
    							 objet = *pObjet;
                                 std::wstring wsNameOfObject = objet.Name;
                                 // il faut là rajouter une recherche sur le nom de l'objet
                                 if( predicat.Comment.find( objet.Name, 0))
                                 { // 5
                                    if( Word.wsWord != L"1")
                                    { // 6
                                        if( Word.wsWord == L"one" && wsText.find( Word.wsWord + L" -", 0))
                                        { // 7   
                                           bValueIsCoherent = false;
                                           if( Word.wsWord.find( L"N", 0))
                                           { // 8
                                               std::wstring wsTemp = Word.wsWord.substr(1);
    										   value = _wtoi( (wchar_t*)wsTemp.c_str());
                                           }
                                           else
                                           {
                                              iiValue = ProcessNumber( iiValue, Enreg, u);
                                           } // 8
                                           // c'est une simplification abusive on utilise l'heritage de la pluie
                                           // mais pour un autre objet il faut utiliser une référence variable
                                           if( !(objet.min == 0 &&  objet.max == 0))
                                           { // 8
                                             if( objet.min -1 < value && objet.max +1 > value || value == objet.type)
                                             { // 9
                                                bValueIsCoherent = true;
                                             } // 9
                                           }
                                           else
                                           {
                                              bValueIsCoherent = true;
                                           } // 8
                                       } // 7
                                    } // 6
                                 } // 5
                                 k++;
                                 if( bValueIsCoherent == false)
                                 { // 5
                                     std::wstring phrase = L"";
                                     std::wstring wsParagraph = predicat.ListParagraph;
                                     itWord = predicat.Word.begin();
                                     while( itWord != predicat.Word.end())
                                     { // 6
                                         pWord = *itWord;
    									 Word = *pWord;
                                         phrase += Word.wsWord;
                                         phrase += L" ";
                                         k++;
                                     } // 6
                                     char* temp = SpecificationLoader::objStrConv.awcstombs( (wchar_t *)objet.Name.c_str());
    								 std::string sName = temp;
    								 SpecificationLoader::objStrConv.StrFreeA( temp);
    								 temp = SpecificationLoader::objStrConv.awcstombs( (wchar_t *)phrase.c_str());
    								 sPhrase = temp;
    								 SpecificationLoader::objStrConv.StrFreeA( temp);
    								 msg = "Incoherence inter an object named ";
    								 msg += sName;
    								 msg += " with the minimum value is ";
    								 msg += objet.min;
    								 msg += " and the maximum value is ";
    								 msg += objet.max;
    								 msg += " with the number of value is ";
    								 msg += objet.nValue;
    								 msg += " in the sentence ";
    								 msg += sPhrase;
    								 throw Doc_exception( (const char*)msg.c_str(), nParagraph);
                                 } // 5
                             } // 4
                             break;
                         case POS_COLOR :
                             k = 0;
                             int len;
                             itObjet = listObjectsNormalized.begin();
                             while( itObjet != listObjectsNormalized.end())
                             { // 4
                                 pObjet = *itObjet;
    							 objet = *pObjet;
                                 l = 0;
                                 if( objet.Name == L"indicator")
                                 { // 5
                                      bColorIsCoherent = false;
                                      itString = objet.Enumerated.begin();
                                      while( itString != objet.Enumerated.end())
                                      { // 6
                                            pString = *itString;
    									    std::wstring color = *pString;
                                            if( Word.wsWord == color)
                                            { // 7
                                                bColorIsCoherent = true;
                                            }
                                            itString++;
                                       } // 6
                                 } // 5
                                 itObjet++;
                             } // 4
                             if( bColorIsCoherent == false)
                             { // 4
                                 std::wstring phrase = L"";
                                 std::wstring listOfColors = L"";
                                 std::wstring wsParagraph = predicat.ListParagraph;
                                 k = 0;
                                 itObjet = listObjectsNormalized.begin();
    							 while( itObjet != listObjectsNormalized.end())
    							 { // 4
    								 pObjet = *itObjet;
    								 objet = *pObjet;
                                     phrase += Word.wsWord;
                                     phrase += L" ";
                                     k++;
                                 } // 5
                                 // il faut positioner objet sur l'indicateur
                                 std::wstring wsName = objet.Name;
                                 bool bFound = false;
                                 itObjet = listObjectsNormalized.begin();
                                 while( itObjet != listObjectsNormalized.end() && bFound == false)
                                 {
                                     pObjet = *itObjet;
    								 objet = *pObjet;
                                     k++;
                                     if( objet.Name == L"indicator")
                                     {
                                         bFound = true;
                                     }
                                 }
                                 itObjet = listObjectsNormalized.begin();
                                 while( itObjet != listObjectsNormalized.end() && bFound == false)
                                 {
                                     pObjet = *itObjet;
    								 objet = *pObjet;
                                     listOfColors += L" ";
                                     k++;
                                 } // 5
                                 wsBuffer = L"Incoherence inter an object named ";
    							 wsBuffer += objet.Name;
    							 wsBuffer += L" with the list of value value is ";
    							 wsBuffer += listOfColors;
    							 wsBuffer += L" with the number of value is ";
    							 wsBuffer += iSize;
    							 wsBuffer += L" in the sentence " + phrase; 
                                 // char* =CStrConv::awcstombs(wchar_t *sczW)
    						     char* tmp = SpecificationLoader::objStrConv.awcstombs( (wchar_t*)wsBuffer.c_str());
    							 msg = tmp;
    							 SpecificationLoader::objStrConv.StrFreeA( tmp); 
                                 throw Doc_exception( (const char*)msg.c_str(), nParagraph);
                             } // 4
                             break;
                         default:
                             break;
                     } // 3
                     j++;
                 } // 2
                 i++;
            } // 1
            // puis on traitera les Préconditions
            i = 0;
            j = 0;
            k = 0;
            itPrecondition = listePreconditionNormalized.begin();
            while( itPrecondition != listePreconditionNormalized.end() && sKeyName != L"")
            { // 1
                pPrecondition = *itPrecondition;
    			precondition = *pPrecondition;
                // il faut parser chaque précondition pour identifier les termes qui se raccordent à l'héritage
                wsText = precondition.Comment;
                precondition.bAllocated = false;
                Identifiant = precondition.Identifier;
                Occurence = precondition.Occurence;
                Reference = sKeyName;
                itWord = precondition.Word.begin();
                while( itWord != precondition.Word.end())
                { // 2
                    pWord = *itWord;
    				Word = *pWord;
                    std::wstring wsTemp1 = Word.wsWord;
    		        transform( wsTemp1.begin(), wsTemp1.end(), wsTemp1.begin(), towlower);
                    std::wstring wsTemp = sKeyName;
    				transform( wsTemp.begin(), wsTemp.end(), wsTemp.begin(), towlower);
    				if( wsTemp.find(wsTemp1, 0))
                    { // 3
                        precondition.Occurence += 3;
                        precondition.bAllocated = true;
                    } // 3
                    j++;
                } // 2
                i++;
            } // 1
            // il faut controler que tous les termes de l'objet trouve un répondant dans les préconditions
            bool bFound = false;
            j = 0;
            itObjet = listObjectsNormalized.begin();
            while( itObjet != listObjectsNormalized.end())
            { // 1
                pObjet = *itObjet;
    			NewObject = *pObjet;
    			std::wstring wsName = NewObject.Name;
                std::wstring wsComment = NewObject.Text;
                k = 0;
                int size = 0;
                if( NewObject.max < 5)
                { // 2
                    itString = NewObject.Enumerated.begin();
                    while( itString != NewObject.Enumerated.end())
                    { // 3
                        pString = *itString;
    					std::wstring color = *pString;
                        bFound = false;
                        itPrecondition = listePreconditionNormalized.begin();
                        while( itPrecondition != listePreconditionNormalized.end())
                        { // 4
                            pPrecondition = *itPrecondition;
    					    precondition = *pPrecondition;
                            if( precondition.Comment == wsRefName)
                            { // 5
                                bFound = true;
                            } // 5
                            itPrecondition++;
                            if( wsRefName == L"0")
                            { // 5
                               l = 0;
                               bFound = true;
                            } // 5
                            else if( wsRefName == L"1")
                            { // 5
                               l = 1;
                               bFound = true;
                            } // 5
                            else if( wsRefName == L"2")
                            { // 5
                               l = 2;
                               bFound = true;
                            } // 5
                            else if( wsRefName == L"3")
                            { // 5
                               l = 3;
                               bFound = true;
                            } // 5
                            else if( wsRefName == L"4")
                            { // 5
                               l = 4;
                               bFound = true;
                            } // 5
                            if( bFound == false || wsRefName == precondition.Identifier)
                            { // 5
                                msg = "What is to be done with the object ";
    							char* temp = SpecificationLoader::objStrConv.awcstombs( (wchar_t *)wsRefName.c_str());
    							sPhrase = temp;
    							SpecificationLoader::objStrConv.StrFreeA( temp);
    							msg	+= sPhrase;
    							msg += "\n";
    							wrn += msg;
                            } // 5
                        } // 4
                        itPrecondition++;
                    } // 3
    				itString++;
                } // 2
                itObjet++;
            } // 1
            // il y a encore un contrôle à faire entre les préconditions: on cherche des conditions potentiellement ambigûe
            // pour chaque objet
            // pour chaque précondition
            // la precondition en cours risque t-elle de provoquer une incohérence
            std::wstring RefValue1 = L"";
            std::wstring RefValue2 = L"";
            std::wstring RefValue3 = L"";
            int covered = 0;
            wsText = L"";
            pObjet = new CObjet();
    		RefObject = *pObjet;
            itObjet = listObjectsNormalized.begin();
            while( itObjet != listObjectsNormalized.end())
            { // 1
                RefObject = *pObjet;
                std:wstring wsNameOfCurrentObject = RefObject.Name;
                if( RefObject.max < 5)
                { // 2
      3801          itWord = RefObject.Enumerated.begin();
      3802		while( itWord != RefObject.Enumerated.end())
    		{ // 3
    			pString = *itWord;
    			Word = *pWord;
    			wsWord = Word.wsWord;
    			itWord++;
    		}
                    int min = RefObject.min;
                    int max = RefObject.max;
                    j = 0;
                    itPrecondition = listePreconditionNormalized.begin();
                    while( itPrecondition != listePreconditionNormalized.end() && Reference != L"")
                    { // 4
                        pPrecondition = *itPrecondition;
    		    precondition = *pPrecondition;
                        std::wstring wsComment = precondition.Comment;
                        std::wstring wsTemp = wsNameOfCurrentObject;
    		    transform( wsTemp.begin(), wsTemp.end(), wsTemp.begin(), towlower);
    		    if( precondition.Comment.find( wsTemp, 0))
                        { // 5
                            if( !( RefObject.min == 0 &&  RefObject.max == 0))
                            { // 6
                                // il faut extraire la valeur à évaluer
                                // on parcours la précondition à la recherche de valeur numérique
                                k = 0;
                                itWord = precondition.Word.begin();
                                while( itWord != precondition.Word.end())
                                { // 7
                                    Word = precondition.Word.get( k);
                                    std::wstring wsWord = Word.wsWord;
                                    if( Word.iPOS == POS_NAMED_ENTITY)
                                    { // 8
                                        switch( l)
                                        { // 9
                                            case 0:
                                                RefValue1 = RefObject.Enumerated.get( l);
                                                covered++;
                                                break;
                                            case 1:
                                                RefValue2 = RefObject.Enumerated.get( l);
                                                covered++;
                                                break;
                                            case 2:
                                                if( RefObject.nValue == 3)
                                                    RefValue3 = RefObject.Enumerated.get( l);
                                                covered++;
                                                break;
                                            default:
                                                break;
                                        } // 9
                                        l++;
                                    } // 8
                                    else if( Word.iPOS == POS_NB)
                                    { // 8
                                        if( Word.Word != L"1")
                                        { // 9
                                            if( Word.Word != L"one" && wsText != Word.wsWord + L" -")
                                            { // 10  
                                                bValueIsCoherent = false;
                                                if( Word.Word.find( L"N", 0))
                                                { // 11
                                                    wsTemp = Word.wsWord.substr(1);
    												value = _wtoi( wsTemp.c_str());
                                                } // 11
                                                else
                                                { // 11
                                                    iiValue = ProcessNumber( iiValue, Enreg, u);
                                                } // 11
                                                if( RefObject.min -1 < value && RefObject.max +1 > value || value == RefObject.type)
                                                { // 11
                                                    bValueIsCoherent = true;
                                                } // 11
    										} // 10
                                        } // 9
                                        else
                                        { // 9
                                            bValueIsCoherent = true;
                                        } // 9
    								} //8
                                    itWord++;
                                } // 7
                                if( bValueIsCoherent == false)
                                { // 7
                                    std::wstring phrase = L"";
                                    nParagraph = _wtoi(precondition.ListParagraph;c_str());
                                    k = 0;
    								itWord = precondition.Word.begin();
                                    while( itWord = precondition.Word.end())
                                    { // 8
                                         pWord = *itWord;
    									 Word = *pWord;
    									 phrase += Word.wsWord;
                                         phrase += L" ";
                                         itWord++;
                                    } // 8
                                    msg = "Incoherence inter an object named " + RefObject.Name + " with tne minimum value is " + RefObject.min + " and the maximum value is " + RefObject.max + " with the number of value is " + RefObject.nValue + " in the sentence " + phrase; 
                                    throw Doc_exception( msg, nParagraph);
                                } // 7
                            } // 6
                        } // 5
                        itPrecondition++;
                   } // 4
               } // 3
               itString++;
    	   } // 2
           itobjet++;
           if( covered <= 3 || covered == 0))
           {
                    msg = "the values " + RefValue1 + ", " + RefValue2 + ", " + RefValue3 + " have not be completly covered";
    				throw Doc_exception( msg, nParagraph);
           }
                covered = 0;
            } // 1
            iSize = listeAPreconditionToCompare.size();
            i = 0;
            while( i < iSize)
            { // 1
                precondition = listeAPreconditionToCompare.get( i);
                if( !wsText.equals( precondition.Comment) && wsText.contains("Door N2") && precondition.Comment.contains("Door N1") && precondition.Comment.contains("Door N2"))
                { // 2
                    msg = "There is a high risk on uncoherence related to the precondition " + wsText + " and the precondition " + precondition.Comment + " What is to be done with the object's about Door N1 in the first précondition";
                    throw new Doc_Exception( msg);
                } // 2
                else
                { // 2
                    wsText = precondition.Comment;
                } // 2
                i++;
            } // 1
            // il reste à contrôler les précondition à comparer
            // il faut maintenat réordonner la liste des préconditions en fonction de l'occurence
            // on va les réordonner par occurence
            i = 0;
            j = 0;
            int maxOccurence = 0;
            std::list<TempPrecondition> listTempPrecondition  = new std::list<TempPrecondition>();
            TempPrecondition tPrecondition = null;
            listprecondition = null;
            int occurence = 0;
            iSize = listePreconditionNormalized.size();
            while( i < iSize)
            { // 1
                precondition = ( preconditionNormalized) listePreconditionNormalized.get( i);
                occurence = std::listprecondition.Occurence;
                tPrecondition = new TempPrecondition();
                tPrecondition.occurence = occurence;
                tPrecondition.precondition = precondition;
                listTempPrecondition.add( tPrecondition);
                if( maxOccurence < occurence) 
                { // 2
                    maxOccurence = occurence;
                } // 2
                i++;
            } // 1
            // il faut maintenent reporter les prédicats dans l'ordre des occurences
            listePreconditionNormalized.clear();
            i = maxOccurence;
            while( i > -1)
            { // 1
                j = 0;
                iSize = listTempPrecondition.size();
                while( j < iSize)
                { // 2
                    tPrecondition = listTempPrecondition.get( j);
                    if( tPrecondition.occurence == i)
                    { // 3
                        listePreconditionNormalized.add( tPrecondition.precondition);
                    } // 3
                    j++;
                } // 2
                i--;
            } // 1
            bool bCode = false;        
            if( bColorIsCoherent == true && bValueIsCoherent == true)
               bCode = true;
            else
               bCode = false;
            return( bCode);
        } // 0
        

    les erreurs reportées

    1>..\..\..\..\Linguistic\Coherence\src\BuildComponents.cpp(3801): error C2679: '=' binaire : aucun opérateur trouvé qui accepte un opérande de partie droite de type 'std::_List_iterator<_Mylist>' (ou il n'existe pas de conversion acceptable)
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *,std::allocator<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *>>
    1>          ]
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\list(393): peut être 'std::_List_iterator<_Mylist> &std::_List_iterator<_Mylist>::operator =(const std::_List_iterator<_Mylist> &)'
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<CAnalysedWord *,std::allocator<CAnalysedWord *>>
    1>          ]
    1>          lors de la tentative de mise en correspondance de la liste des arguments '(std::_List_iterator<_Mylist>, std::_List_iterator<_Mylist>)'
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<CAnalysedWord *,std::allocator<CAnalysedWord *>>
    1>          ]
    1>          and
    1>          [
    1>              _Mylist=std::_List_val<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *,std::allocator<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *>>
    1>          ]
    1>..\..\..\..\Linguistic\Coherence\src\BuildComponents.cpp(3802): error C2678: '!=' binaire : aucun opérateur trouvé qui accepte un opérande de partie gauche de type 'std::_List_iterator<_Mylist>' (ou il n'existe pas de conversion acceptable)
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<CAnalysedWord *,std::allocator<CAnalysedWord *>>
    1>          ]
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\system_error(425): peut être 'bool std::operator !=(const std::error_code &,const std::error_condition &)'
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\system_error(432): ou       'bool std::operator !=(const std::error_condition &,const std::error_code &)'
    1>          C:\Program Files\Microsoft SDKs\Windows\v7.0A\include\guiddef.h(197): ou       'int operator !=(const GUID &,const GUID &)'
    1>          e:\Program Files\Microsoft Visual Studio 10.0\VC\include\list(298): ou       'bool std::_List_const_iterator<_Mylist>::operator !=(const std::_List_const_iterator<_Mylist> &) const'
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<CAnalysedWord *,std::allocator<CAnalysedWord *>>
    1>          ]
    1>          lors de la tentative de mise en correspondance de la liste des arguments '(std::_List_iterator<_Mylist>, std::_List_iterator<_Mylist>)'
    1>          with
    1>          [
    1>              _Mylist=std::_List_val<CAnalysedWord *,std::allocator<CAnalysedWord *>>
    1>          ]
    1>          and
    1>          [
    1>              _Mylist=std::_List_val<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *,std::allocator<std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>> *>>
    1>          ]
    1>..\..\..\..\Linguistic\Coherence\src\BuildComponents.cpp(3802): fatal error C1903: impossible de récupérer à partir des erreurs précédentes ; arrêt de la compilation
    1>


    Jean Noël Martin

    jeudi 17 octobre 2013 23:58

Réponses