OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0031970: Data Exchange, STEP reader - parser syntax error messages are inaccessible

Browse Source 
- 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
This commit is contained in:
dpasukhi 2021-01-11 13:20:31 +03:00 committed by bugmaster
parent 1ac837b2c2
commit 0c38be8f8d
18 changed files with 499 additions and 624 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/ExprIntrp/ExprIntrp.tab.c
View File

@ -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 /* Bison implementation for Yacc-like parsers in C
@ -45,11 +45,11 @@
define necessary library symbols; they are noted "INFRINGES ON define necessary library symbols; they are noted "INFRINGES ON
USER NAME SPACE" below. */ USER NAME SPACE" below. */
/* Identify Bison output. */ /* Identify Bison output, and Bison version. */
#define YYBISON 1 #define YYBISON 30704
/* Bison version. */ /* Bison version string. */
#define YYBISON_VERSION "3.7.1" #define YYBISON_VERSION "3.7.4"
/* Skeleton name. */ /* Skeleton name. */
#define YYSKELETON_NAME "yacc.c" #define YYSKELETON_NAME "yacc.c"

2
src/ExprIntrp/ExprIntrp.tab.h
View File

@ -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 /* Bison interface for Yacc-like parsers in C

2
src/ExprIntrp/lex.ExprIntrp.c
View File

@ -1515,7 +1515,7 @@ static int yy_get_next_buffer (void)
yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
yy_is_jam = (yy_current_state == 54); 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 #ifndef YY_NO_UNPUT

32
src/StepData/StepData_StepReaderData.cxx
View File

@ -381,16 +381,15 @@ void StepData_StepReaderData::SetRecord(const Standard_Integer num,
errm.AssignCat(" / "); errm.AssignCat(" / ");
errm.AssignCat(thenametypes.FindKey(thetypes.Value(num))); errm.AssignCat(thenametypes.FindKey(thetypes.Value(num)));
errm.AssignCat(" ... "); errm.AssignCat(" ... ");
#ifdef OCCT_DEBUG
while (theidents(prev) <= 0) { while (theidents(prev) <= 0) {
prev--; if (prev <= 0) break; prev--; if (prev <= 0) break;
} }
Message_Messenger::StreamBuffer sout = Message::SendInfo();
sout << " *** Error on Record " << num << " (on " << NbRecords() Message_Messenger::StreamBuffer sout = Message::SendTrace();
<< " -> " << num * 100 / NbRecords() << " % in File) ***"; sout << " *** Incorrect record " << num << " (on " << NbRecords()
<< " -> " << num * 100 / NbRecords() << " % in File) ***";
if (prev > 0) sout << " Ident #" << theidents(prev); if (prev > 0) sout << " Ident #" << theidents(prev);
sout << "\n" << errm << std::endl; sout << "\n" << errm << std::endl;
#endif
thecheck->AddWarning(errm.ToCString(), "Complex Type incorrect : "); thecheck->AddWarning(errm.ToCString(), "Complex Type incorrect : ");
} }
break; break;
@ -1730,7 +1729,7 @@ Standard_Integer StepData_StepReaderData::FindEntityNumber(const Standard_Intege
void StepData_StepReaderData::SetEntityNumbers(const Standard_Boolean withmap) 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 // Passe initiale : Resolution directe par Map
// si tout passe (pas de collision), OK. Sinon, autres passes a prevoir // si tout passe (pas de collision), OK. Sinon, autres passes a prevoir
// On resoud du meme coup les sous-listes // On resoud du meme coup les sous-listes
@ -1775,7 +1774,8 @@ void StepData_StepReaderData::SetEntityNumbers(const Standard_Boolean withmap)
if (letype == Interface_ParamSub) { if (letype == Interface_ParamSub) {
Standard_Integer numsub = FP.EntityNumber(); Standard_Integer numsub = FP.EntityNumber();
if (numsub > thelastn) { 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; continue;
} }
FP.SetEntityNumber(subn(numsub)); FP.SetEntityNumber(subn(numsub));
@ -1798,9 +1798,9 @@ void StepData_StepReaderData::SetEntityNumbers(const Standard_Boolean withmap)
ident, na, id); ident, na, id);
thecheck->AddFail(failmess, "Unresolved Reference"); thecheck->AddFail(failmess, "Unresolved Reference");
// ... Et sortir message un peu plus complet // ... Et sortir message un peu plus complet
sout << "*** ERR StepReaderData *** Pour Entite #" << ident sout << "*** ERR StepReaderData *** Entite #" << ident
<< "\n Type:" << RecordType(num) << "\n Type:" << RecordType(num)
<< " Param.n0 " << na << ": #" << id << " Non trouve" << std::endl; << " Param.n0 " << na << ": #" << id << " Not found" << std::endl;
} // FIN Mapping } // FIN Mapping
} // FIN Traitement Reference } // FIN Traitement Reference
} // FIN Boucle Parametres } // FIN Boucle Parametres
@ -1867,7 +1867,7 @@ void StepData_StepReaderData::SetEntityNumbers(const Standard_Boolean withmap)
char ligne[80]; char ligne[80];
sprintf(ligne, "Ident defined SEVERAL TIMES : #%d", ident); sprintf(ligne, "Ident defined SEVERAL TIMES : #%d", ident);
thecheck->AddFail(ligne, "Ident defined SEVERAL TIMES : #%d"); 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 if (indm(indmap) > 0) indm(indmap) = -indm(indmap); // Pas pour Map
// Cas Normal pour la 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)", "Unresolved Reference, Ent.n0 %d (Id.#%d) Param.n0 %d (Id.#%d)",
nument, ident, na, id); nument, ident, na, id);
thecheck->AddFail(failmess, "Unresolved Reference"); thecheck->AddFail(failmess, "Unresolved Reference");
// ... Et sortir message un peu plus complet // ... Et sortir message un peu plus complet
sout << "*** ERR StepReaderData *** Pour Entite " << nument sout << "*** ERR StepReaderData *** Entite " << nument
<< ", a " << (nr * 100) / nbseq << "% de DATA : #" << ident << ", a " << (nr * 100) / nbseq << "% de DATA : #" << ident
<< "\n Type:" << RecordType(num) << "\n Type:" << RecordType(num)
<< " Param.n0 " << na << ": #" << id << " Non trouve" << std::endl; << " Param.n0 " << na << ": #" << id << " Not found" << std::endl;
FP.SetEntityNumber(0); // -> Reference non resolue FP.SetEntityNumber(0); // -> Reference non resolue
} }
} }

16
src/StepData/StepData_StepReaderTool.cxx
View File

@ -159,7 +159,7 @@ void StepData_StepReaderTool::PrepareHeader
void StepData_StepReaderTool::BeginRead void StepData_StepReaderTool::BeginRead
(const Handle(Interface_InterfaceModel)& amodel) (const Handle(Interface_InterfaceModel)& amodel)
{ {
Message_Messenger::StreamBuffer sout = Message::SendInfo(); Message_Messenger::StreamBuffer sout = Message::SendTrace();
DeclareAndCast(StepData_StepModel,model,amodel); DeclareAndCast(StepData_StepModel,model,amodel);
DeclareAndCast(StepData_StepReaderData,stepdat,Data()); DeclareAndCast(StepData_StepReaderData,stepdat,Data());
@ -185,16 +185,20 @@ void StepData_StepReaderTool::BeginRead
Standard_Integer nbmess = ach->NbWarnings(); Standard_Integer nbmess = ach->NbWarnings();
sout<<nbmess<<" Warnings on Reading Header Entity N0."<<i<<":"; sout<<nbmess<<" Warnings on Reading Header Entity N0."<<i<<":";
if (!ent.IsNull()) sout << ent->DynamicType()->Name() << std::endl; if (!ent.IsNull()) sout << ent->DynamicType()->Name() << std::endl;
for (Standard_Integer nf = 1; nf <= nbmess; nf ++) for (Standard_Integer nf = 1; nf <= nbmess; nf++)
sout << ach->CWarning(nf) << "\n"; {
sout << ach->CWarning(nf) << "\n";
}
} }
if (ach->HasFailed()) { if (ach->HasFailed()) {
Handle(Interface_Check) mch = model->GlobalCheck(); Handle(Interface_Check) mch = model->GlobalCheck();
Standard_Integer nbmess = ach->NbFails(); 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; if (!ent.IsNull()) sout << ent->DynamicType()->Name() << std::endl;
for (Standard_Integer nf = 1; nf <= nbmess; nf ++) for (Standard_Integer nf = 1; nf <= nbmess; nf++)
sout << ach->CFail(nf) << "\n"; {
sout << ach->CFail(nf) << "\n";
}
} }
} }
} }

1
src/StepFile/FILES
View File

@ -8,4 +8,3 @@ StepFile_Read.hxx
step.lex step.lex
step.yacc step.yacc
FlexLexer.h FlexLexer.h
location.hh

168
src/StepFile/StepFile_Read.cxx
View File

@ -27,24 +27,27 @@
#include <stdio.h> #include <stdio.h>
#include <iostream> #include <iostream>
#include <StepFile_ReadData.hxx>
#include <step.tab.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_ParamType.hxx>
#include <Interface_Protocol.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_StepReaderData.hxx>
#include <StepData_StepReaderTool.hxx> #include <StepData_StepReaderTool.hxx>
#include <StepFile_Read.hxx>
#include <Standard_ErrorHandler.hxx> #include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx> #include <Standard_Failure.hxx>
#include <Interface_InterfaceError.hxx>
#include <Message_Messenger.hxx>
#include <Message.hxx> #include <Message.hxx>
#include <Message_Messenger.hxx>
#include <OSD_OpenFile.hxx> #include <OSD_OpenFile.hxx>
#include <OSD_Timer.hxx> #include <OSD_Timer.hxx>
@ -53,31 +56,22 @@
#define CHRONOMESURE #define CHRONOMESURE
#endif #endif
// ## ## ## ## ON SAURA AU MOINS TRAITER UndefinedEntity ## ## ## ## void StepFile_Interrupt(Standard_CString theErrorMessage, const Standard_Boolean theIsFail)
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)
{ {
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, static Standard_Integer StepFile_Read (const char* theName,
std::istream* theIStream, std::istream* theIStream,
const Handle(StepData_StepModel)& stepmodel, const Handle(StepData_StepModel)& theStepModel,
const Handle(StepData_Protocol)& protocol, const Handle(StepData_Protocol)& theProtocol,
const Handle(StepData_FileRecognizer)& recoheader, const Handle(StepData_FileRecognizer)& theRecogHeader,
const Handle(StepData_FileRecognizer)& recodata) const Handle(StepData_FileRecognizer)& theRecogData)
{ {
StepFile_ReadData aFileDataModel;
aFileDataModel.SetModePrint(modepr > 0 ? modepr - 1 : 0);
// if stream is not provided, open file stream here // if stream is not provided, open file stream here
std::istream *aStreamPtr = theIStream; std::istream *aStreamPtr = theIStream;
std::ifstream aFileStream; std::ifstream aFileStream;
@ -95,8 +89,12 @@ static Standard_Integer StepFile_Read (const char* theName,
OSD_Timer c; OSD_Timer c;
c.Reset(); c.Reset();
c.Start(); c.Start();
Message::SendInfo() << " ... Step File Reading : '" << theName << "'";
#endif #endif
Message_Messenger::StreamBuffer sout = Message::SendTrace();
sout << " ... Step File Reading : '" << theName << "'";
StepFile_ReadData aFileDataModel;
try { try {
OCC_CATCH_SIGNALS OCC_CATCH_SIGNALS
int aLetat = 0; int aLetat = 0;
@ -105,123 +103,101 @@ static Standard_Integer StepFile_Read (const char* theName,
step::parser aParser(&aScanner); step::parser aParser(&aScanner);
aLetat = aParser.parse(); aLetat = aParser.parse();
if (aLetat != 0) { if (aLetat != 0) {
StepFile_Interrupt(aFileDataModel.GetLastError(), Standard_True);
return 1; return 1;
} }
} }
catch (Standard_Failure const& anException) { catch (Standard_Failure const& anException) {
#ifdef OCCT_DEBUG Message::SendFail() << " ... Exception Raised while reading Step File : '" << theName << "':\n"
Message::SendAlarm() << " ... Exception Raised while reading Step File : '" << theName << "':\n" << anException << " ...";
<< anException.GetMessageString()
<< " ...";
#endif
(void)anException;
return 1; 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 #ifdef CHRONOMESURE
{ c.Show(sout);
Message_Messenger::StreamBuffer sout = Message::SendInfo();
sout << " ... STEP File Read ...\n";
c.Show (sout);
}
#endif #endif
// Creation du StepReaderData sout << " ... STEP File Read ...\n";
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 ;
Standard_Integer nbhead, nbrec, nbpar; Standard_Integer nbhead, nbrec, nbpar;
aFileDataModel.GetFileNbR (&nbhead,&nbrec,&nbpar); // renvoi par lex/yacc aFileDataModel.GetFileNbR (&nbhead,&nbrec,&nbpar); // renvoi par lex/yacc
Handle(StepData_StepReaderData) undirec = 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 ++) { for ( Standard_Integer nr = 1; nr <= nbrec; nr ++) {
int nbarg; char* ident; char* typrec = 0; int nbarg; char* ident; char* typrec = 0;
aFileDataModel.GetRecordDescription(&ident, &typrec, &nbarg); aFileDataModel.GetRecordDescription(&ident, &typrec, &nbarg);
undirec->SetRecord (nr, ident, typrec, nbarg); undirec->SetRecord (nr, ident, typrec, nbarg);
if (nbarg>0) { if (nbarg>0) {
ArgumentType typa; char* val; Interface_ParamType typa; char* val;
Interface_ParamType newtype;
while(aFileDataModel.GetArgDescription (&typa, &val) == 1) { while(aFileDataModel.GetArgDescription (&typa, &val) == 1) {
newtype = LesTypes[typa] ; undirec->AddStepParam (nr, val, typa);
undirec->AddStepParam (nr, val, newtype);
} }
} }
undirec->InitParams(nr); undirec->InitParams(nr);
aFileDataModel.NextRecord(); 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); 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 #ifdef CHRONOMESURE
{ c.Show(sout);
Message_Messenger::StreamBuffer sout = Message::SendInfo();
sout << " ... Step File loaded ...\n";
c.Show (sout);
sout << " "<< undirec->NbRecords() << " records (entities,sub-lists,scopes), "<< nbpar << " parameters";
}
#endif #endif
// Analyse : par StepReaderTool // Analyse : par StepReaderTool
StepData_StepReaderTool readtool (undirec,protocol); StepData_StepReaderTool readtool (undirec, theProtocol);
readtool.SetErrorHandle (Standard_True); readtool.SetErrorHandle (Standard_True);
readtool.PrepareHeader(recoheader); // Header. reco nul -> pour Protocol readtool.PrepareHeader(theRecogHeader); // Header. reco nul -> pour Protocol
readtool.Prepare(recodata); // Data. reco nul -> pour Protocol readtool.Prepare(theRecogData); // Data. reco nul -> pour Protocol
sout << " ... Parameters prepared ...\n";
#ifdef CHRONOMESURE #ifdef CHRONOMESURE
{ c.Show(sout)
Message_Messenger::StreamBuffer sout = Message::SendInfo();
sout << " ... Parameters prepared ...\n";
c.Show (sout);
}
#endif #endif
readtool.LoadModel(stepmodel); readtool.LoadModel(theStepModel);
if (stepmodel->Protocol().IsNull()) stepmodel->SetProtocol (protocol); if (theStepModel->Protocol().IsNull()) theStepModel->SetProtocol (theProtocol);
aFileDataModel.ClearRecorder(2); aFileDataModel.ClearRecorder(2);
anFailsCount = undirec->GlobalCheck()->NbFails() - anFailsCount;
if (anFailsCount > 0)
{
Message::SendInfo() << "*** ERR StepReaderData : Unresolved Reference : Fails Count : "
<< anFailsCount << " ***";
}
readtool.Clear(); readtool.Clear();
undirec.Nullify(); undirec.Nullify();
sout << " ... Objects analysed ...\n";
Standard_Integer n = theStepModel->NbEntities();
sout << " STEP Loading done : " << n << " Entities";
#ifdef CHRONOMESURE #ifdef CHRONOMESURE
{ c.Show(sout);
Message_Messenger::StreamBuffer sout = Message::SendInfo();
sout << " ... Objets analysed ...\n";
c.Show (sout);
Standard_Integer n = stepmodel->NbEntities();
sout << " STEP Loading done : " << n << " Entities";
}
#endif #endif
return 0; return 0;
} }
Standard_Integer StepFile_Read(const char* theName, Standard_Integer StepFile_Read(const char* theName,
std::istream* theIStream, std::istream* theIStream,
const Handle(StepData_StepModel)& stepmodel, const Handle(StepData_StepModel)& theStepModel,
const Handle(StepData_Protocol)& protocol) const Handle(StepData_Protocol)& theProtocol)
{ {
Handle(StepData_FileRecognizer) nulreco; Handle(StepData_FileRecognizer) aNulRecog;
return StepFile_Read (theName,theIStream,stepmodel,protocol,nulreco,nulreco); return StepFile_Read(theName, theIStream, theStepModel, theProtocol, aNulRecog, aNulRecog);
}
void StepFile_Interrupt (char* mess)
{
#ifdef OCCT_DEBUG
Message_Messenger::StreamBuffer sout = Message::SendInfo();
sout << " **** StepFile Error : " << mess << " ****" << std::endl;
#endif
checkread->AddFail(mess);
} }

26
src/StepFile/StepFile_Read.hxx
View File

@ -14,27 +14,19 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // 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 #ifndef StepFile_Read_HeaderFile
#define StepFile_Read_HeaderFile #define StepFile_Read_HeaderFile
#include <iostream> #include <iostream>
//# include <stepread.h> : sauf recfile_modeprint, declare ici
# include <StepData_StepModel.hxx>
# include <StepData_FileRecognizer.hxx>
# include <StepData_Protocol.hxx>
Standard_EXPORT void StepFile_ReadTrace (const Standard_Integer mode); class StepData_StepModel;
// Modal : 0 pas de trace, 1 trace LoadModel, 2 & 3 + trace interne lex-yac 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. //! Working function reading STEP file or stream.
//! @param theName - name of the file or stream //! @param theName - name of the file or stream

118
src/StepFile/StepFile_ReadData.cxx
View File

@ -15,6 +15,9 @@
#include <StepFile_ReadData.hxx> #include <StepFile_ReadData.hxx>
#include <Interface_Check.hxx>
#include <TCollection_AsciiString.hxx>
// Constant litterales // Constant litterales
namespace TextValue namespace TextValue
{ {
@ -61,7 +64,7 @@ public:
public: public:
Argument() :myNext(NULL), myValue(NULL), myType(ArgumentType_Sub) {} Argument() :myNext(NULL), myValue(NULL), myType(Interface_ParamSub) {}
~Argument() {} ~Argument() {}
@ -69,7 +72,7 @@ public:
Argument* myNext; //!< Next argument in the list for this record Argument* myNext; //!< Next argument in the list for this record
char* myValue; //!< Character value of the argument char* myValue; //!< Character value of the argument
ArgumentType myType; //!< Type of the argument Interface_ParamType myType; //!< Type of the argument
}; };
class StepFile_ReadData::ArgumentsPage { class StepFile_ReadData::ArgumentsPage {
@ -143,7 +146,6 @@ public:
Record* myRecord; //!< Record interrupted by the scope (to resume) Record* myRecord; //!< Record interrupted by the scope (to resume)
}; };
class StepFile_ReadData::RecordsPage class StepFile_ReadData::RecordsPage
{ {
@ -170,6 +172,29 @@ public:
int myUsed; //!< Counter employed records 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 //function : StepFile_ReadData
//purpose : //purpose :
@ -179,8 +204,8 @@ StepFile_ReadData::StepFile_ReadData()
:myMaxChar(50000), myMaxRec(5000), myMaxArg(10000), myModePrint(0), :myMaxChar(50000), myMaxRec(5000), myMaxArg(10000), myModePrint(0),
myNbRec(0), myNbHead(0), myNbPar(0), myYaRec(0), myNbRec(0), myNbHead(0), myNbPar(0), myYaRec(0),
myNumSub(0), myErrorArg(Standard_False), myResText(NULL), myCurrType(TextValue::SubList), myNumSub(0), myErrorArg(Standard_False), myResText(NULL), myCurrType(TextValue::SubList),
mySubArg(NULL), myTypeArg(ArgumentType_Sub), myCurrArg(NULL), myFirstRec(NULL), mySubArg(NULL), myTypeArg(Interface_ParamSub), myCurrArg(NULL), myFirstRec(NULL),
myCurRec(NULL), myLastRec(NULL), myCurScope(NULL) myCurRec(NULL), myLastRec(NULL), myCurScope(NULL), myFirstError(NULL), myCurError(NULL)
{ {
myOneCharPage = new CharactersPage(myMaxChar); myOneCharPage = new CharactersPage(myMaxChar);
myOneArgPage = new ArgumentsPage(myMaxArg); myOneArgPage = new ArgumentsPage(myMaxArg);
@ -238,7 +263,7 @@ void StepFile_ReadData::RecordNewEntity()
{ {
myErrorArg = Standard_False; // Reset error argument mod myErrorArg = Standard_False; // Reset error argument mod
AddNewRecord(myCurRec); AddNewRecord(myCurRec);
SetTypeArg(ArgumentType_Sub); SetTypeArg(Interface_ParamSub);
mySubArg = myCurRec->myIdent; mySubArg = myCurRec->myIdent;
myCurRec = myCurRec->myNext; myCurRec = myCurRec->myNext;
myLastRec->myNext = NULL; myLastRec->myNext = NULL;
@ -331,12 +356,12 @@ void StepFile_ReadData::CreateNewArg()
aNewArg = &myOneArgPage->myArgs[myOneArgPage->myUsed]; aNewArg = &myOneArgPage->myArgs[myOneArgPage->myUsed];
myOneArgPage->myUsed++; myOneArgPage->myUsed++;
aNewArg->myType = myTypeArg; aNewArg->myType = myTypeArg;
if (myTypeArg == ArgumentType_Sub) if (myTypeArg == Interface_ParamSub)
aNewArg->myValue = mySubArg; aNewArg->myValue = mySubArg;
else else
GetResultText(&aNewArg->myValue); GetResultText(&aNewArg->myValue);
if (myTypeArg == ArgumentType_Misc) if (myTypeArg == Interface_ParamMisc)
myErrorArg = Standard_True; myErrorArg = Standard_True;
if (myCurRec->myFirst == NULL) if (myCurRec->myFirst == NULL)
@ -364,7 +389,7 @@ void StepFile_ReadData::CreateErrorArg()
// If already exists - update text value // If already exists - update text value
if (!myErrorArg) if (!myErrorArg)
{ {
SetTypeArg(ArgumentType_Misc); SetTypeArg(Interface_ParamMisc);
CreateNewArg(); CreateNewArg();
myErrorArg = Standard_True; myErrorArg = Standard_True;
return; return;
@ -421,7 +446,7 @@ void StepFile_ReadData::FinalOfScope()
PrintRecord(myLastRec); PrintRecord(myLastRec);
} }
myCurRec = aRecord; myCurRec = aRecord;
myTypeArg = ArgumentType_Sub; myTypeArg = Interface_ParamSub;
CreateNewArg(); CreateNewArg();
} }
@ -445,26 +470,28 @@ void StepFile_ReadData::ClearRecorder(const Standard_Integer theMode)
{ {
while (myOneRecPage != NULL) while (myOneRecPage != NULL)
{ {
RecordsPage* aNewPage; RecordsPage* aNewPage = myOneRecPage->myNext;
aNewPage = myOneRecPage->myNext;
delete myOneRecPage; delete myOneRecPage;
myOneRecPage = NULL;
myOneRecPage = aNewPage; myOneRecPage = aNewPage;
} }
while (myOneArgPage != NULL) { while (myOneArgPage != NULL) {
ArgumentsPage* aNewPage; aNewPage = myOneArgPage->myNext; ArgumentsPage* aNewPage = myOneArgPage->myNext;
delete myOneArgPage; delete myOneArgPage;
myOneArgPage = NULL;
myOneArgPage = aNewPage; myOneArgPage = aNewPage;
} }
while (myFirstError != NULL)
{
ErrorsPage* aNewErrorPage = myFirstError->NextErrorPage();
delete myFirstError;
myFirstError = aNewErrorPage;
}
} }
if (theMode & 2) if (theMode & 2)
{ {
while (myOneCharPage != NULL) while (myOneCharPage != NULL)
{ {
CharactersPage* aNewPage; aNewPage = myOneCharPage->myNext; CharactersPage* aNewPage = myOneCharPage->myNext;
delete myOneCharPage; delete myOneCharPage;
myOneCharPage = NULL;
myOneCharPage = aNewPage; myOneCharPage = aNewPage;
} }
} }
@ -475,7 +502,7 @@ void StepFile_ReadData::ClearRecorder(const Standard_Integer theMode)
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean StepFile_ReadData::GetArgDescription(ArgumentType* theType, char** theValue) Standard_Boolean StepFile_ReadData::GetArgDescription(Interface_ParamType* theType, char** theValue)
{ {
if (myCurrArg == NULL) if (myCurrArg == NULL)
return Standard_False; return Standard_False;
@ -491,8 +518,8 @@ Standard_Boolean StepFile_ReadData::GetArgDescription(ArgumentType* theType, cha
//======================================================================= //=======================================================================
void StepFile_ReadData::GetFileNbR(Standard_Integer* theNbHead, void StepFile_ReadData::GetFileNbR(Standard_Integer* theNbHead,
Standard_Integer* theNbRec, Standard_Integer* theNbRec,
Standard_Integer* theNbPage) Standard_Integer* theNbPage)
{ {
myCurRec = myFirstRec; myCurRec = myFirstRec;
*theNbHead = myNbHead; *theNbHead = myNbHead;
@ -506,8 +533,8 @@ void StepFile_ReadData::GetFileNbR(Standard_Integer* theNbHead,
//======================================================================= //=======================================================================
Standard_Boolean StepFile_ReadData::GetRecordDescription(char** theIdent, Standard_Boolean StepFile_ReadData::GetRecordDescription(char** theIdent,
char** theType, char** theType,
int* theNbArg) int* theNbArg)
{ {
if (myCurRec == NULL) if (myCurRec == NULL)
return Standard_False; return Standard_False;
@ -573,7 +600,7 @@ void StepFile_ReadData::FinalOfHead()
//purpose : //purpose :
//======================================================================= //=======================================================================
void StepFile_ReadData::SetTypeArg(const ArgumentType theArgType) void StepFile_ReadData::SetTypeArg(const Interface_ParamType theArgType)
{ {
myTypeArg = theArgType; myTypeArg = theArgType;
} }
@ -608,6 +635,51 @@ Standard_Integer StepFile_ReadData::GetNbRecord() const
return myNbRec; 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 //function : RecordNewText
//purpose : //purpose :

37
src/StepFile/StepFile_ReadData.hxx
View File

@ -16,23 +16,12 @@
#ifndef _StepFile_ReadData_HeaderFile #ifndef _StepFile_ReadData_HeaderFile
#define _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.hxx>
#include <Standard_Handle.hxx>
#include <Standard_DefineAlloc.hxx> #include <Standard_DefineAlloc.hxx>
#include <Interface_ParamType.hxx>
//! Provides data structures and tools to collect and store the data //! Provides data structures and tools to collect and store the data
//! read from the STEP file. //! read from the STEP file.
//! This class is designed to work in collaboration with STEP parser //! 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 //! threads) provided that each file is read using its own instances of Flex, Bison
//! and StepFile_ReadData tools. //! and StepFile_ReadData tools.
class Interface_Check;
class StepFile_ReadData class StepFile_ReadData
{ {
public: public:
@ -128,6 +119,7 @@ private:
class ArgumentsPage; //!< List of arguments pages, contains all text derived from Flex 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 Scope; //!< List of scopes pages, contains all records for external processing
class RecordsPage; //!< List of records pages, contains all records class RecordsPage; //!< List of records pages, contains all records
class ErrorsPage; //!< List of errors messages, containts all errors
public: public:
@ -178,7 +170,7 @@ public:
void ClearRecorder(const Standard_Integer theMode); void ClearRecorder(const Standard_Integer theMode);
//! Returns a value of fields of current argument //! 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 //! Returns a value of all file counters
void GetFileNbR(Standard_Integer* theNbHead, Standard_Integer* theNbRec, Standard_Integer* theNbPage); void GetFileNbR(Standard_Integer* theNbHead, Standard_Integer* theNbRec, Standard_Integer* theNbPage);
@ -203,7 +195,7 @@ public:
void FinalOfHead(); void FinalOfHead();
//! Sets type of the current argument //! Sets type of the current argument
void SetTypeArg(const ArgumentType theArgType); void SetTypeArg(const Interface_ParamType theArgType);
//! Initializes the print mode //! Initializes the print mode
//! 0 - don't print descriptions //! 0 - don't print descriptions
@ -217,6 +209,15 @@ public:
//! Returns number of records //! Returns number of records
Standard_Integer GetNbRecord() const; 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: private:
//! Prepare text to analyze //! Prepare text to analyze
@ -250,12 +251,14 @@ private:
char* myResText; //!< Text value written by Flex and passed to Bison to create record char* myResText; //!< Text value written by Flex and passed to Bison to create record
char* myCurrType; //!< Type of last record read char* myCurrType; //!< Type of last record read
char* mySubArg; //!< Ident last record (possible sub-list) 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 Argument* myCurrArg; //!< Current node of the argumets list
Record* myFirstRec; //!< First node of the records list Record* myFirstRec; //!< First node of the records list
Record* myCurRec; //!< Current node of the records list Record* myCurRec; //!< Current node of the records list
Record* myLastRec; //!< Last node of the records list Record* myLastRec; //!< Last node of the records list
Scope* myCurScope; //!< Current node of the scopes 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 RecordsPage* myOneRecPage; //!< Current node of the records pages list
CharactersPage* myOneCharPage; //!< Current node of the characters pages list CharactersPage* myOneCharPage; //!< Current node of the characters pages list
ArgumentsPage* myOneArgPage; //!< Current node of the arguments pages list ArgumentsPage* myOneArgPage; //!< Current node of the arguments pages list

18
src/StepFile/lex.step.cxx
View File

@ -653,7 +653,7 @@ goto find_rule; \
#ifdef YY_DECL #ifdef YY_DECL
# undef YY_DECL # undef YY_DECL
#endif #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; 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_c_buf_p) = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP 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 YY_BREAK
case 10: case 10:
YY_RULE_SETUP YY_RULE_SETUP
@ -999,23 +999,23 @@ YY_RULE_SETUP
YY_BREAK YY_BREAK
case 18: case 18:
YY_RULE_SETUP YY_RULE_SETUP
{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Integer); return(token::QUID); } { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamInteger); return(token::QUID); }
YY_BREAK YY_BREAK
case 19: case 19:
YY_RULE_SETUP YY_RULE_SETUP
{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Float); return(token::QUID); } { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamReal); return(token::QUID); }
YY_BREAK YY_BREAK
case 20: case 20:
YY_RULE_SETUP YY_RULE_SETUP
{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Float); return(token::QUID); } { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamReal); return(token::QUID); }
YY_BREAK YY_BREAK
case 21: case 21:
YY_RULE_SETUP YY_RULE_SETUP
{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Hexa); return(token::QUID); } { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamHexa); return(token::QUID); }
YY_BREAK YY_BREAK
case 22: case 22:
YY_RULE_SETUP YY_RULE_SETUP
{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Enum); return(token::QUID); } { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamEnum); return(token::QUID); }
YY_BREAK YY_BREAK
case 23: case 23:
YY_RULE_SETUP YY_RULE_SETUP
@ -1031,7 +1031,7 @@ YY_RULE_SETUP
YY_BREAK YY_BREAK
case 26: case 26:
YY_RULE_SETUP YY_RULE_SETUP
{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Nondef); return(token::QUID); } { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamVoid); return(token::QUID); }
YY_BREAK YY_BREAK
case 27: case 27:
YY_RULE_SETUP YY_RULE_SETUP
@ -1096,7 +1096,7 @@ YY_RULE_SETUP
case 42: case 42:
/* rule 42 can match eol */ /* rule 42 can match eol */
YY_RULE_SETUP YY_RULE_SETUP
{ CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Misc); return(token::QUID); } { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamMisc); return(token::QUID); }
YY_BREAK YY_BREAK
case 43: case 43:
YY_RULE_SETUP YY_RULE_SETUP

