From 0c38be8f8dd39a7c9509eaac2be3ef08026b348d Mon Sep 17 00:00:00 2001 From: dpasukhi Date: Mon, 11 Jan 2021 13:20:31 +0300 Subject: [PATCH] 0031970: Data Exchange, STEP reader - parser syntax error messages are inaccessible - Upgraded files using new version of WinFlexBison - Removed global variables within StepFile_Read.cxx - Upgraded error message during bison analyzing ( added a expected expression information ) - Used 'Interface_ParamType' as argument type for the StepFile_ReadData::Argument for a compatibility with the StepData/StepData_StepReaderData - Added handling parse errors and transferring it to the StepData_StepReaderData - Now parsing and referencing errors save in the check and non output by default - Step_file's and Step_Data's output info prints according by trace level of printer - Removed useless location.hxx - Removed TraceLevel for the StepFile_Reader ( now it useless, it is 0 by default and newer and nowhere change ) - Translate error message into English within StepData_StepReaderData - Replace "Error" word in the output messages --- src/ExprIntrp/ExprIntrp.tab.c | 10 +- src/ExprIntrp/ExprIntrp.tab.h | 2 +- src/ExprIntrp/lex.ExprIntrp.c | 2 +- src/StepData/StepData_StepReaderData.cxx | 32 +-- src/StepData/StepData_StepReaderTool.cxx | 16 +- src/StepFile/FILES | 1 - src/StepFile/StepFile_Read.cxx | 168 ++++++------ src/StepFile/StepFile_Read.hxx | 26 +- src/StepFile/StepFile_ReadData.cxx | 118 +++++++-- src/StepFile/StepFile_ReadData.hxx | 37 +-- src/StepFile/lex.step.cxx | 18 +- src/StepFile/location.hh | 302 ---------------------- src/StepFile/step.lex | 18 +- src/StepFile/step.tab.cxx | 267 ++++++++++++++----- src/StepFile/step.tab.hxx | 67 ++--- src/StepFile/step.yacc | 35 +-- src/StepSelect/StepSelect_WorkLibrary.cxx | 2 - tests/de/step_1/R9 | 2 +- 18 files changed, 499 insertions(+), 624 deletions(-) delete mode 100644 src/StepFile/location.hh diff --git a/src/ExprIntrp/ExprIntrp.tab.c b/src/ExprIntrp/ExprIntrp.tab.c index b8e1203779..42379f3ef1 100644 --- a/src/ExprIntrp/ExprIntrp.tab.c +++ b/src/ExprIntrp/ExprIntrp.tab.c @@ -1,4 +1,4 @@ -/* A Bison parser, made by GNU Bison 3.7.1. */ +/* A Bison parser, made by GNU Bison 3.7.4. */ /* Bison implementation for Yacc-like parsers in C @@ -45,11 +45,11 @@ define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ -/* Identify Bison output. */ -#define YYBISON 1 +/* Identify Bison output, and Bison version. */ +#define YYBISON 30704 -/* Bison version. */ -#define YYBISON_VERSION "3.7.1" +/* Bison version string. */ +#define YYBISON_VERSION "3.7.4" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" diff --git a/src/ExprIntrp/ExprIntrp.tab.h b/src/ExprIntrp/ExprIntrp.tab.h index 897b12ceb1..069d7f41ee 100644 --- a/src/ExprIntrp/ExprIntrp.tab.h +++ b/src/ExprIntrp/ExprIntrp.tab.h @@ -1,4 +1,4 @@ -/* A Bison parser, made by GNU Bison 3.7.1. */ +/* A Bison parser, made by GNU Bison 3.7.4. */ /* Bison interface for Yacc-like parsers in C diff --git a/src/ExprIntrp/lex.ExprIntrp.c b/src/ExprIntrp/lex.ExprIntrp.c index 93ecde6507..0bd3db536e 100644 --- a/src/ExprIntrp/lex.ExprIntrp.c +++ b/src/ExprIntrp/lex.ExprIntrp.c @@ -1515,7 +1515,7 @@ static int yy_get_next_buffer (void) yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; yy_is_jam = (yy_current_state == 54); - return yy_is_jam ? 0 : yy_current_state; + return yy_is_jam ? 0 : yy_current_state; } #ifndef YY_NO_UNPUT diff --git a/src/StepData/StepData_StepReaderData.cxx b/src/StepData/StepData_StepReaderData.cxx index ecc36a0e3c..ca2ebcff7c 100644 --- a/src/StepData/StepData_StepReaderData.cxx +++ b/src/StepData/StepData_StepReaderData.cxx @@ -381,16 +381,15 @@ void StepData_StepReaderData::SetRecord(const Standard_Integer num, errm.AssignCat(" / "); errm.AssignCat(thenametypes.FindKey(thetypes.Value(num))); errm.AssignCat(" ... "); -#ifdef OCCT_DEBUG while (theidents(prev) <= 0) { prev--; if (prev <= 0) break; } - Message_Messenger::StreamBuffer sout = Message::SendInfo(); - sout << " *** Error on Record " << num << " (on " << NbRecords() - << " -> " << num * 100 / NbRecords() << " % in File) ***"; + + Message_Messenger::StreamBuffer sout = Message::SendTrace(); + sout << " *** Incorrect record " << num << " (on " << NbRecords() + << " -> " << num * 100 / NbRecords() << " % in File) ***"; if (prev > 0) sout << " Ident #" << theidents(prev); sout << "\n" << errm << std::endl; -#endif thecheck->AddWarning(errm.ToCString(), "Complex Type incorrect : "); } break; @@ -1730,7 +1729,7 @@ Standard_Integer StepData_StepReaderData::FindEntityNumber(const Standard_Intege void StepData_StepReaderData::SetEntityNumbers(const Standard_Boolean withmap) { - Message_Messenger::StreamBuffer sout = Message::SendInfo(); + Message_Messenger::StreamBuffer sout = Message::SendTrace(); // Passe initiale : Resolution directe par Map // si tout passe (pas de collision), OK. Sinon, autres passes a prevoir // On resoud du meme coup les sous-listes @@ -1775,7 +1774,8 @@ void StepData_StepReaderData::SetEntityNumbers(const Standard_Boolean withmap) if (letype == Interface_ParamSub) { Standard_Integer numsub = FP.EntityNumber(); if (numsub > thelastn) { - sout << "Bad Sub.N0, Record " << num << " Param " << na << ":$" << numsub << std::endl; + Message::SendInfo() + << "Bad Sub.N0, Record " << num << " Param " << na << ":$" << numsub << std::endl; continue; } FP.SetEntityNumber(subn(numsub)); @@ -1798,9 +1798,9 @@ void StepData_StepReaderData::SetEntityNumbers(const Standard_Boolean withmap) ident, na, id); thecheck->AddFail(failmess, "Unresolved Reference"); // ... Et sortir message un peu plus complet - sout << "*** ERR StepReaderData *** Pour Entite #" << ident - << "\n Type:" << RecordType(num) - << " Param.n0 " << na << ": #" << id << " Non trouve" << std::endl; + sout << "*** ERR StepReaderData *** Entite #" << ident + << "\n Type:" << RecordType(num) + << " Param.n0 " << na << ": #" << id << " Not found" << std::endl; } // FIN Mapping } // FIN Traitement Reference } // FIN Boucle Parametres @@ -1867,7 +1867,7 @@ void StepData_StepReaderData::SetEntityNumbers(const Standard_Boolean withmap) char ligne[80]; sprintf(ligne, "Ident defined SEVERAL TIMES : #%d", ident); thecheck->AddFail(ligne, "Ident defined SEVERAL TIMES : #%d"); - sout << "StepReaderData:SetEntityNumbers, " << ligne << std::endl; + sout << "StepReaderData : SetEntityNumbers, " << ligne << std::endl; } if (indm(indmap) > 0) indm(indmap) = -indm(indmap); // Pas pour Map // Cas Normal pour la Map @@ -2056,11 +2056,13 @@ void StepData_StepReaderData::SetEntityNumbers(const Standard_Boolean withmap) "Unresolved Reference, Ent.n0 %d (Id.#%d) Param.n0 %d (Id.#%d)", nument, ident, na, id); thecheck->AddFail(failmess, "Unresolved Reference"); + // ... Et sortir message un peu plus complet - sout << "*** ERR StepReaderData *** Pour Entite " << nument - << ", a " << (nr * 100) / nbseq << "% de DATA : #" << ident - << "\n Type:" << RecordType(num) - << " Param.n0 " << na << ": #" << id << " Non trouve" << std::endl; + sout << "*** ERR StepReaderData *** Entite " << nument + << ", a " << (nr * 100) / nbseq << "% de DATA : #" << ident + << "\n Type:" << RecordType(num) + << " Param.n0 " << na << ": #" << id << " Not found" << std::endl; + FP.SetEntityNumber(0); // -> Reference non resolue } } diff --git a/src/StepData/StepData_StepReaderTool.cxx b/src/StepData/StepData_StepReaderTool.cxx index 7e52ae77dd..1e8146d9fc 100644 --- a/src/StepData/StepData_StepReaderTool.cxx +++ b/src/StepData/StepData_StepReaderTool.cxx @@ -159,7 +159,7 @@ void StepData_StepReaderTool::PrepareHeader void StepData_StepReaderTool::BeginRead (const Handle(Interface_InterfaceModel)& amodel) { - Message_Messenger::StreamBuffer sout = Message::SendInfo(); + Message_Messenger::StreamBuffer sout = Message::SendTrace(); DeclareAndCast(StepData_StepModel,model,amodel); DeclareAndCast(StepData_StepReaderData,stepdat,Data()); @@ -185,16 +185,20 @@ void StepData_StepReaderTool::BeginRead Standard_Integer nbmess = ach->NbWarnings(); sout<DynamicType()->Name() << std::endl; - for (Standard_Integer nf = 1; nf <= nbmess; nf ++) - sout << ach->CWarning(nf) << "\n"; + for (Standard_Integer nf = 1; nf <= nbmess; nf++) + { + sout << ach->CWarning(nf) << "\n"; + } } if (ach->HasFailed()) { Handle(Interface_Check) mch = model->GlobalCheck(); Standard_Integer nbmess = ach->NbFails(); - sout << " Errors on Reading Header Entity N0."<DynamicType()->Name() << std::endl; - for (Standard_Integer nf = 1; nf <= nbmess; nf ++) - sout << ach->CFail(nf) << "\n"; + for (Standard_Integer nf = 1; nf <= nbmess; nf++) + { + sout << ach->CFail(nf) << "\n"; + } } } } diff --git a/src/StepFile/FILES b/src/StepFile/FILES index 92d0bcd745..733a836129 100755 --- a/src/StepFile/FILES +++ b/src/StepFile/FILES @@ -8,4 +8,3 @@ StepFile_Read.hxx step.lex step.yacc FlexLexer.h -location.hh diff --git a/src/StepFile/StepFile_Read.cxx b/src/StepFile/StepFile_Read.cxx index aec22f1897..06068319b2 100644 --- a/src/StepFile/StepFile_Read.cxx +++ b/src/StepFile/StepFile_Read.cxx @@ -27,24 +27,27 @@ #include #include -#include -#include +#include +#include +#include + +#include +#include #include #include -#include -#include +#include +#include +#include #include #include -#include #include #include -#include -#include #include +#include #include #include @@ -53,31 +56,22 @@ #define CHRONOMESURE #endif -// ## ## ## ## ON SAURA AU MOINS TRAITER UndefinedEntity ## ## ## ## - -extern "C" void recfile_modeprint (int mode); // controle trace recfile - -static Handle(Interface_Check) checkread = new Interface_Check; -static Standard_Integer modepr = 1; - -void StepFile_ReadTrace (const Standard_Integer mode) +void StepFile_Interrupt(Standard_CString theErrorMessage, const Standard_Boolean theIsFail) { - modepr = mode; // recfile_modeprint est rappele a chaque lecture de fichier + if (theErrorMessage == NULL) + return; + + Message_Messenger::StreamBuffer sout = theIsFail ? Message::SendFail() : Message::SendTrace(); + sout << "**** ERR StepFile : " << theErrorMessage << " ****" << std::endl; } -// ## ## ## ## ## ## Corps de la Routine ## ## ## ## ## ## - -static Interface_ParamType LesTypes[10]; // passage types (recstep/Interface) - static Standard_Integer StepFile_Read (const char* theName, std::istream* theIStream, - const Handle(StepData_StepModel)& stepmodel, - const Handle(StepData_Protocol)& protocol, - const Handle(StepData_FileRecognizer)& recoheader, - const Handle(StepData_FileRecognizer)& recodata) + const Handle(StepData_StepModel)& theStepModel, + const Handle(StepData_Protocol)& theProtocol, + const Handle(StepData_FileRecognizer)& theRecogHeader, + const Handle(StepData_FileRecognizer)& theRecogData) { - StepFile_ReadData aFileDataModel; - aFileDataModel.SetModePrint(modepr > 0 ? modepr - 1 : 0); // if stream is not provided, open file stream here std::istream *aStreamPtr = theIStream; std::ifstream aFileStream; @@ -95,8 +89,12 @@ static Standard_Integer StepFile_Read (const char* theName, OSD_Timer c; c.Reset(); c.Start(); - Message::SendInfo() << " ... Step File Reading : '" << theName << "'"; #endif + + Message_Messenger::StreamBuffer sout = Message::SendTrace(); + sout << " ... Step File Reading : '" << theName << "'"; + + StepFile_ReadData aFileDataModel; try { OCC_CATCH_SIGNALS int aLetat = 0; @@ -105,123 +103,101 @@ static Standard_Integer StepFile_Read (const char* theName, step::parser aParser(&aScanner); aLetat = aParser.parse(); if (aLetat != 0) { + StepFile_Interrupt(aFileDataModel.GetLastError(), Standard_True); return 1; } } catch (Standard_Failure const& anException) { -#ifdef OCCT_DEBUG - Message::SendAlarm() << " ... Exception Raised while reading Step File : '" << theName << "':\n" - << anException.GetMessageString() - << " ..."; -#endif - (void)anException; + Message::SendFail() << " ... Exception Raised while reading Step File : '" << theName << "':\n" + << anException << " ..."; return 1; } -// Continue reading of file despite of possible fails -// if (checkread->HasFailed()) { lir_file_fin(3); stepread_endinput(newifstream, ficnom); return 1; } #ifdef CHRONOMESURE - { - Message_Messenger::StreamBuffer sout = Message::SendInfo(); - sout << " ... STEP File Read ...\n"; - c.Show (sout); - } + c.Show(sout); #endif -// Creation du StepReaderData - - LesTypes[ArgumentType_Nondef] = Interface_ParamVoid ; - LesTypes[ArgumentType_Sub] = Interface_ParamSub ; - LesTypes[ArgumentType_Ident] = Interface_ParamIdent ; - LesTypes[ArgumentType_Integer] = Interface_ParamInteger ; - LesTypes[ArgumentType_Float] = Interface_ParamReal ; - LesTypes[ArgumentType_Enum] = Interface_ParamEnum ; - LesTypes[ArgumentType_Binary] = Interface_ParamBinary ; - LesTypes[ArgumentType_Text] = Interface_ParamText ; - LesTypes[ArgumentType_Hexa] = Interface_ParamHexa ; - LesTypes[ArgumentType_Misc] = Interface_ParamMisc ; + sout << " ... STEP File Read ...\n"; Standard_Integer nbhead, nbrec, nbpar; aFileDataModel.GetFileNbR (&nbhead,&nbrec,&nbpar); // renvoi par lex/yacc Handle(StepData_StepReaderData) undirec = - new StepData_StepReaderData(nbhead,nbrec,nbpar, stepmodel->SourceCodePage()); // creation tableau de records - + new StepData_StepReaderData(nbhead,nbrec,nbpar, theStepModel->SourceCodePage()); // creation tableau de records for ( Standard_Integer nr = 1; nr <= nbrec; nr ++) { int nbarg; char* ident; char* typrec = 0; aFileDataModel.GetRecordDescription(&ident, &typrec, &nbarg); undirec->SetRecord (nr, ident, typrec, nbarg); if (nbarg>0) { - ArgumentType typa; char* val; - Interface_ParamType newtype; + Interface_ParamType typa; char* val; while(aFileDataModel.GetArgDescription (&typa, &val) == 1) { - newtype = LesTypes[typa] ; - undirec->AddStepParam (nr, val, newtype); + undirec->AddStepParam (nr, val, typa); } } undirec->InitParams(nr); aFileDataModel.NextRecord(); } + + aFileDataModel.ErrorHandle(undirec->GlobalCheck()); + Standard_Integer anFailsCount = undirec->GlobalCheck()->NbFails(); + if (anFailsCount > 0) + { + Message::SendInfo() << "**** ERR StepFile : Incorrect Syntax : Fails Count : " + << anFailsCount << " ****"; + } + aFileDataModel.ClearRecorder(1); -// on a undirec pret pour la suite + + sout << " ... Step File loaded ...\n"; + sout << " " << undirec->NbRecords() << " records (entities,sub-lists,scopes), " << nbpar << " parameters"; #ifdef CHRONOMESURE - { - Message_Messenger::StreamBuffer sout = Message::SendInfo(); - sout << " ... Step File loaded ...\n"; - c.Show (sout); - sout << " "<< undirec->NbRecords() << " records (entities,sub-lists,scopes), "<< nbpar << " parameters"; - } + c.Show(sout); #endif // Analyse : par StepReaderTool - StepData_StepReaderTool readtool (undirec,protocol); + StepData_StepReaderTool readtool (undirec, theProtocol); readtool.SetErrorHandle (Standard_True); - readtool.PrepareHeader(recoheader); // Header. reco nul -> pour Protocol - readtool.Prepare(recodata); // Data. reco nul -> pour Protocol + readtool.PrepareHeader(theRecogHeader); // Header. reco nul -> pour Protocol + readtool.Prepare(theRecogData); // Data. reco nul -> pour Protocol + + sout << " ... Parameters prepared ...\n"; #ifdef CHRONOMESURE - { - Message_Messenger::StreamBuffer sout = Message::SendInfo(); - sout << " ... Parameters prepared ...\n"; - c.Show (sout); - } + c.Show(sout) #endif - readtool.LoadModel(stepmodel); - if (stepmodel->Protocol().IsNull()) stepmodel->SetProtocol (protocol); + readtool.LoadModel(theStepModel); + if (theStepModel->Protocol().IsNull()) theStepModel->SetProtocol (theProtocol); aFileDataModel.ClearRecorder(2); - + anFailsCount = undirec->GlobalCheck()->NbFails() - anFailsCount; + if (anFailsCount > 0) + { + Message::SendInfo() << "*** ERR StepReaderData : Unresolved Reference : Fails Count : " + << anFailsCount << " ***"; + } + readtool.Clear(); undirec.Nullify(); + + sout << " ... Objects analysed ...\n"; + Standard_Integer n = theStepModel->NbEntities(); + sout << " STEP Loading done : " << n << " Entities"; + #ifdef CHRONOMESURE - { - Message_Messenger::StreamBuffer sout = Message::SendInfo(); - sout << " ... Objets analysed ...\n"; - c.Show (sout); - Standard_Integer n = stepmodel->NbEntities(); - sout << " STEP Loading done : " << n << " Entities"; - } + c.Show(sout); #endif + return 0; } Standard_Integer StepFile_Read(const char* theName, std::istream* theIStream, - const Handle(StepData_StepModel)& stepmodel, - const Handle(StepData_Protocol)& protocol) + const Handle(StepData_StepModel)& theStepModel, + const Handle(StepData_Protocol)& theProtocol) { - Handle(StepData_FileRecognizer) nulreco; - return StepFile_Read (theName,theIStream,stepmodel,protocol,nulreco,nulreco); -} - -void StepFile_Interrupt (char* mess) -{ -#ifdef OCCT_DEBUG - Message_Messenger::StreamBuffer sout = Message::SendInfo(); - sout << " **** StepFile Error : " << mess << " ****" << std::endl; -#endif - checkread->AddFail(mess); + Handle(StepData_FileRecognizer) aNulRecog; + return StepFile_Read(theName, theIStream, theStepModel, theProtocol, aNulRecog, aNulRecog); } diff --git a/src/StepFile/StepFile_Read.hxx b/src/StepFile/StepFile_Read.hxx index f02ced5c54..3f51411c5f 100644 --- a/src/StepFile/StepFile_Read.hxx +++ b/src/StepFile/StepFile_Read.hxx @@ -14,27 +14,19 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. -// StepFile_Read.hxx - -// routine assurant l'enchainement des operations de lecture d'un fichier -// STEP dans un StepModel, en fonction d'une cle de reconnaissance -// Retour de la fonction : -// 0 si OK (le StepModel a ete charge) -// -1 si abandon car fichier pas pu etre ouvert -// 1 si erreur en cours de lecture - - #ifndef StepFile_Read_HeaderFile #define StepFile_Read_HeaderFile -#include -//# include : sauf recfile_modeprint, declare ici -# include -# include -# include +#include -Standard_EXPORT void StepFile_ReadTrace (const Standard_Integer mode); -// Modal : 0 pas de trace, 1 trace LoadModel, 2 & 3 + trace interne lex-yac +class StepData_StepModel; +class StepData_Protocol; + +//! Prints the error message +//! @param theErrorMessage - error message for output +//! @param theFail - if true output as a fail info, else output as a trace info ( log ) +void StepFile_Interrupt(Standard_CString theErrorMessage, + const Standard_Boolean theIsFail = Standard_True); //! Working function reading STEP file or stream. //! @param theName - name of the file or stream diff --git a/src/StepFile/StepFile_ReadData.cxx b/src/StepFile/StepFile_ReadData.cxx index 5099008339..8ee4177e8c 100644 --- a/src/StepFile/StepFile_ReadData.cxx +++ b/src/StepFile/StepFile_ReadData.cxx @@ -15,6 +15,9 @@ #include +#include +#include + // Constant litterales namespace TextValue { @@ -61,7 +64,7 @@ public: public: - Argument() :myNext(NULL), myValue(NULL), myType(ArgumentType_Sub) {} + Argument() :myNext(NULL), myValue(NULL), myType(Interface_ParamSub) {} ~Argument() {} @@ -69,7 +72,7 @@ public: Argument* myNext; //!< Next argument in the list for this record char* myValue; //!< Character value of the argument - ArgumentType myType; //!< Type of the argument + Interface_ParamType myType; //!< Type of the argument }; class StepFile_ReadData::ArgumentsPage { @@ -143,7 +146,6 @@ public: Record* myRecord; //!< Record interrupted by the scope (to resume) }; - class StepFile_ReadData::RecordsPage { @@ -170,6 +172,29 @@ public: int myUsed; //!< Counter employed records }; +class StepFile_ReadData::ErrorsPage +{ + +public: + + ErrorsPage(Standard_CString theError) :myNext(NULL), myError(theError) + {} + + //! Returns point to the next ErrorsPage + ErrorsPage* NextErrorPage() const { return myNext; } + + //! Sets the next ErrorPage + void SetNextErrorPage(ErrorsPage* theNextErrorsPage) { myNext = theNextErrorsPage; } + + //! Returns an error message + Standard_CString ErrorMessage() const { return myError.ToCString(); } + +private: + + ErrorsPage* myNext; //!< Chaining of records pages + TCollection_AsciiString myError; //!< Own error message +}; + //======================================================================= //function : StepFile_ReadData //purpose : @@ -179,8 +204,8 @@ StepFile_ReadData::StepFile_ReadData() :myMaxChar(50000), myMaxRec(5000), myMaxArg(10000), myModePrint(0), myNbRec(0), myNbHead(0), myNbPar(0), myYaRec(0), myNumSub(0), myErrorArg(Standard_False), myResText(NULL), myCurrType(TextValue::SubList), - mySubArg(NULL), myTypeArg(ArgumentType_Sub), myCurrArg(NULL), myFirstRec(NULL), - myCurRec(NULL), myLastRec(NULL), myCurScope(NULL) + mySubArg(NULL), myTypeArg(Interface_ParamSub), myCurrArg(NULL), myFirstRec(NULL), + myCurRec(NULL), myLastRec(NULL), myCurScope(NULL), myFirstError(NULL), myCurError(NULL) { myOneCharPage = new CharactersPage(myMaxChar); myOneArgPage = new ArgumentsPage(myMaxArg); @@ -238,7 +263,7 @@ void StepFile_ReadData::RecordNewEntity() { myErrorArg = Standard_False; // Reset error argument mod AddNewRecord(myCurRec); - SetTypeArg(ArgumentType_Sub); + SetTypeArg(Interface_ParamSub); mySubArg = myCurRec->myIdent; myCurRec = myCurRec->myNext; myLastRec->myNext = NULL; @@ -331,12 +356,12 @@ void StepFile_ReadData::CreateNewArg() aNewArg = &myOneArgPage->myArgs[myOneArgPage->myUsed]; myOneArgPage->myUsed++; aNewArg->myType = myTypeArg; - if (myTypeArg == ArgumentType_Sub) + if (myTypeArg == Interface_ParamSub) aNewArg->myValue = mySubArg; else GetResultText(&aNewArg->myValue); - if (myTypeArg == ArgumentType_Misc) + if (myTypeArg == Interface_ParamMisc) myErrorArg = Standard_True; if (myCurRec->myFirst == NULL) @@ -364,7 +389,7 @@ void StepFile_ReadData::CreateErrorArg() // If already exists - update text value if (!myErrorArg) { - SetTypeArg(ArgumentType_Misc); + SetTypeArg(Interface_ParamMisc); CreateNewArg(); myErrorArg = Standard_True; return; @@ -421,7 +446,7 @@ void StepFile_ReadData::FinalOfScope() PrintRecord(myLastRec); } myCurRec = aRecord; - myTypeArg = ArgumentType_Sub; + myTypeArg = Interface_ParamSub; CreateNewArg(); } @@ -445,26 +470,28 @@ void StepFile_ReadData::ClearRecorder(const Standard_Integer theMode) { while (myOneRecPage != NULL) { - RecordsPage* aNewPage; - aNewPage = myOneRecPage->myNext; + RecordsPage* aNewPage = myOneRecPage->myNext; delete myOneRecPage; - myOneRecPage = NULL; myOneRecPage = aNewPage; } while (myOneArgPage != NULL) { - ArgumentsPage* aNewPage; aNewPage = myOneArgPage->myNext; + ArgumentsPage* aNewPage = myOneArgPage->myNext; delete myOneArgPage; - myOneArgPage = NULL; myOneArgPage = aNewPage; } + while (myFirstError != NULL) + { + ErrorsPage* aNewErrorPage = myFirstError->NextErrorPage(); + delete myFirstError; + myFirstError = aNewErrorPage; + } } if (theMode & 2) { while (myOneCharPage != NULL) { - CharactersPage* aNewPage; aNewPage = myOneCharPage->myNext; + CharactersPage* aNewPage = myOneCharPage->myNext; delete myOneCharPage; - myOneCharPage = NULL; myOneCharPage = aNewPage; } } @@ -475,7 +502,7 @@ void StepFile_ReadData::ClearRecorder(const Standard_Integer theMode) //purpose : //======================================================================= -Standard_Boolean StepFile_ReadData::GetArgDescription(ArgumentType* theType, char** theValue) +Standard_Boolean StepFile_ReadData::GetArgDescription(Interface_ParamType* theType, char** theValue) { if (myCurrArg == NULL) return Standard_False; @@ -491,8 +518,8 @@ Standard_Boolean StepFile_ReadData::GetArgDescription(ArgumentType* theType, cha //======================================================================= void StepFile_ReadData::GetFileNbR(Standard_Integer* theNbHead, - Standard_Integer* theNbRec, - Standard_Integer* theNbPage) + Standard_Integer* theNbRec, + Standard_Integer* theNbPage) { myCurRec = myFirstRec; *theNbHead = myNbHead; @@ -506,8 +533,8 @@ void StepFile_ReadData::GetFileNbR(Standard_Integer* theNbHead, //======================================================================= Standard_Boolean StepFile_ReadData::GetRecordDescription(char** theIdent, - char** theType, - int* theNbArg) + char** theType, + int* theNbArg) { if (myCurRec == NULL) return Standard_False; @@ -573,7 +600,7 @@ void StepFile_ReadData::FinalOfHead() //purpose : //======================================================================= -void StepFile_ReadData::SetTypeArg(const ArgumentType theArgType) +void StepFile_ReadData::SetTypeArg(const Interface_ParamType theArgType) { myTypeArg = theArgType; } @@ -608,6 +635,51 @@ Standard_Integer StepFile_ReadData::GetNbRecord() const return myNbRec; } +//======================================================================= +//function : AddError +//purpose : +//======================================================================= +void StepFile_ReadData::AddError(Standard_CString theErrorMessage) +{ + if (myFirstError == NULL) + { + myFirstError = new ErrorsPage(theErrorMessage); + myCurError = myFirstError; + } + else + { + myCurError->SetNextErrorPage(new ErrorsPage(theErrorMessage)); + myCurError = myCurError->NextErrorPage(); + } +} + +//======================================================================= +//function : ErrorHandle +//purpose : +//======================================================================= +Standard_Boolean StepFile_ReadData::ErrorHandle(const Handle(Interface_Check)& theCheck) const +{ + if (myFirstError != NULL) + { + ErrorsPage* aCurrent = myFirstError; + while (aCurrent != NULL) + { + theCheck->AddFail(aCurrent->ErrorMessage(), "Undefined Parsing"); + aCurrent = aCurrent->NextErrorPage(); + } + } + return myFirstError == NULL; +} + +//======================================================================= +//function : GetLastError +//purpose : +//======================================================================= +Standard_CString StepFile_ReadData::GetLastError() const +{ + return myCurError != NULL ? myCurError->ErrorMessage() : NULL; +} + //======================================================================= //function : RecordNewText //purpose : diff --git a/src/StepFile/StepFile_ReadData.hxx b/src/StepFile/StepFile_ReadData.hxx index da4d7c8311..49c98adae2 100644 --- a/src/StepFile/StepFile_ReadData.hxx +++ b/src/StepFile/StepFile_ReadData.hxx @@ -16,23 +16,12 @@ #ifndef _StepFile_ReadData_HeaderFile #define _StepFile_ReadData_HeaderFile -// Types of arguments -enum ArgumentType { - ArgumentType_Sub = 0, - ArgumentType_Integer, - ArgumentType_Float, - ArgumentType_Ident, - ArgumentType_Text, - ArgumentType_Nondef, - ArgumentType_Enum, - ArgumentType_Hexa, - ArgumentType_Binary, - ArgumentType_Misc -}; - #include +#include #include +#include + //! Provides data structures and tools to collect and store the data //! read from the STEP file. //! This class is designed to work in collaboration with STEP parser @@ -114,6 +103,8 @@ enum ArgumentType { //! threads) provided that each file is read using its own instances of Flex, Bison //! and StepFile_ReadData tools. +class Interface_Check; + class StepFile_ReadData { public: @@ -128,6 +119,7 @@ private: class ArgumentsPage; //!< List of arguments pages, contains all text derived from Flex class Scope; //!< List of scopes pages, contains all records for external processing class RecordsPage; //!< List of records pages, contains all records + class ErrorsPage; //!< List of errors messages, containts all errors public: @@ -178,7 +170,7 @@ public: void ClearRecorder(const Standard_Integer theMode); //! Returns a value of fields of current argument - Standard_Boolean GetArgDescription(ArgumentType* theType, char** theValue); + Standard_Boolean GetArgDescription(Interface_ParamType* theType, char** theValue); //! Returns a value of all file counters void GetFileNbR(Standard_Integer* theNbHead, Standard_Integer* theNbRec, Standard_Integer* theNbPage); @@ -203,7 +195,7 @@ public: void FinalOfHead(); //! Sets type of the current argument - void SetTypeArg(const ArgumentType theArgType); + void SetTypeArg(const Interface_ParamType theArgType); //! Initializes the print mode //! 0 - don't print descriptions @@ -217,6 +209,15 @@ public: //! Returns number of records Standard_Integer GetNbRecord() const; + //! Adds an error message + void AddError(Standard_CString theErrorMessage); + + //! Transfers error messages to checker + Standard_Boolean ErrorHandle(const Handle(Interface_Check)& theCheck) const; + + //! Returns the message of the last error + Standard_CString GetLastError() const; + private: //! Prepare text to analyze @@ -250,12 +251,14 @@ private: char* myResText; //!< Text value written by Flex and passed to Bison to create record char* myCurrType; //!< Type of last record read char* mySubArg; //!< Ident last record (possible sub-list) - ArgumentType myTypeArg; //!< Type of last argument read + Interface_ParamType myTypeArg; //!< Type of last argument read Argument* myCurrArg; //!< Current node of the argumets list Record* myFirstRec; //!< First node of the records list Record* myCurRec; //!< Current node of the records list Record* myLastRec; //!< Last node of the records list Scope* myCurScope; //!< Current node of the scopes list + ErrorsPage* myFirstError; //!< First node of the errors pages list + ErrorsPage* myCurError; //!< Current node of the errors pages list RecordsPage* myOneRecPage; //!< Current node of the records pages list CharactersPage* myOneCharPage; //!< Current node of the characters pages list ArgumentsPage* myOneArgPage; //!< Current node of the arguments pages list diff --git a/src/StepFile/lex.step.cxx b/src/StepFile/lex.step.cxx index 7de3419ca0..24d51f0a0a 100644 --- a/src/StepFile/lex.step.cxx +++ b/src/StepFile/lex.step.cxx @@ -653,7 +653,7 @@ goto find_rule; \ #ifdef YY_DECL # undef YY_DECL #endif -#define YY_DECL int step::scanner::lex (step::parser::semantic_type* /*yylval*/, step::parser::location_type* /*yylloc*/) +#define YY_DECL int step::scanner::lex (step::parser::semantic_type* /*yylval*/) typedef step::parser::token token; @@ -959,7 +959,7 @@ YY_LINENO_REWIND_TO(yy_bp + 1); (yy_c_buf_p) = yy_cp = yy_bp + 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -{ BEGIN(INITIAL); CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Text); return(token::QUID); } /* end of string (apostrophe followed by comma or closing parenthesis) - reset the scanner to initial state, record the value of all yytext collected */ +{ BEGIN(INITIAL); CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamText); return(token::QUID); } /* end of string (apostrophe followed by comma or closing parenthesis) - reset the scanner to initial state, record the value of all yytext collected */ YY_BREAK case 10: YY_RULE_SETUP @@ -999,23 +999,23 @@ YY_RULE_SETUP YY_BREAK case 18: YY_RULE_SETUP -{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Integer); return(token::QUID); } +{ CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamInteger); return(token::QUID); } YY_BREAK case 19: YY_RULE_SETUP -{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Float); return(token::QUID); } +{ CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamReal); return(token::QUID); } YY_BREAK case 20: YY_RULE_SETUP -{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Float); return(token::QUID); } +{ CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamReal); return(token::QUID); } YY_BREAK case 21: YY_RULE_SETUP -{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Hexa); return(token::QUID); } +{ CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamHexa); return(token::QUID); } YY_BREAK case 22: YY_RULE_SETUP -{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Enum); return(token::QUID); } +{ CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamEnum); return(token::QUID); } YY_BREAK case 23: YY_RULE_SETUP @@ -1031,7 +1031,7 @@ YY_RULE_SETUP YY_BREAK case 26: YY_RULE_SETUP -{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Nondef); return(token::QUID); } +{ CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamVoid); return(token::QUID); } YY_BREAK case 27: YY_RULE_SETUP @@ -1096,7 +1096,7 @@ YY_RULE_SETUP case 42: /* rule 42 can match eol */ YY_RULE_SETUP -{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Misc); return(token::QUID); } +{ CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamMisc); return(token::QUID); } YY_BREAK case 43: YY_RULE_SETUP diff --git a/src/StepFile/location.hh b/src/StepFile/location.hh deleted file mode 100644 index 450908104a..0000000000 --- a/src/StepFile/location.hh +++ /dev/null @@ -1,302 +0,0 @@ -// A Bison parser, made by GNU Bison 3.7.1. - -// Locations for Bison parsers in C++ - -// Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc. - -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with this program. If not, see . - -// As a special exception, you may create a larger work that contains -// part or all of the Bison parser skeleton and distribute that work -// under terms of your choice, so long as that work isn't itself a -// parser generator using the skeleton or a modified version thereof -// as a parser skeleton. Alternatively, if you modify or redistribute -// the parser skeleton itself, you may (at your option) remove this -// special exception, which will cause the skeleton and the resulting -// Bison output files to be licensed under the GNU General Public -// License without this special exception. - -// This special exception was added by the Free Software Foundation in -// version 2.2 of Bison. - -/** - ** \file StepFile/location.hh - ** Define the step::location class. - */ - -#ifndef YY_STEP_STEPFILE_LOCATION_HH_INCLUDED -# define YY_STEP_STEPFILE_LOCATION_HH_INCLUDED - -# include -# include - -# ifndef YY_NULLPTR -# if defined __cplusplus -# if 201103L <= __cplusplus -# define YY_NULLPTR nullptr -# else -# define YY_NULLPTR 0 -# endif -# else -# define YY_NULLPTR ((void*)0) -# endif -# endif - -namespace step { - - /// A point in a source file. - class position - { - public: - /// Type for file name. - typedef const std::string filename_type; - /// Type for line and column numbers. - typedef int counter_type; - - /// Construct a position. - explicit position (filename_type* f = YY_NULLPTR, - counter_type l = 1, - counter_type c = 1) - : filename (f) - , line (l) - , column (c) - {} - - - /// Initialization. - void initialize (filename_type* fn = YY_NULLPTR, - counter_type l = 1, - counter_type c = 1) - { - filename = fn; - line = l; - column = c; - } - - /** \name Line and Column related manipulators - ** \{ */ - /// (line related) Advance to the COUNT next lines. - void lines (counter_type count = 1) - { - if (count) - { - column = 1; - line = add_ (line, count, 1); - } - } - - /// (column related) Advance to the COUNT next columns. - void columns (counter_type count = 1) - { - column = add_ (column, count, 1); - } - /** \} */ - - /// File name to which this position refers. - filename_type* filename; - /// Current line number. - counter_type line; - /// Current column number. - counter_type column; - - private: - /// Compute max (min, lhs+rhs). - static counter_type add_ (counter_type lhs, counter_type rhs, counter_type min) - { - return lhs + rhs < min ? min : lhs + rhs; - } - }; - - /// Add \a width columns, in place. - inline position& - operator+= (position& res, position::counter_type width) - { - res.columns (width); - return res; - } - - /// Add \a width columns. - inline position - operator+ (position res, position::counter_type width) - { - return res += width; - } - - /// Subtract \a width columns, in place. - inline position& - operator-= (position& res, position::counter_type width) - { - return res += -width; - } - - /// Subtract \a width columns. - inline position - operator- (position res, position::counter_type width) - { - return res -= width; - } - - /** \brief Intercept output stream redirection. - ** \param ostr the destination output stream - ** \param pos a reference to the position to redirect - */ - template - std::basic_ostream& - operator<< (std::basic_ostream& ostr, const position& pos) - { - if (pos.filename) - ostr << *pos.filename << ':'; - return ostr << pos.line << '.' << pos.column; - } - - /// Two points in a source file. - class location - { - public: - /// Type for file name. - typedef position::filename_type filename_type; - /// Type for line and column numbers. - typedef position::counter_type counter_type; - - /// Construct a location from \a b to \a e. - location (const position& b, const position& e) - : begin (b) - , end (e) - {} - - /// Construct a 0-width location in \a p. - explicit location (const position& p = position ()) - : begin (p) - , end (p) - {} - - /// Construct a 0-width location in \a f, \a l, \a c. - explicit location (filename_type* f, - counter_type l = 1, - counter_type c = 1) - : begin (f, l, c) - , end (f, l, c) - {} - - - /// Initialization. - void initialize (filename_type* f = YY_NULLPTR, - counter_type l = 1, - counter_type c = 1) - { - begin.initialize (f, l, c); - end = begin; - } - - /** \name Line and Column related manipulators - ** \{ */ - public: - /// Reset initial location to final location. - void step () - { - begin = end; - } - - /// Extend the current location to the COUNT next columns. - void columns (counter_type count = 1) - { - end += count; - } - - /// Extend the current location to the COUNT next lines. - void lines (counter_type count = 1) - { - end.lines (count); - } - /** \} */ - - - public: - /// Beginning of the located region. - position begin; - /// End of the located region. - position end; - }; - - /// Join two locations, in place. - inline location& - operator+= (location& res, const location& end) - { - res.end = end.end; - return res; - } - - /// Join two locations. - inline location - operator+ (location res, const location& end) - { - return res += end; - } - - /// Add \a width columns to the end position, in place. - inline location& - operator+= (location& res, location::counter_type width) - { - res.columns (width); - return res; - } - - /// Add \a width columns to the end position. - inline location - operator+ (location res, location::counter_type width) - { - return res += width; - } - - /// Subtract \a width columns to the end position, in place. - inline location& - operator-= (location& res, location::counter_type width) - { - return res += -width; - } - - /// Subtract \a width columns to the end position. - inline location - operator- (location res, location::counter_type width) - { - return res -= width; - } - - /** \brief Intercept output stream redirection. - ** \param ostr the destination output stream - ** \param loc a reference to the location to redirect - ** - ** Avoid duplicate information. - */ - template - std::basic_ostream& - operator<< (std::basic_ostream& ostr, const location& loc) - { - location::counter_type end_col - = 0 < loc.end.column ? loc.end.column - 1 : 0; - ostr << loc.begin; - if (loc.end.filename - && (!loc.begin.filename - || *loc.begin.filename != *loc.end.filename)) - ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col; - else if (loc.begin.line < loc.end.line) - ostr << '-' << loc.end.line << '.' << end_col; - else if (loc.begin.column < end_col) - ostr << '-' << end_col; - return ostr; - } - -} // step - -#endif // !YY_STEP_STEPFILE_LOCATION_HH_INCLUDED diff --git a/src/StepFile/step.lex b/src/StepFile/step.lex index 54e2d46a0a..1f77493f45 100644 --- a/src/StepFile/step.lex +++ b/src/StepFile/step.lex @@ -44,7 +44,7 @@ #ifdef YY_DECL # undef YY_DECL #endif -#define YY_DECL int step::scanner::lex (step::parser::semantic_type* /*yylval*/, step::parser::location_type* /*yylloc*/) +#define YY_DECL int step::scanner::lex (step::parser::semantic_type* /*yylval*/) typedef step::parser::token token; @@ -97,7 +97,7 @@ long string in files Henri.stp and 401.stp*/ [\n] { yymore(); yylineno ++; } /* newline in text string - increment line counter and keep collecting yytext */ ['] { yymore(); } /* single ' inside text string - keep collecting yytext*/ [^\n']+ { yymore(); } /* a sequence of any characters except ' and \n - keep collecting yytext */ -[']/[" "\n\r]*[\)\,] { BEGIN(INITIAL); CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Text); return(token::QUID); } /* end of string (apostrophe followed by comma or closing parenthesis) - reset the scanner to initial state, record the value of all yytext collected */ +[']/[" "\n\r]*[\)\,] { BEGIN(INITIAL); CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamText); return(token::QUID); } /* end of string (apostrophe followed by comma or closing parenthesis) - reset the scanner to initial state, record the value of all yytext collected */ " " {;} " " {;} @@ -108,15 +108,15 @@ long string in files Henri.stp and 401.stp*/ #[0-9]+/= { CreateNewText(YYText(),YYLeng()); return(token::ENTITY); } #[0-9]+/[ ]*= { CreateNewText(YYText(),YYLeng()); return(token::ENTITY); } #[0-9]+ { CreateNewText(YYText(),YYLeng()); return(token::IDENT); } -[-+0-9][0-9]* { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Integer); return(token::QUID); } -[-+\.0-9][\.0-9]+ { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Float); return(token::QUID); } -[-+\.0-9][\.0-9]+E[-+0-9][0-9]* { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Float); return(token::QUID); } -["][0-9A-F]+["] { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Hexa); return(token::QUID); } -[.]*[A-Z0-9_]+[.] { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Enum); return(token::QUID); } +[-+0-9][0-9]* { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamInteger); return(token::QUID); } +[-+\.0-9][\.0-9]+ { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamReal); return(token::QUID); } +[-+\.0-9][\.0-9]+E[-+0-9][0-9]* { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamReal); return(token::QUID); } +["][0-9A-F]+["] { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamHexa); return(token::QUID); } +[.]*[A-Z0-9_]+[.] { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamEnum); return(token::QUID); } [(] { return ('('); } [)] { return (')'); } [,] { myDataModel->PrepareNewArg(); return (','); } -[$] { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Nondef); return(token::QUID); } +[$] { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamVoid); return(token::QUID); } [=] { return ('='); } [;] { return (';'); } @@ -134,7 +134,7 @@ long string in files Henri.stp and 401.stp*/ (?i:ENDSCOPE) { return(token::ENDSCOPE); } [a-zA-Z0-9_]+ { CreateNewText(YYText(),YYLeng()); return(token::TYPE); } ![a-zA-Z0-9_]+ { CreateNewText(YYText(),YYLeng()); return(token::TYPE); } -[^)] { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Misc); return(token::QUID); } +[^)] { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamMisc); return(token::QUID); } [^\n] {;} /* skip any characters (except newlines) */ diff --git a/src/StepFile/step.tab.cxx b/src/StepFile/step.tab.cxx index 965548fda8..473d65f559 100644 --- a/src/StepFile/step.tab.cxx +++ b/src/StepFile/step.tab.cxx @@ -1,4 +1,4 @@ -// A Bison parser, made by GNU Bison 3.7.1. +// A Bison parser, made by GNU Bison 3.7.4. // Skeleton implementation for Bison LALR(1) parsers in C++ @@ -50,21 +50,17 @@ // Unqualified %code blocks. - #undef yylex #define yylex scanner->lex #define StepData scanner->myDataModel -#define stepclearin yychar = -1 -#define steperrok yyerrflag = 0 - // disable MSVC warnings in bison code #ifdef _MSC_VER #pragma warning(disable:4065 4244 4131 4127 4702) #define YYMALLOC malloc #define YYFREE free #endif -void StepFile_Interrupt (char* nomfic); /* rln 13.09.00 port on HP*/ +void StepFile_Interrupt (Standard_CString theErrorMessage, const Standard_Boolean theIsFail); @@ -90,25 +86,6 @@ void StepFile_Interrupt (char* nomfic); /* rln 13.09.00 port on HP*/ # endif #endif -#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -# ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (N) \ - { \ - (Current).begin = YYRHSLOC (Rhs, 1).begin; \ - (Current).end = YYRHSLOC (Rhs, N).end; \ - } \ - else \ - { \ - (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ - } \ - while (false) -# endif // Enable debugging if requested. @@ -184,23 +161,20 @@ namespace step { parser::basic_symbol::basic_symbol (const basic_symbol& that) : Base (that) , value (that.value) - , location (that.location) {} /// Constructor for valueless symbols. template - parser::basic_symbol::basic_symbol (typename Base::kind_type t, YY_MOVE_REF (location_type) l) + parser::basic_symbol::basic_symbol (typename Base::kind_type t) : Base (t) , value () - , location (l) {} template - parser::basic_symbol::basic_symbol (typename Base::kind_type t, YY_RVREF (semantic_type) v, YY_RVREF (location_type) l) + parser::basic_symbol::basic_symbol (typename Base::kind_type t, YY_RVREF (semantic_type) v) : Base (t) , value (YY_MOVE (v)) - , location (YY_MOVE (l)) {} template @@ -223,7 +197,6 @@ namespace step { { super_type::move (s); value = YY_MOVE (s.value); - location = YY_MOVE (s.location); } // by_kind. @@ -312,7 +285,7 @@ namespace step { {} parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that) - : super_type (YY_MOVE (that.state), YY_MOVE (that.value), YY_MOVE (that.location)) + : super_type (YY_MOVE (that.state), YY_MOVE (that.value)) { #if 201103L <= YY_CPLUSPLUS // that is emptied. @@ -321,7 +294,7 @@ namespace step { } parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) - : super_type (s, YY_MOVE (that.value), YY_MOVE (that.location)) + : super_type (s, YY_MOVE (that.value)) { // that is emptied. that.kind_ = symbol_kind::S_YYEMPTY; @@ -333,7 +306,6 @@ namespace step { { state = that.state; value = that.value; - location = that.location; return *this; } @@ -342,7 +314,6 @@ namespace step { { state = that.state; value = that.value; - location = that.location; // that is emptied. that.state = empty_state; return *this; @@ -373,8 +344,7 @@ namespace step { { symbol_kind_type yykind = yysym.kind (); yyo << (yykind < YYNTOKENS ? "token" : "nterm") - << ' ' << yysym.name () << " (" - << yysym.location << ": "; + << ' ' << yysym.name () << " ("; YYUSE (yykind); yyo << ')'; } @@ -475,9 +445,6 @@ namespace step { /// The lookahead symbol. symbol_type yyla; - /// The locations where the error started and ended. - stack_symbol_type yyerror_range[3]; - /// The return value of parse (). int yyresult; @@ -526,7 +493,7 @@ namespace step { try #endif // YY_EXCEPTIONS { - yyla.kind_ = yytranslate_ (yylex (&yyla.value, &yyla.location)); + yyla.kind_ = yytranslate_ (yylex (&yyla.value)); } #if YY_EXCEPTIONS catch (const syntax_error& yyexc) @@ -605,12 +572,6 @@ namespace step { else yylhs.value = yystack_[0].value; - // Default location. - { - stack_type::slice range (yystack_, yylen); - YYLLOC_DEFAULT (yylhs.location, range, yylen); - yyerror_range[1].location = yylhs.location; - } // Perform the reduction. YY_REDUCE_PRINT (yyn); @@ -629,7 +590,7 @@ namespace step { break; case 17: // unarg: IDENT - { StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); } + { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); } break; case 18: // unarg: QUID @@ -667,7 +628,7 @@ namespace step { break; case 40: // unid: IDENT - { StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); } + { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); } break; case 43: // debexp: '/' @@ -723,12 +684,12 @@ namespace step { if (!yyerrstatus_) { ++yynerrs_; - std::string msg = YY_("syntax error"); - error (yyla.location, YY_MOVE (msg)); + context yyctx (*this, yyla); + std::string msg = yysyntax_error_ (yyctx); + error (YY_MOVE (msg)); } - yyerror_range[1].location = yyla.location; if (yyerrstatus_ == 3) { /* If just tried and failed to reuse lookahead token after an @@ -790,7 +751,6 @@ namespace step { if (yystack_.size () == 1) YYABORT; - yyerror_range[1].location = yystack_[0].location; yy_destroy_ ("Error: popping", yystack_[0]); yypop_ (); YY_STACK_PRINT (); @@ -798,8 +758,6 @@ namespace step { { stack_symbol_type error_token; - yyerror_range[2].location = yyla.location; - YYLLOC_DEFAULT (error_token.location, yyerror_range, 2); // Shift the error token. error_token.state = state_type (yyn); @@ -865,19 +823,178 @@ namespace step { void parser::error (const syntax_error& yyexc) { - error (yyexc.location, yyexc.what ()); + error (yyexc.what ()); } -#if YYDEBUG || 0 - const char * + /* Return YYSTR after stripping away unnecessary quotes and + backslashes, so that it's suitable for yyerror. The heuristic is + that double-quoting is unnecessary unless the string contains an + apostrophe, a comma, or backslash (other than backslash-backslash). + YYSTR is taken from yytname. */ + std::string + parser::yytnamerr_ (const char *yystr) + { + if (*yystr == '"') + { + std::string yyr; + char const *yyp = yystr; + + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + yyr += *yyp; + break; + + case '"': + return yyr; + } + do_not_strip_quotes: ; + } + + return yystr; + } + + std::string parser::symbol_name (symbol_kind_type yysymbol) { - return yytname_[yysymbol]; + return yytnamerr_ (yytname_[yysymbol]); } -#endif // #if YYDEBUG || 0 + // parser::context. + parser::context::context (const parser& yyparser, const symbol_type& yyla) + : yyparser_ (yyparser) + , yyla_ (yyla) + {} + + int + parser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; + + int yyn = yypact_[+yyparser_.yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + // Stay within bounds of both yycheck and yytname. + int yychecklim = yylast_ - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + for (int yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck_[yyx + yyn] == yyx && yyx != symbol_kind::S_YYerror + && !yy_table_value_is_error_ (yytable_[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx); + } + } + + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = symbol_kind::S_YYEMPTY; + return yycount; + } + + + + int + parser::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yyla) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yyla. (However, yyla is currently not documented for users.) + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; + } + return 0; + } + + // Generate an error message. + std::string + parser::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); + + char const* yyformat = YY_NULLPTR; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: // Avoid compiler warnings. + YYCASE_ (0, YY_("syntax error")); + YYCASE_ (1, YY_("syntax error, unexpected %s")); + YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + std::string yyres; + // Argument number. + std::ptrdiff_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += symbol_name (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres; + } const signed char parser::yypact_ninf_ = -24; @@ -991,7 +1108,7 @@ namespace step { }; -#if YYDEBUG +#if YYDEBUG || 1 // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. // First, the terminals, then, starting at \a YYNTOKENS, nonterminals. const char* @@ -1013,11 +1130,11 @@ namespace step { const unsigned char parser::yyrline_[] = { - 0, 103, 103, 104, 105, 106, 107, 108, 109, 110, - 110, 110, 113, 114, 116, 117, 119, 122, 123, 124, - 125, 126, 129, 132, 135, 140, 141, 143, 144, 146, - 147, 149, 150, 151, 152, 154, 155, 157, 158, 160, - 163, 166, 167, 169, 172, 174, 179, 182 + 0, 98, 98, 99, 100, 101, 102, 103, 104, 105, + 105, 105, 108, 109, 111, 112, 114, 117, 118, 119, + 120, 121, 124, 127, 130, 135, 136, 138, 139, 141, + 142, 144, 145, 146, 147, 149, 150, 152, 153, 155, + 158, 161, 162, 164, 167, 169, 174, 177 }; void @@ -1099,10 +1216,18 @@ namespace step { } // step - -void step::parser::error(const location_type& /*loc*/, const std::string& m) +void step::parser::error(const std::string& m) { - char newmess[80]; - sprintf(newmess, "At line %d : %s", scanner->lineno() + 1, m.c_str()); - StepFile_Interrupt(newmess); + char newmess[120]; + Standard_Boolean isSyntax = (Standard_Boolean)strncmp(m.c_str(), "syntax error", 13); + if (isSyntax && strlen(m.c_str()) > 13) + sprintf(newmess, "Undefined Parsing: Line %d: %s: %s", scanner->lineno() + 1, "Incorrect syntax", m.c_str() + 14); + else if (isSyntax) + sprintf(newmess, "Undefined Parsing: Line %d: Incorrect syntax", scanner->lineno() + 1); + else + sprintf(newmess, "Undefined Parsing: Line %d: %s", scanner->lineno() + 1, m.c_str()); + + StepFile_Interrupt(newmess, Standard_False); + + StepData->AddError(newmess); } diff --git a/src/StepFile/step.tab.hxx b/src/StepFile/step.tab.hxx index 7f25463b95..914aac07b0 100644 --- a/src/StepFile/step.tab.hxx +++ b/src/StepFile/step.tab.hxx @@ -1,4 +1,4 @@ -// A Bison parser, made by GNU Bison 3.7.1. +// A Bison parser, made by GNU Bison 3.7.4. // Skeleton interface for Bison LALR(1) parsers in C++ @@ -106,7 +106,7 @@ namespace step { #else # define YY_CONSTEXPR #endif -# include "location.hh" + #ifndef YY_ATTRIBUTE_PURE @@ -204,25 +204,19 @@ namespace step { #else typedef YYSTYPE semantic_type; #endif - /// Symbol locations. - typedef location location_type; /// Syntax errors thrown from user actions. struct syntax_error : std::runtime_error { - syntax_error (const location_type& l, const std::string& m) + syntax_error (const std::string& m) : std::runtime_error (m) - , location (l) {} syntax_error (const syntax_error& s) : std::runtime_error (s.what ()) - , location (s.location) {} ~syntax_error () YY_NOEXCEPT YY_NOTHROW; - - location_type location; }; /// Token kinds. @@ -337,7 +331,7 @@ namespace step { /// Expects its Base type to provide access to the symbol kind /// via kind (). /// - /// Provide access to semantic value and location. + /// Provide access to semantic value. template struct basic_symbol : Base { @@ -347,7 +341,6 @@ namespace step { /// Default constructor. basic_symbol () : value () - , location () {} #if 201103L <= YY_CPLUSPLUS @@ -355,20 +348,17 @@ namespace step { basic_symbol (basic_symbol&& that) : Base (std::move (that)) , value (std::move (that.value)) - , location (std::move (that.location)) {} #endif /// Copy constructor. basic_symbol (const basic_symbol& that); /// Constructor for valueless symbols. - basic_symbol (typename Base::kind_type t, - YY_MOVE_REF (location_type) l); + basic_symbol (typename Base::kind_type t); /// Constructor for symbols with semantic value. basic_symbol (typename Base::kind_type t, - YY_RVREF (semantic_type) v, - YY_RVREF (location_type) l); + YY_RVREF (semantic_type) v); /// Destroy the symbol. ~basic_symbol () @@ -382,14 +372,11 @@ namespace step { Base::clear (); } -#if YYDEBUG || 0 /// The user-facing name of this symbol. - const char *name () const YY_NOEXCEPT + std::string name () const YY_NOEXCEPT { return parser::symbol_name (this->kind ()); } -#endif // #if YYDEBUG || 0 - /// Backward compatibility (Bison 3.6). symbol_kind_type type_get () const YY_NOEXCEPT; @@ -403,9 +390,6 @@ namespace step { /// The semantic value. semantic_type value; - /// The location. - location_type location; - private: #if YY_CPLUSPLUS < 201103L /// Assignment operator. @@ -492,21 +476,33 @@ namespace step { #endif /// Report a syntax error. - /// \param loc where the syntax error is found. /// \param msg a description of the syntax error. - virtual void error (const location_type& loc, const std::string& msg); + virtual void error (const std::string& msg); /// Report a syntax error. void error (const syntax_error& err); -#if YYDEBUG || 0 /// The user-facing name of the symbol whose (internal) number is /// YYSYMBOL. No bounds checking. - static const char *symbol_name (symbol_kind_type yysymbol); -#endif // #if YYDEBUG || 0 + static std::string symbol_name (symbol_kind_type yysymbol); + class context + { + public: + context (const parser& yyparser, const symbol_type& yyla); + const symbol_type& lookahead () const { return yyla_; } + symbol_kind_type token () const { return yyla_.kind (); } + /// Put in YYARG at most YYARGN of the expected tokens, and return the + /// number of tokens stored in YYARG. If YYARG is null, return the + /// number of expected tokens (guaranteed to be less than YYNTOKENS). + int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; + + private: + const parser& yyparser_; + const symbol_type& yyla_; + }; private: #if YY_CPLUSPLUS < 201103L @@ -520,6 +516,13 @@ namespace step { /// Stored state numbers (used for stacks). typedef signed char state_type; + /// The arguments of the error message. + int yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const; + + /// Generate an error message. + /// \param yyctx the context in which the error occurred. + virtual std::string yysyntax_error_ (const context& yyctx) const; /// Compute post-reduction state. /// \param yystate the current state /// \param yysym the nonterminal to push on the stack @@ -541,10 +544,11 @@ namespace step { /// are valid, yet not members of the token_type enum. static symbol_kind_type yytranslate_ (int t); -#if YYDEBUG || 0 + /// Convert the symbol name \a n to a form suitable for a diagnostic. + static std::string yytnamerr_ (const char *yystr); + /// For a symbol, its name in clear. static const char* const yytname_[]; -#endif // #if YYDEBUG || 0 // Tables. @@ -847,8 +851,7 @@ namespace step { public: explicit scanner(StepFile_ReadData* theDataModel, std::istream* in = 0, std::ostream* out = 0); - int lex(step::parser::semantic_type* yylval, - step::parser::location_type* yylloc); + int lex(step::parser::semantic_type* yylval); StepFile_ReadData* myDataModel; }; diff --git a/src/StepFile/step.yacc b/src/StepFile/step.yacc index 5ec3f48aba..de2f1278d9 100644 --- a/src/StepFile/step.yacc +++ b/src/StepFile/step.yacc @@ -26,7 +26,7 @@ %parse-param {step::scanner* scanner} -%locations +%define parse.error verbose %token STEP HEADER ENDSEC DATA ENDSTEP SCOPE ENDSCOPE ENTITY TYPE INTEGER FLOAT IDENT TEXT NONDEF ENUM HEXA QUID %start stepf @@ -48,23 +48,19 @@ namespace step { #endif } - -%code { +%code { #undef yylex #define yylex scanner->lex #define StepData scanner->myDataModel -#define stepclearin yychar = -1 -#define steperrok yyerrflag = 0 - // disable MSVC warnings in bison code #ifdef _MSC_VER #pragma warning(disable:4065 4244 4131 4127 4702) #define YYMALLOC malloc #define YYFREE free #endif -void StepFile_Interrupt (char* nomfic); /* rln 13.09.00 port on HP*/ +void StepFile_Interrupt (Standard_CString theErrorMessage, const Standard_Boolean theIsFail); } %code provides { @@ -88,8 +84,7 @@ namespace step { public: explicit scanner(StepFile_ReadData* theDataModel, std::istream* in = 0, std::ostream* out = 0); - int lex(step::parser::semantic_type* yylval, - step::parser::location_type* yylloc); + int lex(step::parser::semantic_type* yylval); StepFile_ReadData* myDataModel; }; @@ -119,7 +114,7 @@ headent : enttype listarg ';' endhead : DATA { StepData->FinalOfHead(); } ; -unarg : IDENT { StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); } +unarg : IDENT { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); } | QUID { /* deja fait par lex*/ StepData->CreateNewArg(); } | listarg /* rec_newent lors du ')' */ { StepData->CreateNewArg(); } | listype listarg /* liste typee */ { StepData->CreateNewArg(); } @@ -161,7 +156,7 @@ debscop : SCOPE { StepData->AddNewScope(); } ; unid : IDENT - { StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); } + { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); } ; export : unid | export ',' unid @@ -183,10 +178,18 @@ enttype : TYPE { StepData->RecordType (); } ; %% - -void step::parser::error(const location_type& /*loc*/, const std::string& m) +void step::parser::error(const std::string& m) { - char newmess[80]; - sprintf(newmess, "At line %d : %s", scanner->lineno() + 1, m.c_str()); - StepFile_Interrupt(newmess); + char newmess[120]; + Standard_Boolean isSyntax = (Standard_Boolean)strncmp(m.c_str(), "syntax error", 13); + if (isSyntax && strlen(m.c_str()) > 13) + sprintf(newmess, "Undefined Parsing: Line %d: %s: %s", scanner->lineno() + 1, "Incorrect syntax", m.c_str() + 14); + else if (isSyntax) + sprintf(newmess, "Undefined Parsing: Line %d: Incorrect syntax", scanner->lineno() + 1); + else + sprintf(newmess, "Undefined Parsing: Line %d: %s", scanner->lineno() + 1, m.c_str()); + + StepFile_Interrupt(newmess, Standard_False); + + StepData->AddError(newmess); } diff --git a/src/StepSelect/StepSelect_WorkLibrary.cxx b/src/StepSelect/StepSelect_WorkLibrary.cxx index 18b9f106be..b1e136a103 100644 --- a/src/StepSelect/StepSelect_WorkLibrary.cxx +++ b/src/StepSelect/StepSelect_WorkLibrary.cxx @@ -72,7 +72,6 @@ Standard_Integer StepSelect_WorkLibrary::ReadFile if (stepro.IsNull()) return 1; Handle(StepData_StepModel) stepmodel = new StepData_StepModel; model = stepmodel; - StepFile_ReadTrace (0); status = StepFile_Read(name, 0, stepmodel, stepro); return status; } @@ -87,7 +86,6 @@ Standard_Integer StepSelect_WorkLibrary::ReadStream (const Standard_CString the if (stepro.IsNull()) return 1; Handle(StepData_StepModel) stepmodel = new StepData_StepModel; model = stepmodel; - StepFile_ReadTrace(0); status = StepFile_Read(theName, &theIStream, stepmodel, stepro); return status; } diff --git a/tests/de/step_1/R9 b/tests/de/step_1/R9 index 9238da1b7b..90b37945e7 100644 --- a/tests/de/step_1/R9 +++ b/tests/de/step_1/R9 @@ -4,7 +4,7 @@ set filename stepBF3.stp puts "TODO 29269 ALL: B_SPLINE_CURVE_WITH_KNOTS: Update of 3D-Parameters has failed" set ref_data { -DATA : Faulties = 0 ( 22 ) Warnings = 0 ( 0 ) Summary = 0 ( 22 ) +DATA : Faulties = 0 ( 23 ) Warnings = 0 ( 0 ) Summary = 0 ( 23 ) TPSTAT : Faulties = 0 ( 0 ) Warnings = 4 ( 88 ) Summary = 4 ( 88 ) CHECKSHAPE : Wires = 1 ( 1 ) Faces = 1 ( 1 ) Shells = 0 ( 0 ) Solids = 0 ( 0 ) NBSHAPES : Solid = 1 ( 1 ) Shell = 1 ( 1 ) Face = 153 ( 153 )