-/* 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
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"
-/* 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
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
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;
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
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));
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
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
"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
}
}
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());
Standard_Integer nbmess = ach->NbWarnings();
sout<<nbmess<<" Warnings on Reading Header Entity N0."<<i<<":";
if (!ent.IsNull()) sout << ent->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."<<i<<":";
+ sout << " Fails on Reading Header Entity N0." << i << ":";
if (!ent.IsNull()) sout << ent->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";
+ }
}
}
}
step.lex
step.yacc
FlexLexer.h
-location.hh
#include <stdio.h>
#include <iostream>
-#include <StepFile_ReadData.hxx>
+
#include <step.tab.hxx>
+#include <StepFile_Read.hxx>
+#include <StepFile_ReadData.hxx>
+#include <Interface_Check.hxx>
+#include <Interface_InterfaceError.hxx>
#include <Interface_ParamType.hxx>
#include <Interface_Protocol.hxx>
-#include <Interface_Check.hxx>
-#include <StepData_Protocol.hxx>
+#include <StepData_FileRecognizer.hxx>
+#include <StepData_Protocol.hxx>
+#include <StepData_StepModel.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepReaderTool.hxx>
-#include <StepFile_Read.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
-#include <Interface_InterfaceError.hxx>
-#include <Message_Messenger.hxx>
#include <Message.hxx>
+#include <Message_Messenger.hxx>
#include <OSD_OpenFile.hxx>
#include <OSD_Timer.hxx>
#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;
-// ## ## ## ## ## ## Corps de la Routine ## ## ## ## ## ##
-
-static Interface_ParamType LesTypes[10]; // passage types (recstep/Interface)
+ Message_Messenger::StreamBuffer sout = theIsFail ? Message::SendFail() : Message::SendTrace();
+ sout << "**** ERR StepFile : " << theErrorMessage << " ****" << std::endl;
+}
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;
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;
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.ClearRecorder(1);
-// on a undirec pret pour la suite
-#ifdef CHRONOMESURE
+ aFileDataModel.ErrorHandle(undirec->GlobalCheck());
+ Standard_Integer anFailsCount = undirec->GlobalCheck()->NbFails();
+ if (anFailsCount > 0)
{
- Message_Messenger::StreamBuffer sout = Message::SendInfo();
- sout << " ... Step File loaded ...\n";
- c.Show (sout);
- sout << " "<< undirec->NbRecords() << " records (entities,sub-lists,scopes), "<< nbpar << " parameters";
+ Message::SendInfo() << "**** ERR StepFile : Incorrect Syntax : Fails Count : "
+ << anFailsCount << " ****";
}
+
+ aFileDataModel.ClearRecorder(1);
+
+ sout << " ... Step File loaded ...\n";
+ sout << " " << undirec->NbRecords() << " records (entities,sub-lists,scopes), " << nbpar << " parameters";
+
+#ifdef CHRONOMESURE
+ 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)
-{
- Handle(StepData_FileRecognizer) nulreco;
- return StepFile_Read (theName,theIStream,stepmodel,protocol,nulreco,nulreco);
-}
-
-void StepFile_Interrupt (char* mess)
+ const Handle(StepData_StepModel)& theStepModel,
+ const Handle(StepData_Protocol)& theProtocol)
{
-#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);
}
// 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 <iostream>
-//# include <stepread.h> : sauf recfile_modeprint, declare ici
-# include <StepData_StepModel.hxx>
-# include <StepData_FileRecognizer.hxx>
-# include <StepData_Protocol.hxx>
+#include <iostream>
+
+class StepData_StepModel;
+class StepData_Protocol;
-Standard_EXPORT void StepFile_ReadTrace (const Standard_Integer mode);
-// Modal : 0 pas de trace, 1 trace LoadModel, 2 & 3 + trace interne lex-yac
+//! 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
#include <StepFile_ReadData.hxx>
+#include <Interface_Check.hxx>
+#include <TCollection_AsciiString.hxx>
+
// Constant litterales
namespace TextValue
{
public:
- Argument() :myNext(NULL), myValue(NULL), myType(ArgumentType_Sub) {}
+ Argument() :myNext(NULL), myValue(NULL), myType(Interface_ParamSub) {}
~Argument() {}
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 {
Record* myRecord; //!< Record interrupted by the scope (to resume)
};
-
class StepFile_ReadData::RecordsPage
{
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 :
: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);
{
myErrorArg = Standard_False; // Reset error argument mod
AddNewRecord(myCurRec);
- SetTypeArg(ArgumentType_Sub);
+ SetTypeArg(Interface_ParamSub);
mySubArg = myCurRec->myIdent;
myCurRec = myCurRec->myNext;
myLastRec->myNext = NULL;
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)
// If already exists - update text value
if (!myErrorArg)
{
- SetTypeArg(ArgumentType_Misc);
+ SetTypeArg(Interface_ParamMisc);
CreateNewArg();
myErrorArg = Standard_True;
return;
PrintRecord(myLastRec);
}
myCurRec = aRecord;
- myTypeArg = ArgumentType_Sub;
+ myTypeArg = Interface_ParamSub;
CreateNewArg();
}
{
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;
}
}
//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;
//=======================================================================
void StepFile_ReadData::GetFileNbR(Standard_Integer* theNbHead,
- Standard_Integer* theNbRec,
- Standard_Integer* theNbPage)
+ Standard_Integer* theNbRec,
+ Standard_Integer* theNbPage)
{
myCurRec = myFirstRec;
*theNbHead = myNbHead;
//=======================================================================
Standard_Boolean StepFile_ReadData::GetRecordDescription(char** theIdent,
- char** theType,
- int* theNbArg)
+ char** theType,
+ int* theNbArg)
{
if (myCurRec == NULL)
return Standard_False;
//purpose :
//=======================================================================
-void StepFile_ReadData::SetTypeArg(const ArgumentType theArgType)
+void StepFile_ReadData::SetTypeArg(const Interface_ParamType theArgType)
{
myTypeArg = theArgType;
}
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 :
#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 <Standard.hxx>
+#include <Standard_Handle.hxx>
#include <Standard_DefineAlloc.hxx>
+#include <Interface_ParamType.hxx>
+
//! 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
//! 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:
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:
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);
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
//! 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
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
#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;
(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
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
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
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
+++ /dev/null
-// 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 <http://www.gnu.org/licenses/>.
-
-// 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 <iostream>
-# include <string>
-
-# 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 <typename YYChar>
- std::basic_ostream<YYChar>&
- operator<< (std::basic_ostream<YYChar>& 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 <typename YYChar>
- std::basic_ostream<YYChar>&
- operator<< (std::basic_ostream<YYChar>& 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
#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;
<Text>[\n] { yymore(); yylineno ++; } /* newline in text string - increment line counter and keep collecting yytext */
<Text>['] { yymore(); } /* single ' inside text string - keep collecting yytext*/
<Text>[^\n']+ { yymore(); } /* a sequence of any characters except ' and \n - keep collecting yytext */
-<Text>[']/[" "\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 */
+<Text>[']/[" "\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 */
" " {;}
" " {;}
#[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 (';'); }
(?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); }
<End>[^\n] {;} /* skip any characters (except newlines) */
-// 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++
// 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);
# 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.
parser::basic_symbol<Base>::basic_symbol (const basic_symbol& that)
: Base (that)
, value (that.value)
- , location (that.location)
{}
/// Constructor for valueless symbols.
template <typename Base>
- parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_MOVE_REF (location_type) l)
+ parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t)
: Base (t)
, value ()
- , location (l)
{}
template <typename Base>
- parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (semantic_type) v, YY_RVREF (location_type) l)
+ parser::basic_symbol<Base>::basic_symbol (typename Base::kind_type t, YY_RVREF (semantic_type) v)
: Base (t)
, value (YY_MOVE (v))
- , location (YY_MOVE (l))
{}
template <typename Base>
{
super_type::move (s);
value = YY_MOVE (s.value);
- location = YY_MOVE (s.location);
}
// by_kind.
{}
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.
}
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;
{
state = that.state;
value = that.value;
- location = that.location;
return *this;
}
{
state = that.state;
value = that.value;
- location = that.location;
// that is emptied.
that.state = empty_state;
return *this;
{
symbol_kind_type yykind = yysym.kind ();
yyo << (yykind < YYNTOKENS ? "token" : "nterm")
- << ' ' << yysym.name () << " ("
- << yysym.location << ": ";
+ << ' ' << yysym.name () << " (";
YYUSE (yykind);
yyo << ')';
}
/// 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;
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)
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);
break;
case 17: // unarg: IDENT
- { StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); }
+ { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); }
break;
case 18: // unarg: QUID
break;
case 40: // unid: IDENT
- { StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); }
+ { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); }
break;
case 43: // debexp: '/'
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
if (yystack_.size () == 1)
YYABORT;
- yyerror_range[1].location = yystack_[0].location;
yy_destroy_ ("Error: popping", yystack_[0]);
yypop_ ();
YY_STACK_PRINT ();
{
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);
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]);
+ }
+
+
+
+ // 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;
}
-#endif // #if YYDEBUG || 0
+ 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;
};
-#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*
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
} // 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);
}
-// 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++
#else
# define YY_CONSTEXPR
#endif
-# include "location.hh"
+
#ifndef YY_ATTRIBUTE_PURE
#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.
/// 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 <typename Base>
struct basic_symbol : Base
{
/// Default constructor.
basic_symbol ()
: value ()
- , location ()
{}
#if 201103L <= YY_CPLUSPLUS
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 ()
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;
/// The semantic value.
semantic_type value;
- /// The location.
- location_type location;
-
private:
#if YY_CPLUSPLUS < 201103L
/// Assignment operator.
#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
/// 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
/// 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.
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;
};
%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
#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 {
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;
};
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(); }
{ StepData->AddNewScope(); }
;
unid : IDENT
- { StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); }
+ { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); }
;
export : unid
| export ',' unid
{ 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);
}
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;
}
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;
}
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 )
projects / occt.git / commitdiff