302
src/StepFile/location.hh
View File

@ -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 <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

18
src/StepFile/step.lex
View File

@ -44,7 +44,7 @@
#ifdef YY_DECL #ifdef YY_DECL
# undef YY_DECL # undef YY_DECL
#endif #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; typedef step::parser::token token;
@ -97,7 +97,7 @@ long string in files Henri.stp and 401.stp*/
<Text>[\n] { yymore(); yylineno ++; } /* newline in text string - increment line counter and keep collecting yytext */ <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>['] { yymore(); } /* single ' inside text string - keep collecting yytext*/
<Text>[^\n']+ { yymore(); } /* a sequence of any characters except ' and \n - 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 */
" " {;} " " {;}
" " {;} " " {;}
@ -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::ENTITY); } #[0-9]+/[ ]*= { CreateNewText(YYText(),YYLeng()); return(token::ENTITY); }
#[0-9]+ { CreateNewText(YYText(),YYLeng()); return(token::IDENT); } #[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(Interface_ParamInteger); return(token::QUID); }
[-+\.0-9][\.0-9]+ { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Float); 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(ArgumentType_Float); 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(ArgumentType_Hexa); return(token::QUID); } ["][0-9A-F]+["] { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamHexa); return(token::QUID); }
[.]*[A-Z0-9_]+[.] { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Enum); return(token::QUID); } [.]*[A-Z0-9_]+[.] { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamEnum); return(token::QUID); }
[(] { return ('('); } [(] { return ('('); }
[)] { return (')'); } [)] { return (')'); }
[,] { myDataModel->PrepareNewArg(); return (','); } [,] { myDataModel->PrepareNewArg(); return (','); }
[$] { CreateNewText(YYText(),YYLeng()); SetTypeArg(ArgumentType_Nondef); return(token::QUID); } [$] { CreateNewText(YYText(),YYLeng()); SetTypeArg(Interface_ParamVoid); return(token::QUID); }
[=] { return ('='); } [=] { return ('='); }
[;] { return (';'); } [;] { return (';'); }
@ -134,7 +134,7 @@ long string in files Henri.stp and 401.stp*/
(?i:ENDSCOPE) { return(token::ENDSCOPE); } (?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); }
![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) */ <End>[^\n] {;} /* skip any characters (except newlines) */

267
src/StepFile/step.tab.cxx
View File

@ -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++ // Skeleton implementation for Bison LALR(1) parsers in C++
@ -50,21 +50,17 @@
// Unqualified %code blocks. // Unqualified %code blocks.
#undef yylex #undef yylex
#define yylex scanner->lex #define yylex scanner->lex
#define StepData scanner->myDataModel #define StepData scanner->myDataModel
#define stepclearin yychar = -1
#define steperrok yyerrflag = 0
// disable MSVC warnings in bison code // disable MSVC warnings in bison code
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(disable:4065 4244 4131 4127 4702) #pragma warning(disable:4065 4244 4131 4127 4702)
#define YYMALLOC malloc #define YYMALLOC malloc
#define YYFREE free #define YYFREE free
#endif #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
#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. // Enable debugging if requested.
@ -184,23 +161,20 @@ namespace step {
parser::basic_symbol<Base>::basic_symbol (const basic_symbol& that) parser::basic_symbol<Base>::basic_symbol (const basic_symbol& that)
: Base (that) : Base (that)
, value (that.value) , value (that.value)
, location (that.location)
{} {}
/// Constructor for valueless symbols. /// Constructor for valueless symbols.
template <typename Base> 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) : Base (t)
, value () , value ()
, location (l)
{} {}
template <typename Base> 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) : Base (t)
, value (YY_MOVE (v)) , value (YY_MOVE (v))
, location (YY_MOVE (l))
{} {}
template <typename Base> template <typename Base>
@ -223,7 +197,6 @@ namespace step {
{ {
super_type::move (s); super_type::move (s);
value = YY_MOVE (s.value); value = YY_MOVE (s.value);
location = YY_MOVE (s.location);
} }
// by_kind. // by_kind.
@ -312,7 +285,7 @@ namespace step {
{} {}
parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that) 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 #if 201103L <= YY_CPLUSPLUS
// that is emptied. // 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) 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 is emptied.
that.kind_ = symbol_kind::S_YYEMPTY; that.kind_ = symbol_kind::S_YYEMPTY;
@ -333,7 +306,6 @@ namespace step {
{ {
state = that.state; state = that.state;
value = that.value; value = that.value;
location = that.location;
return *this; return *this;
} }
@ -342,7 +314,6 @@ namespace step {
{ {
state = that.state; state = that.state;
value = that.value; value = that.value;
location = that.location;
// that is emptied. // that is emptied.
that.state = empty_state; that.state = empty_state;
return *this; return *this;
@ -373,8 +344,7 @@ namespace step {
{ {
symbol_kind_type yykind = yysym.kind (); symbol_kind_type yykind = yysym.kind ();
yyo << (yykind < YYNTOKENS ? "token" : "nterm") yyo << (yykind < YYNTOKENS ? "token" : "nterm")
<< ' ' << yysym.name () << " (" << ' ' << yysym.name () << " (";
<< yysym.location << ": ";
YYUSE (yykind); YYUSE (yykind);
yyo << ')'; yyo << ')';
} }
@ -475,9 +445,6 @@ namespace step {
/// The lookahead symbol. /// The lookahead symbol.
symbol_type yyla; symbol_type yyla;
/// The locations where the error started and ended.
stack_symbol_type yyerror_range[3];
/// The return value of parse (). /// The return value of parse ().
int yyresult; int yyresult;
@ -526,7 +493,7 @@ namespace step {
try try
#endif // YY_EXCEPTIONS #endif // YY_EXCEPTIONS
{ {
yyla.kind_ = yytranslate_ (yylex (&yyla.value, &yyla.location)); yyla.kind_ = yytranslate_ (yylex (&yyla.value));
} }
#if YY_EXCEPTIONS #if YY_EXCEPTIONS
catch (const syntax_error& yyexc) catch (const syntax_error& yyexc)
@ -605,12 +572,6 @@ namespace step {
else else
yylhs.value = yystack_[0].value; 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. // Perform the reduction.
YY_REDUCE_PRINT (yyn); YY_REDUCE_PRINT (yyn);
@ -629,7 +590,7 @@ namespace step {
break; break;
case 17: // unarg: IDENT case 17: // unarg: IDENT
{ StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); } { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); }
break; break;
case 18: // unarg: QUID case 18: // unarg: QUID
@ -667,7 +628,7 @@ namespace step {
break; break;
case 40: // unid: IDENT case 40: // unid: IDENT
{ StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); } { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); }
break; break;
case 43: // debexp: '/' case 43: // debexp: '/'
@ -723,12 +684,12 @@ namespace step {
if (!yyerrstatus_) if (!yyerrstatus_)
{ {
++yynerrs_; ++yynerrs_;
std::string msg = YY_("syntax error"); context yyctx (*this, yyla);
error (yyla.location, YY_MOVE (msg)); std::string msg = yysyntax_error_ (yyctx);
error (YY_MOVE (msg));
} }
yyerror_range[1].location = yyla.location;
if (yyerrstatus_ == 3) if (yyerrstatus_ == 3)
{ {
/* If just tried and failed to reuse lookahead token after an /* If just tried and failed to reuse lookahead token after an
@ -790,7 +751,6 @@ namespace step {
if (yystack_.size () == 1) if (yystack_.size () == 1)
YYABORT; YYABORT;
yyerror_range[1].location = yystack_[0].location;
yy_destroy_ ("Error: popping", yystack_[0]); yy_destroy_ ("Error: popping", yystack_[0]);
yypop_ (); yypop_ ();
YY_STACK_PRINT (); YY_STACK_PRINT ();
@ -798,8 +758,6 @@ namespace step {
{ {
stack_symbol_type error_token; stack_symbol_type error_token;
yyerror_range[2].location = yyla.location;
YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);
// Shift the error token. // Shift the error token.
error_token.state = state_type (yyn); error_token.state = state_type (yyn);
@ -865,19 +823,178 @@ namespace step {
void void
parser::error (const syntax_error& yyexc) parser::error (const syntax_error& yyexc)
{ {
error (yyexc.location, yyexc.what ()); error (yyexc.what ());
} }
#if YYDEBUG || 0 /* Return YYSTR after stripping away unnecessary quotes and
const char * 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) 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; 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. // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
// First, the terminals, then, starting at \a YYNTOKENS, nonterminals. // First, the terminals, then, starting at \a YYNTOKENS, nonterminals.
const char* const char*
@ -1013,11 +1130,11 @@ namespace step {
const unsigned char const unsigned char
parser::yyrline_[] = parser::yyrline_[] =
{ {
0, 103, 103, 104, 105, 106, 107, 108, 109, 110, 0, 98, 98, 99, 100, 101, 102, 103, 104, 105,
110, 110, 113, 114, 116, 117, 119, 122, 123, 124, 105, 105, 108, 109, 111, 112, 114, 117, 118, 119,
125, 126, 129, 132, 135, 140, 141, 143, 144, 146, 120, 121, 124, 127, 130, 135, 136, 138, 139, 141,
147, 149, 150, 151, 152, 154, 155, 157, 158, 160, 142, 144, 145, 146, 147, 149, 150, 152, 153, 155,
163, 166, 167, 169, 172, 174, 179, 182 158, 161, 162, 164, 167, 169, 174, 177
}; };
void void
@ -1099,10 +1216,18 @@ namespace step {
} // step } // step
void step::parser::error(const std::string& m)
void step::parser::error(const location_type& /*loc*/, const std::string& m)
{ {
char newmess[80]; char newmess[120];
sprintf(newmess, "At line %d : %s", scanner->lineno() + 1, m.c_str()); Standard_Boolean isSyntax = (Standard_Boolean)strncmp(m.c_str(), "syntax error", 13);
StepFile_Interrupt(newmess); 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);
} }

67
src/StepFile/step.tab.hxx
View File

@ -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++ // Skeleton interface for Bison LALR(1) parsers in C++
@ -106,7 +106,7 @@ namespace step {
#else #else
# define YY_CONSTEXPR # define YY_CONSTEXPR
#endif #endif
# include "location.hh"
#ifndef YY_ATTRIBUTE_PURE #ifndef YY_ATTRIBUTE_PURE
@ -204,25 +204,19 @@ namespace step {
#else #else
typedef YYSTYPE semantic_type; typedef YYSTYPE semantic_type;
#endif #endif
/// Symbol locations.
typedef location location_type;
/// Syntax errors thrown from user actions. /// Syntax errors thrown from user actions.
struct syntax_error : std::runtime_error 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) : std::runtime_error (m)
, location (l)
{} {}
syntax_error (const syntax_error& s) syntax_error (const syntax_error& s)
: std::runtime_error (s.what ()) : std::runtime_error (s.what ())
, location (s.location)
{} {}
~syntax_error () YY_NOEXCEPT YY_NOTHROW; ~syntax_error () YY_NOEXCEPT YY_NOTHROW;
location_type location;
}; };
/// Token kinds. /// Token kinds.
@ -337,7 +331,7 @@ namespace step {
/// Expects its Base type to provide access to the symbol kind /// Expects its Base type to provide access to the symbol kind
/// via kind (). /// via kind ().
/// ///
/// Provide access to semantic value and location. /// Provide access to semantic value.
template <typename Base> template <typename Base>
struct basic_symbol : Base struct basic_symbol : Base
{ {
@ -347,7 +341,6 @@ namespace step {
/// Default constructor. /// Default constructor.
basic_symbol () basic_symbol ()
: value () : value ()
, location ()
{} {}
#if 201103L <= YY_CPLUSPLUS #if 201103L <= YY_CPLUSPLUS
@ -355,20 +348,17 @@ namespace step {
basic_symbol (basic_symbol&& that) basic_symbol (basic_symbol&& that)
: Base (std::move (that)) : Base (std::move (that))
, value (std::move (that.value)) , value (std::move (that.value))
, location (std::move (that.location))
{} {}
#endif #endif
/// Copy constructor. /// Copy constructor.
basic_symbol (const basic_symbol& that); basic_symbol (const basic_symbol& that);
/// Constructor for valueless symbols. /// Constructor for valueless symbols.
basic_symbol (typename Base::kind_type t, basic_symbol (typename Base::kind_type t);
YY_MOVE_REF (location_type) l);
/// Constructor for symbols with semantic value. /// Constructor for symbols with semantic value.
basic_symbol (typename Base::kind_type t, basic_symbol (typename Base::kind_type t,
YY_RVREF (semantic_type) v, YY_RVREF (semantic_type) v);
YY_RVREF (location_type) l);
/// Destroy the symbol. /// Destroy the symbol.
~basic_symbol () ~basic_symbol ()
@ -382,14 +372,11 @@ namespace step {
Base::clear (); Base::clear ();
} }
#if YYDEBUG || 0
/// The user-facing name of this symbol. /// 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 ()); return parser::symbol_name (this->kind ());
} }
#endif // #if YYDEBUG || 0
/// Backward compatibility (Bison 3.6). /// Backward compatibility (Bison 3.6).
symbol_kind_type type_get () const YY_NOEXCEPT; symbol_kind_type type_get () const YY_NOEXCEPT;
@ -403,9 +390,6 @@ namespace step {
/// The semantic value. /// The semantic value.
semantic_type value; semantic_type value;
/// The location.
location_type location;
private: private:
#if YY_CPLUSPLUS < 201103L #if YY_CPLUSPLUS < 201103L
/// Assignment operator. /// Assignment operator.
@ -492,21 +476,33 @@ namespace step {
#endif #endif
/// Report a syntax error. /// Report a syntax error.
/// \param loc where the syntax error is found.
/// \param msg a description of the syntax error. /// \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. /// Report a syntax error.
void error (const syntax_error& err); void error (const syntax_error& err);
#if YYDEBUG || 0
/// The user-facing name of the symbol whose (internal) number is /// The user-facing name of the symbol whose (internal) number is
/// YYSYMBOL. No bounds checking. /// YYSYMBOL. No bounds checking.
static const char *symbol_name (symbol_kind_type yysymbol); static std::string symbol_name (symbol_kind_type yysymbol);
#endif // #if YYDEBUG || 0
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: private:
#if YY_CPLUSPLUS < 201103L #if YY_CPLUSPLUS < 201103L
@ -520,6 +516,13 @@ namespace step {
/// Stored state numbers (used for stacks). /// Stored state numbers (used for stacks).
typedef signed char state_type; 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. /// Compute post-reduction state.
/// \param yystate the current state /// \param yystate the current state
/// \param yysym the nonterminal to push on the stack /// \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. /// are valid, yet not members of the token_type enum.
static symbol_kind_type yytranslate_ (int t); 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. /// For a symbol, its name in clear.
static const char* const yytname_[]; static const char* const yytname_[];
#endif // #if YYDEBUG || 0
// Tables. // Tables.
@ -847,8 +851,7 @@ namespace step {
public: public:
explicit scanner(StepFile_ReadData* theDataModel, std::istream* in = 0, std::ostream* out = 0); explicit scanner(StepFile_ReadData* theDataModel, std::istream* in = 0, std::ostream* out = 0);
int lex(step::parser::semantic_type* yylval, int lex(step::parser::semantic_type* yylval);
step::parser::location_type* yylloc);
StepFile_ReadData* myDataModel; StepFile_ReadData* myDataModel;
}; };

35
src/StepFile/step.yacc
View File

@ -26,7 +26,7 @@
%parse-param {step::scanner* scanner} %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 %token STEP HEADER ENDSEC DATA ENDSTEP SCOPE ENDSCOPE ENTITY TYPE INTEGER FLOAT IDENT TEXT NONDEF ENUM HEXA QUID
%start stepf %start stepf
@ -48,23 +48,19 @@ namespace step {
#endif #endif
} }
%code {
%code {
#undef yylex #undef yylex
#define yylex scanner->lex #define yylex scanner->lex
#define StepData scanner->myDataModel #define StepData scanner->myDataModel
#define stepclearin yychar = -1
#define steperrok yyerrflag = 0
// disable MSVC warnings in bison code // disable MSVC warnings in bison code
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(disable:4065 4244 4131 4127 4702) #pragma warning(disable:4065 4244 4131 4127 4702)
#define YYMALLOC malloc #define YYMALLOC malloc
#define YYFREE free #define YYFREE free
#endif #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 { %code provides {
@ -88,8 +84,7 @@ namespace step {
public: public:
explicit scanner(StepFile_ReadData* theDataModel, std::istream* in = 0, std::ostream* out = 0); explicit scanner(StepFile_ReadData* theDataModel, std::istream* in = 0, std::ostream* out = 0);
int lex(step::parser::semantic_type* yylval, int lex(step::parser::semantic_type* yylval);
step::parser::location_type* yylloc);
StepFile_ReadData* myDataModel; StepFile_ReadData* myDataModel;
}; };
@ -119,7 +114,7 @@ headent : enttype listarg ';'
endhead : DATA endhead : DATA
{ StepData->FinalOfHead(); } { 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(); } | QUID { /* deja fait par lex*/ StepData->CreateNewArg(); }
| listarg /* rec_newent lors du ')' */ { StepData->CreateNewArg(); } | listarg /* rec_newent lors du ')' */ { StepData->CreateNewArg(); }
| listype listarg /* liste typee */ { StepData->CreateNewArg(); } | listype listarg /* liste typee */ { StepData->CreateNewArg(); }
@ -161,7 +156,7 @@ debscop : SCOPE
{ StepData->AddNewScope(); } { StepData->AddNewScope(); }
; ;
unid : IDENT unid : IDENT
{ StepData->SetTypeArg(ArgumentType_Ident); StepData->CreateNewArg(); } { StepData->SetTypeArg(Interface_ParamIdent); StepData->CreateNewArg(); }
; ;
export : unid export : unid
| export ',' unid | export ',' unid
@ -183,10 +178,18 @@ enttype : TYPE
{ StepData->RecordType (); } { StepData->RecordType (); }
; ;
%% %%
void step::parser::error(const std::string& m)
void step::parser::error(const location_type& /*loc*/, const std::string& m)
{ {
char newmess[80]; char newmess[120];
sprintf(newmess, "At line %d : %s", scanner->lineno() + 1, m.c_str()); Standard_Boolean isSyntax = (Standard_Boolean)strncmp(m.c_str(), "syntax error", 13);
StepFile_Interrupt(newmess); 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);
} }

2
src/StepSelect/StepSelect_WorkLibrary.cxx
View File

@ -72,7 +72,6 @@ Standard_Integer StepSelect_WorkLibrary::ReadFile
if (stepro.IsNull()) return 1; if (stepro.IsNull()) return 1;
Handle(StepData_StepModel) stepmodel = new StepData_StepModel; Handle(StepData_StepModel) stepmodel = new StepData_StepModel;
model = stepmodel; model = stepmodel;
StepFile_ReadTrace (0);
status = StepFile_Read(name, 0, stepmodel, stepro); status = StepFile_Read(name, 0, stepmodel, stepro);
return status; return status;
} }
@ -87,7 +86,6 @@ Standard_Integer StepSelect_WorkLibrary::ReadStream (const Standard_CString the
if (stepro.IsNull()) return 1; if (stepro.IsNull()) return 1;
Handle(StepData_StepModel) stepmodel = new StepData_StepModel; Handle(StepData_StepModel) stepmodel = new StepData_StepModel;
model = stepmodel; model = stepmodel;
StepFile_ReadTrace(0);
status = StepFile_Read(theName, &theIStream, stepmodel, stepro); status = StepFile_Read(theName, &theIStream, stepmodel, stepro);
return status; return status;
} }

2
tests/de/step_1/R9
View File

@ -4,7 +4,7 @@ set filename stepBF3.stp
puts "TODO 29269 ALL: B_SPLINE_CURVE_WITH_KNOTS: Update of 3D-Parameters has failed" puts "TODO 29269 ALL: B_SPLINE_CURVE_WITH_KNOTS: Update of 3D-Parameters has failed"
set ref_data { 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 ) TPSTAT : Faulties = 0 ( 0 ) Warnings = 4 ( 88 ) Summary = 4 ( 88 )
CHECKSHAPE : Wires = 1 ( 1 ) Faces = 1 ( 1 ) Shells = 0 ( 0 ) Solids = 0 ( 0 ) CHECKSHAPE : Wires = 1 ( 1 ) Faces = 1 ( 1 ) Shells = 0 ( 0 ) Solids = 0 ( 0 )
NBSHAPES : Solid = 1 ( 1 ) Shell = 1 ( 1 ) Face = 153 ( 153 ) NBSHAPES : Solid = 1 ( 1 ) Shell = 1 ( 1 ) Face = 153 ( 153 )