KiCad PCB EDA Suite
WRLPROC Class Reference

#include <wrlproc.h>

Public Member Functions

 WRLPROC (LINE_READER *aLineReader)
 
 ~WRLPROC ()
 
bool eof (void)
 
WRLVERSION GetVRMLType (void)
 
const char * GetParentDir (void)
 
std::string GetError (void)
 
bool GetFilePosData (size_t &line, size_t &column)
 
std::string GetFilePosition () const
 
std::string GetFileName (void)
 
bool EatSpace (void)
 
char Peek (void)
 
void Pop (void)
 
bool ReadGlob (std::string &aGlob)
 
bool ReadName (std::string &aName)
 
bool DiscardNode (void)
 
bool DiscardList (void)
 
bool ReadString (std::string &aSFString)
 
bool ReadSFBool (bool &aSFBool)
 
bool ReadSFColor (WRLVEC3F &aSFColor)
 
bool ReadSFFloat (float &aSFFloat)
 
bool ReadSFInt (int &aSFInt32)
 
bool ReadSFRotation (WRLROTATION &aSFRotation)
 
bool ReadSFVec2f (WRLVEC2F &aSFVec2f)
 
bool ReadSFVec3f (WRLVEC3F &aSFVec3f)
 
bool ReadMFString (std::vector< std::string > &aMFString)
 
bool ReadMFColor (std::vector< WRLVEC3F > &aMFColor)
 
bool ReadMFFloat (std::vector< float > &aMFFloat)
 
bool ReadMFInt (std::vector< int > &aMFInt32)
 
bool ReadMFRotation (std::vector< WRLROTATION > &aMFRotation)
 
bool ReadMFVec2f (std::vector< WRLVEC2F > &aMFVec2f)
 
bool ReadMFVec3f (std::vector< WRLVEC3F > &aMFVec3f)
 
bool getRawLine (void)
 

Private Attributes

LINE_READERm_file
 
std::string m_buf
 
bool m_eof
 
unsigned int m_fileline
 
unsigned int m_bufpos
 
WRLVERSION m_fileVersion
 
std::string m_error
 
std::string m_badchars
 
std::string m_filename
 
std::string m_filedir
 

Detailed Description

Definition at line 41 of file wrlproc.h.

Constructor & Destructor Documentation

◆ WRLPROC()

WRLPROC::WRLPROC ( LINE_READER aLineReader)

Definition at line 61 of file wrlproc.cpp.

62{
64 m_eof = false;
65 m_fileline = 0;
66 m_bufpos = 0;
67 m_file = aLineReader;
68
69 if( nullptr == aLineReader )
70 {
71 m_eof = true;
72 return;
73 }
74
75 m_error.clear();
76 wxString tname = m_file->GetSource();
77 m_filename = tname.ToUTF8();
78 wxFileName fn( tname );
79
80 if( fn.IsRelative() )
81 fn.Normalize( FN_NORMALIZE_FLAGS | wxPATH_NORM_ENV_VARS );
82
83 m_filedir = fn.GetPathWithSep().ToUTF8();
84
85 m_buf.clear();
86 GETLINE;
87
88 if( m_eof )
89 return;
90
91 if( m_buf.compare( 0, 16, "#VRML V1.0 ascii" ) == 0 )
92 {
94 // nothing < 0x20, and no:
95 // single or double quote
96 // backslash
97 // curly brace
98 // plus
99 // period
100 m_badchars = "\"'\\{}+.";
101 return;
102 }
103
104 if( m_buf.compare( 0, 15, "#VRML V2.0 utf8" ) == 0 )
105 {
107 // nothing < 0x20, and no:
108 // single or double quotes
109 // sharp (#)
110 // plus
111 // minus
112 // comma
113 // period
114 // square brackets []
115 // curly braces {}
116 // backslash
117 // NOTE: badchars should include '-' but due to my bad model naming scheme
118 // in the VRML model generator, I have allowed '-'. Other VRML parsers seem to
119 // accept '-'. FreeCAD produces names with '+' in them so '+' has been allowed
120 // as well; '+' is not even valid for VRML1.
121 //m_badchars = "'\"#,.+-[]\\{}";
122 m_badchars = "'\"#,.[]\\{}";
123 return;
124 }
125
126 m_buf.clear();
128 m_eof = true;
129
130 m_error = "not a valid VRML file: '";
131 m_error.append( m_filename );
132 m_error.append( 1, '\'' );
133 m_badchars.clear();
134}
virtual const wxString & GetSource() const
Returns the name of the source of the lines in an abstract sense.
Definition: richio.h:109
WRLVERSION m_fileVersion
Definition: wrlproc.h:114
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_filename
Definition: wrlproc.h:117
std::string m_badchars
Definition: wrlproc.h:116
std::string m_filedir
Definition: wrlproc.h:118
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_bufpos
Definition: wrlproc.h:112
bool m_eof
Definition: wrlproc.h:110
std::string m_buf
Definition: wrlproc.h:109
#define GETLINE
Definition: wrlproc.cpp:32
#define FN_NORMALIZE_FLAGS
Default flags to pass to wxFileName::Normalize().
Definition: wx_filename.h:38

References FN_NORMALIZE_FLAGS, GETLINE, LINE_READER::GetSource(), m_badchars, m_buf, m_bufpos, m_eof, m_error, m_file, m_filedir, m_fileline, m_filename, m_fileVersion, VRML_INVALID, VRML_V1, and VRML_V2.

◆ ~WRLPROC()

WRLPROC::~WRLPROC ( )

Definition at line 137 of file wrlproc.cpp.

138{
139}

Member Function Documentation

◆ DiscardList()

bool WRLPROC::DiscardList ( void  )

Definition at line 491 of file wrlproc.cpp.

492{
493 if( !m_file )
494 {
495 m_error = "no open file";
496 return false;
497 }
498
499 if( !EatSpace() )
500 {
501 std::ostringstream ostr;
502 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
503 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
504 ostr << " * [INFO] " << m_error;
505 m_error = ostr.str();
506
507 return false;
508 }
509
510 if( '[' != m_buf[m_bufpos] )
511 {
512 std::ostringstream ostr;
513 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
514 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
515 ostr << " * [INFO] expecting character '[' at line " << m_fileline;
516 ostr << ", column " << m_bufpos;
517 m_error = ostr.str();
518
519 return false;
520 }
521
522 size_t fileline = m_fileline;
523 size_t linepos = m_bufpos;
524
525 ++m_bufpos;
526 size_t lvl = 1;
527 std::string tmp;
528
529 while( lvl > 0 )
530 {
531 if( !EatSpace() )
532 {
533 std::ostringstream ostr;
534 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
535 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
536 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
537 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
538 ostr << " * [INFO] " << m_error;
539 m_error = ostr.str();
540
541 return false;
542 }
543
544 // comments must be skipped
545 if( '#' == m_buf[m_bufpos] )
546 {
547 m_bufpos = 0;
548 m_buf.clear();
549 continue;
550 }
551
552 if( '[' == m_buf[m_bufpos] )
553 {
554 ++m_bufpos;
555 ++lvl;
556 continue;
557 }
558
559 if( ']' == m_buf[m_bufpos] )
560 {
561 ++m_bufpos;
562 --lvl;
563 continue;
564 }
565
566 // note: if we have a '}' we must skip it and test the next non-blank character;
567 // this ensures that we don't miss a ']' in cases where the braces are not
568 // separated by space. if we had proceeded to ReadGlob() we could have had a problem.
569 if( '}' == m_buf[m_bufpos] || '{' == m_buf[m_bufpos] )
570 {
571 ++m_bufpos;
572 continue;
573 }
574
575 // strings are handled as a special case since they may contain
576 // control characters and braces
577 if( '"' == m_buf[m_bufpos] )
578 {
579 if( !ReadString( tmp ) )
580 {
581 std::ostringstream ostr;
582 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
583 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
584 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
585 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
586 ostr << " * [INFO] " << m_error;
587 m_error = ostr.str();
588
589 return false;
590 }
591 }
592
593 // everything at this point can be read and discarded via ReadGlob()
594 if( !ReadGlob( tmp ) )
595 {
596 std::ostringstream ostr;
597 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
598 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
599 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
600 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
601 ostr << " * [INFO] " << m_error;
602 m_error = ostr.str();
603
604 return false;
605 }
606 }
607
608 return false;
609}
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
bool ReadString(std::string &aSFString)
Definition: wrlproc.cpp:612
bool EatSpace(void)
Definition: wrlproc.cpp:191

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, ReadGlob(), and ReadString().

Referenced by WRL2BASE::ReadNode().

◆ DiscardNode()

bool WRLPROC::DiscardNode ( void  )

Definition at line 368 of file wrlproc.cpp.

369{
370 if( !m_file )
371 {
372 m_error = "no open file";
373 return false;
374 }
375
376 if( !EatSpace() )
377 {
378 std::ostringstream ostr;
379 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
380 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
381 ostr << " * [INFO] " << m_error;
382 m_error = ostr.str();
383
384 return false;
385 }
386
387 if( '{' != m_buf[m_bufpos] )
388 {
389 std::ostringstream ostr;
390 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
391 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
392 ostr << " * [INFO] expecting character '{' at line " << m_fileline;
393 ostr << ", column " << m_bufpos;
394 m_error = ostr.str();
395
396 wxLogTrace( traceVrmlPlugin, "%s\n", m_error.c_str() );
397
398 return false;
399 }
400
401 size_t fileline = m_fileline;
402 size_t linepos = m_bufpos;
403
404 ++m_bufpos;
405 size_t lvl = 1;
406 std::string tmp;
407
408 while( lvl > 0 )
409 {
410 if( !EatSpace() )
411 {
412 std::ostringstream ostr;
413 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
414 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
415 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
416 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
417 ostr << " * [INFO] " << m_error;
418 m_error = ostr.str();
419
420 return false;
421 }
422
423 // comments must be skipped
424 if( '#' == m_buf[m_bufpos] )
425 {
426 m_bufpos = 0;
427 m_buf.clear();
428 continue;
429 }
430
431 if( '{' == m_buf[m_bufpos] )
432 {
433 ++m_bufpos;
434 ++lvl;
435 continue;
436 }
437
438 if( '}' == m_buf[m_bufpos] )
439 {
440 ++m_bufpos;
441 --lvl;
442 continue;
443 }
444
445 // note: if we have a ']' we must skip it and test the next non-blank character;
446 // this ensures that we don't miss a '}' in cases where the braces are not
447 // separated by space. if we had proceeded to ReadGlob() we could have had a problem.
448 if( ']' == m_buf[m_bufpos] || '[' == m_buf[m_bufpos] )
449 {
450 ++m_bufpos;
451 continue;
452 }
453
454 // strings are handled as a special case since they may contain
455 // control characters and braces
456 if( '"' == m_buf[m_bufpos] )
457 {
458 if( !ReadString( tmp ) )
459 {
460 std::ostringstream ostr;
461 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
462 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
463 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
464 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
465 ostr << " * [INFO] " << m_error;
466 m_error = ostr.str();
467
468 return false;
469 }
470 }
471
472 // everything at this point can be read and discarded via ReadGlob()
473 if( !ReadGlob( tmp ) )
474 {
475 std::ostringstream ostr;
476 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
477 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
478 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
479 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
480 ostr << " * [INFO] " << m_error;
481 m_error = ostr.str();
482
483 return false;
484 }
485 }
486
487 return true;
488}
const wxChar *const traceVrmlPlugin
Flag to enable VRML plugin trace output.
Definition: vrml.cpp:63

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, ReadGlob(), ReadString(), and traceVrmlPlugin.

Referenced by WRL2BASE::readInline(), WRL1BASE::ReadNode(), and WRL2BASE::ReadNode().

◆ EatSpace()

bool WRLPROC::EatSpace ( void  )

Definition at line 191 of file wrlproc.cpp.

192{
193 if( !m_file )
194 {
195 m_error = "no open file";
196 return false;
197 }
198
199 if( m_bufpos >= m_buf.size() )
200 m_buf.clear();
201
202RETRY:
203 while( m_buf.empty() && !m_eof )
204 getRawLine();
205
206 // buffer may be empty if we have reached EOF or encountered IO errors
207 if( m_buf.empty() )
208 return false;
209
210 // eliminate leading white space (including control characters and comments)
211 while( m_bufpos < m_buf.size() )
212 {
213 if( m_buf[m_bufpos] > 0x20 )
214 break;
215
216 ++m_bufpos;
217 }
218
219 if( m_bufpos == m_buf.size() || '#' == m_buf[m_bufpos] )
220 {
221 // lines consisting entirely of white space are not unusual
222 m_buf.clear();
223 goto RETRY;
224 }
225
226 return true;
227}
bool getRawLine(void)
Definition: wrlproc.cpp:142

References getRawLine(), m_buf, m_bufpos, m_eof, m_error, and m_file.

Referenced by DiscardList(), DiscardNode(), Peek(), ReadGlob(), ReadMFColor(), ReadMFFloat(), ReadMFInt(), ReadMFRotation(), ReadMFString(), ReadMFVec2f(), ReadMFVec3f(), ReadName(), ReadSFBool(), ReadSFFloat(), ReadSFInt(), ReadSFRotation(), ReadSFVec2f(), ReadSFVec3f(), and ReadString().

◆ eof()

◆ GetError()

◆ GetFileName()

◆ GetFilePosData()

bool WRLPROC::GetFilePosData ( size_t &  line,
size_t &  column 
)

Definition at line 1966 of file wrlproc.cpp.

1967{
1968 if( !m_file )
1969 {
1970 line = 0;
1971 column = 0;
1972 return false;
1973 }
1974
1975 line = m_fileline;
1976 column = m_bufpos;
1977
1978 return true;
1979}

References m_bufpos, m_file, and m_fileline.

Referenced by WRL2TRANSFORM::Read().

◆ GetFilePosition()

◆ GetParentDir()

const char * WRLPROC::GetParentDir ( void  )

Definition at line 236 of file wrlproc.cpp.

237{
238 if( m_filedir.empty() )
239 return nullptr;
240
241 return m_filedir.c_str();
242}

References m_filedir.

Referenced by WRL2BASE::Read().

◆ getRawLine()

bool WRLPROC::getRawLine ( void  )

Definition at line 142 of file wrlproc.cpp.

143{
144 m_error.clear();
145
146 if( !m_file )
147 {
148 m_error = "no open file";
149 return false;
150 }
151
152 if( m_bufpos >= m_buf.size() )
153 m_buf.clear();
154
155 if( !m_buf.empty() )
156 return true;
157
158 if( m_eof )
159 return false;
160
161 GETLINE;
162
163 if( m_eof && m_buf.empty() )
164 return false;
165
166 // strip the EOL characters
167 while( !m_buf.empty() && ( *m_buf.rbegin() == '\r' || *m_buf.rbegin() == '\n' ) )
168 m_buf.erase( --m_buf.end() );
169
170 if( WRLVERSION::VRML_V1 == m_fileVersion && !m_buf.empty() )
171 {
172 std::string::iterator sS = m_buf.begin();
173 std::string::iterator eS = m_buf.end();
174
175 while( sS != eS )
176 {
177 if( ( ( *sS ) & 0x80 ) )
178 {
179 m_error = " non-ASCII character sequence in VRML1 file";
180 return false;
181 }
182
183 ++sS;
184 }
185 }
186
187 return true;
188}

References GETLINE, m_buf, m_bufpos, m_eof, m_error, m_file, m_fileVersion, and VRML_V1.

Referenced by EatSpace(), and ReadString().

◆ GetVRMLType()

WRLVERSION WRLPROC::GetVRMLType ( void  )

Definition at line 230 of file wrlproc.cpp.

231{
232 return m_fileVersion;
233}

References m_fileVersion.

Referenced by LoadVRML(), WRL1BASE::Read(), and WRL2BASE::Read().

◆ Peek()

char WRLPROC::Peek ( void  )

Definition at line 2007 of file wrlproc.cpp.

2008{
2009 if( !m_file )
2010 {
2011 std::ostringstream ostr;
2012 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
2013 ostr << " * [BUG] no open file";
2014 m_error = ostr.str();
2015 return '\0';
2016 }
2017
2018 if( !EatSpace() )
2019 {
2020 if( m_error.empty() )
2021 {
2022 std::ostringstream ostr;
2023 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
2024 ostr << " * [INFO] failed to read data from file\n";
2025 m_error = ostr.str();
2026 }
2027
2028 return '\0';
2029 }
2030
2031 return m_buf[m_bufpos];
2032}

References EatSpace(), m_buf, m_bufpos, m_error, and m_file.

Referenced by WRL1BASE::Read(), WRL1COORDS::Read(), WRL1FACESET::Read(), WRL1GROUP::Read(), WRL1MATBINDING::Read(), WRL1MATERIAL::Read(), WRL1SEPARATOR::Read(), WRL1SHAPEHINTS::Read(), WRL1SWITCH::Read(), WRL1TRANSFORM::Read(), WRL2APPEARANCE::Read(), WRL2BOX::Read(), WRL2COLOR::Read(), WRL2COORDS::Read(), WRL2FACESET::Read(), WRL2INLINE::Read(), WRL2LINESET::Read(), WRL2MATERIAL::Read(), WRL2NORMS::Read(), WRL2POINTSET::Read(), WRL2SHAPE::Read(), WRL2SWITCH::Read(), WRL2TRANSFORM::Read(), WRL2SWITCH::readChildren(), and WRL2TRANSFORM::readChildren().

◆ Pop()

◆ ReadGlob()

bool WRLPROC::ReadGlob ( std::string &  aGlob)

Definition at line 245 of file wrlproc.cpp.

246{
247 aGlob.clear();
248
249 if( !m_file )
250 {
251 m_error = "no open file";
252 return false;
253 }
254
255 while( true )
256 {
257 if( !EatSpace() )
258 return false;
259
260 // if the text is the start of a comment block, clear the buffer and loop
261 if( '#' == m_buf[m_bufpos] )
262 m_buf.clear();
263 else
264 break;
265 }
266
267 size_t ssize = m_buf.size();
268
269 while( m_bufpos < ssize && m_buf[m_bufpos] > 0x20 )
270 {
271 if( ',' == m_buf[m_bufpos] )
272 {
273 // the comma is a special instance of blank space
274 ++m_bufpos;
275 return true;
276 }
277
278 if( '{' == m_buf[m_bufpos] || '}' == m_buf[m_bufpos]
279 || '[' == m_buf[m_bufpos] || ']' == m_buf[m_bufpos] )
280 return true;
281
282 aGlob.append( 1, m_buf[m_bufpos++] );
283 }
284
285 return true;
286}

References EatSpace(), m_buf, m_bufpos, m_error, and m_file.

Referenced by DiscardList(), DiscardNode(), WRL2BASE::ReadNode(), ReadSFBool(), ReadSFFloat(), ReadSFInt(), ReadSFRotation(), ReadSFVec2f(), ReadSFVec3f(), and ReadString().

◆ ReadMFColor()

bool WRLPROC::ReadMFColor ( std::vector< WRLVEC3F > &  aMFColor)

Definition at line 1281 of file wrlproc.cpp.

1282{
1283 aMFColor.clear();
1284 size_t fileline = m_fileline;
1285 size_t linepos = m_bufpos;
1286
1287 if( !m_file )
1288 {
1289 m_error = "no open file";
1290 return false;
1291 }
1292
1293 WRLVEC3F lcolor;
1294
1295 while( true )
1296 {
1297 if( !EatSpace() )
1298 return false;
1299
1300 // if the text is the start of a comment block, clear the buffer and loop
1301 if( '#' == m_buf[m_bufpos] )
1302 m_buf.clear();
1303 else
1304 break;
1305 }
1306
1307 if( m_buf[m_bufpos] != '[' )
1308 {
1309 if( !ReadSFColor( lcolor ) )
1310 {
1311 std::ostringstream ostr;
1312 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1313 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1314 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1315 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1316 ostr << " * [INFO] " << m_error;
1317 m_error = ostr.str();
1318
1319 return false;
1320 }
1321
1322 if( !EatSpace() )
1323 {
1324 std::ostringstream ostr;
1325 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1326 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1327 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1328 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1329 ostr << " * [INFO] could not check characters after the string";
1330 m_error = ostr.str();
1331
1332 return false;
1333 }
1334
1335 if( ',' == m_buf[m_bufpos] )
1336 Pop();
1337
1338 aMFColor.push_back( lcolor );
1339 return true;
1340 }
1341
1342 ++m_bufpos;
1343
1344 while( true )
1345 {
1346 if( !EatSpace() )
1347 return false;
1348
1349 if( ']' == m_buf[m_bufpos] )
1350 break;
1351
1352 if( !ReadSFColor( lcolor ) )
1353 {
1354 std::ostringstream ostr;
1355 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1356 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1357 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1358 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1359 ostr << " * [INFO] " << m_error;
1360 m_error = ostr.str();
1361
1362 return false;
1363 }
1364
1365 aMFColor.push_back( lcolor );
1366
1367 if( !EatSpace() )
1368 {
1369 std::ostringstream ostr;
1370 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1371 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1372 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1373 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1374 ostr << " * [INFO] could not check characters after the string";
1375 m_error = ostr.str();
1376
1377 return false;
1378 }
1379
1380 if( ']' == m_buf[m_bufpos] )
1381 break;
1382
1383 if( ',' == m_buf[m_bufpos] )
1384 Pop();
1385
1386 }
1387
1388 ++m_bufpos;
1389 return true;
1390}
void Pop(void)
Definition: wrlproc.cpp:2035
bool ReadSFColor(WRLVEC3F &aSFColor)
Definition: wrlproc.cpp:774
glm::vec3 WRLVEC3F
Definition: wrltypes.h:188

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, Pop(), and ReadSFColor().

◆ ReadMFFloat()

bool WRLPROC::ReadMFFloat ( std::vector< float > &  aMFFloat)

Definition at line 1393 of file wrlproc.cpp.

1394{
1395 aMFFloat.clear();
1396 size_t fileline = m_fileline;
1397 size_t linepos = m_bufpos;
1398
1399 if( !m_file )
1400 {
1401 m_error = "no open file";
1402 return false;
1403 }
1404
1405 float temp;
1406
1407 while( true )
1408 {
1409 if( !EatSpace() )
1410 return false;
1411
1412 // if the text is the start of a comment block, clear the buffer and loop
1413 if( '#' == m_buf[m_bufpos] )
1414 m_buf.clear();
1415 else
1416 break;
1417 }
1418
1419 if( m_buf[m_bufpos] != '[' )
1420 {
1421 if( !ReadSFFloat( temp ) )
1422 {
1423 std::ostringstream ostr;
1424 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1425 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1426 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1427 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1428 ostr << " * [INFO] " << m_error;
1429 m_error = ostr.str();
1430
1431 return false;
1432 }
1433
1434 if( !EatSpace() )
1435 {
1436 std::ostringstream ostr;
1437 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1438 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1439 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1440 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1441 ostr << " * [INFO] could not check characters after the string";
1442 m_error = ostr.str();
1443
1444 return false;
1445 }
1446
1447 if( ',' == m_buf[m_bufpos] )
1448 Pop();
1449
1450 aMFFloat.push_back( temp );
1451 return true;
1452 }
1453
1454 ++m_bufpos;
1455
1456 while( true )
1457 {
1458 if( !EatSpace() )
1459 return false;
1460
1461 if( ']' == m_buf[m_bufpos] )
1462 break;
1463
1464 if( !ReadSFFloat( temp ) )
1465 {
1466 std::ostringstream ostr;
1467 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1468 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1469 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1470 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1471 ostr << " * [INFO] " << m_error;
1472 m_error = ostr.str();
1473
1474 return false;
1475 }
1476
1477 aMFFloat.push_back( temp );
1478
1479 if( !EatSpace() )
1480 {
1481 std::ostringstream ostr;
1482 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1483 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1484 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1485 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1486 ostr << " * [INFO] could not check characters after the string";
1487 m_error = ostr.str();
1488
1489 return false;
1490 }
1491
1492 if( ']' == m_buf[m_bufpos] )
1493 break;
1494
1495 if( ',' == m_buf[m_bufpos] )
1496 Pop();
1497 }
1498
1499 ++m_bufpos;
1500 return true;
1501}
bool ReadSFFloat(float &aSFFloat)
Definition: wrlproc.cpp:806

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, Pop(), and ReadSFFloat().

Referenced by WRL1MATERIAL::Read().

◆ ReadMFInt()

bool WRLPROC::ReadMFInt ( std::vector< int > &  aMFInt32)

Definition at line 1504 of file wrlproc.cpp.

1505{
1506 aMFInt32.clear();
1507 size_t fileline = m_fileline;
1508 size_t linepos = m_bufpos;
1509
1510 if( !m_file )
1511 {
1512 m_error = "no open file";
1513 return false;
1514 }
1515
1516 int temp;
1517
1518 while( true )
1519 {
1520 if( !EatSpace() )
1521 return false;
1522
1523 // if the text is the start of a comment block, clear the buffer and loop
1524 if( '#' == m_buf[m_bufpos] )
1525 m_buf.clear();
1526 else
1527 break;
1528 }
1529
1530 if( m_buf[m_bufpos] != '[' )
1531 {
1532 if( !ReadSFInt( temp ) )
1533 {
1534 std::ostringstream ostr;
1535 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1536 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1537 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1538 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1539 ostr << " * [INFO] " << m_error;
1540 m_error = ostr.str();
1541
1542 return false;
1543 }
1544
1545 if( !EatSpace() )
1546 {
1547 std::ostringstream ostr;
1548 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1549 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1550 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1551 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1552 ostr << " * [INFO] could not check characters after the string";
1553 m_error = ostr.str();
1554
1555 return false;
1556 }
1557
1558 if( ',' == m_buf[m_bufpos] )
1559 Pop();
1560
1561 aMFInt32.push_back( temp );
1562 return true;
1563 }
1564
1565 ++m_bufpos;
1566
1567 while( true )
1568 {
1569 if( !EatSpace() )
1570 return false;
1571
1572 if( ']' == m_buf[m_bufpos] )
1573 break;
1574
1575 if( !ReadSFInt( temp ) )
1576 {
1577 std::ostringstream ostr;
1578 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1579 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1580 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1581 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1582 ostr << " * [INFO] " << m_error;
1583 m_error = ostr.str();
1584
1585 return false;
1586 }
1587
1588 aMFInt32.push_back( temp );
1589
1590 if( !EatSpace() )
1591 {
1592 std::ostringstream ostr;
1593 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1594 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1595 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1596 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1597 ostr << " * [INFO] could not check characters after the string";
1598 m_error = ostr.str();
1599
1600 return false;
1601 }
1602
1603 if( ']' == m_buf[m_bufpos] )
1604 break;
1605
1606 if( ',' == m_buf[m_bufpos] )
1607 Pop();
1608
1609 }
1610
1611 ++m_bufpos;
1612 return true;
1613}
bool ReadSFInt(int &aSFInt32)
Definition: wrlproc.cpp:867

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, Pop(), and ReadSFInt().

Referenced by WRL1FACESET::Read(), WRL2FACESET::Read(), and WRL2LINESET::Read().

◆ ReadMFRotation()

bool WRLPROC::ReadMFRotation ( std::vector< WRLROTATION > &  aMFRotation)

Definition at line 1616 of file wrlproc.cpp.

1617{
1618 aMFRotation.clear();
1619 size_t fileline = m_fileline;
1620 size_t linepos = m_bufpos;
1621
1622 if( !m_file )
1623 {
1624 m_error = "no open file";
1625 return false;
1626 }
1627
1628 WRLROTATION lrot;
1629
1630 while( true )
1631 {
1632 if( !EatSpace() )
1633 return false;
1634
1635 // if the text is the start of a comment block, clear the buffer and loop
1636 if( '#' == m_buf[m_bufpos] )
1637 m_buf.clear();
1638 else
1639 break;
1640 }
1641
1642 if( m_buf[m_bufpos] != '[' )
1643 {
1644 if( !ReadSFRotation( lrot ) )
1645 {
1646 std::ostringstream ostr;
1647 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1648 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1649 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1650 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1651 ostr << " * [INFO] " << m_error;
1652 m_error = ostr.str();
1653
1654 return false;
1655 }
1656
1657 if( !EatSpace() )
1658 {
1659 std::ostringstream ostr;
1660 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1661 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1662 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1663 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1664 ostr << " * [INFO] could not check characters after the string";
1665 m_error = ostr.str();
1666
1667 return false;
1668 }
1669
1670 if( ',' == m_buf[m_bufpos] )
1671 Pop();
1672
1673 aMFRotation.push_back( lrot );
1674 return true;
1675 }
1676
1677 ++m_bufpos;
1678
1679 while( true )
1680 {
1681 if( !EatSpace() )
1682 return false;
1683
1684 if( ']' == m_buf[m_bufpos] )
1685 break;
1686
1687 if( !ReadSFRotation( lrot ) )
1688 {
1689 std::ostringstream ostr;
1690 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1691 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1692 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1693 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1694 ostr << " * [INFO] " << m_error;
1695 m_error = ostr.str();
1696
1697 return false;
1698 }
1699
1700 aMFRotation.push_back( lrot );
1701
1702 if( !EatSpace() )
1703 {
1704 std::ostringstream ostr;
1705 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1706 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1707 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1708 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1709 ostr << " * [INFO] could not check characters after the string";
1710 m_error = ostr.str();
1711
1712 return false;
1713 }
1714
1715 if( ']' == m_buf[m_bufpos] )
1716 break;
1717
1718 if( ',' == m_buf[m_bufpos] )
1719 Pop();
1720
1721 }
1722
1723 ++m_bufpos;
1724 return true;
1725}
bool ReadSFRotation(WRLROTATION &aSFRotation)
Definition: wrlproc.cpp:937
glm::vec4 WRLROTATION
Definition: wrltypes.h:189

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, Pop(), and ReadSFRotation().

◆ ReadMFString()

bool WRLPROC::ReadMFString ( std::vector< std::string > &  aMFString)

Definition at line 1162 of file wrlproc.cpp.

1163{
1164 aMFString.clear();
1165 size_t fileline = m_fileline;
1166 size_t linepos = m_bufpos;
1167
1168 if( !m_file )
1169 {
1170 m_error = "no open file";
1171 return false;
1172 }
1173
1174 while( true )
1175 {
1176 if( !EatSpace() )
1177 return false;
1178
1179 // if the text is the start of a comment block, clear the buffer and loop
1180 if( '#' == m_buf[m_bufpos] )
1181 m_buf.clear();
1182 else
1183 break;
1184 }
1185
1186 std::string lstr;
1187
1188 if( m_buf[m_bufpos] != '[' )
1189 {
1190 if( !ReadString( lstr ) )
1191 {
1192 std::ostringstream ostr;
1193 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1194 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1195 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1196 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1197 ostr << " * [INFO] " << m_error;
1198 m_error = ostr.str();
1199
1200 return false;
1201 }
1202
1203 if( m_bufpos >= m_buf.size() && !EatSpace() )
1204 {
1205 std::ostringstream ostr;
1206 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1207 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1208 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1209 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1210 ostr << " * [INFO] could not check characters after the string";
1211 m_error = ostr.str();
1212
1213 return false;
1214 }
1215
1216 if( ',' == m_buf[m_bufpos] )
1217 Pop();
1218
1219 aMFString.push_back( lstr );
1220 return true;
1221 }
1222
1223 ++m_bufpos;
1224
1225 while( true )
1226 {
1227 if( !ReadString( lstr ) )
1228 {
1229 std::ostringstream ostr;
1230 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1231 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1232 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1233 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1234 ostr << " * [INFO] " << m_error;
1235 m_error = ostr.str();
1236
1237 return false;
1238 }
1239
1240 if( !EatSpace() )
1241 {
1242 std::ostringstream ostr;
1243 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1244 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1245 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1246 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1247 ostr << " * [INFO] could not check characters after the string";
1248 m_error = ostr.str();
1249
1250 return false;
1251 }
1252
1253 if( ',' == m_buf[m_bufpos] )
1254 Pop();
1255
1256 aMFString.push_back( lstr );
1257
1258 if( !EatSpace() )
1259 {
1260 std::ostringstream ostr;
1261 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1262 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1263 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1264 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1265 ostr << " * [INFO] problems encountered while reading list";
1266 m_error = ostr.str();
1267
1268 return false;
1269 }
1270
1271 if( ']' == m_buf[m_bufpos] )
1272 break;
1273
1274 }
1275
1276 ++m_bufpos;
1277 return true;
1278}

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, Pop(), and ReadString().

Referenced by WRL2INLINE::Read().

◆ ReadMFVec2f()

bool WRLPROC::ReadMFVec2f ( std::vector< WRLVEC2F > &  aMFVec2f)

Definition at line 1728 of file wrlproc.cpp.

1729{
1730 aMFVec2f.clear();
1731 size_t fileline = m_fileline;
1732 size_t linepos = m_bufpos;
1733
1734 if( !m_file )
1735 {
1736 m_error = "no open file";
1737 return false;
1738 }
1739
1740 WRLVEC2F lvec2f;
1741
1742 while( true )
1743 {
1744 if( !EatSpace() )
1745 return false;
1746
1747 // if the text is the start of a comment block, clear the buffer and loop
1748 if( '#' == m_buf[m_bufpos] )
1749 m_buf.clear();
1750 else
1751 break;
1752 }
1753
1754 if( m_buf[m_bufpos] != '[' )
1755 {
1756 if( !ReadSFVec2f( lvec2f ) )
1757 {
1758 std::ostringstream ostr;
1759 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1760 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1761 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1762 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1763 ostr << " * [INFO] " << m_error;
1764 m_error = ostr.str();
1765
1766 return false;
1767 }
1768
1769 if( !EatSpace() )
1770 {
1771 std::ostringstream ostr;
1772 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1773 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1774 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1775 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1776 ostr << " * [INFO] could not check characters after the string";
1777 m_error = ostr.str();
1778
1779 return false;
1780 }
1781
1782 if( ',' == m_buf[m_bufpos] )
1783 Pop();
1784
1785 aMFVec2f.push_back( lvec2f );
1786 return true;
1787 }
1788
1789 ++m_bufpos;
1790
1791 while( true )
1792 {
1793 if( !EatSpace() )
1794 return false;
1795
1796 if( ']' == m_buf[m_bufpos] )
1797 break;
1798
1799 if( !ReadSFVec2f( lvec2f ) )
1800 {
1801 std::ostringstream ostr;
1802 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1803 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1804 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1805 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1806 ostr << " * [INFO] " << m_error;
1807 m_error = ostr.str();
1808
1809 return false;
1810 }
1811
1812 aMFVec2f.push_back( lvec2f );
1813
1814 if( !EatSpace() )
1815 {
1816 std::ostringstream ostr;
1817 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1818 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1819 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1820 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1821 ostr << " * [INFO] could not check characters after the string";
1822 m_error = ostr.str();
1823
1824 return false;
1825 }
1826
1827 if( ']' == m_buf[m_bufpos] )
1828 break;
1829
1830 if( ',' == m_buf[m_bufpos] )
1831 Pop();
1832 }
1833
1834 ++m_bufpos;
1835 return true;
1836}
bool ReadSFVec2f(WRLVEC2F &aSFVec2f)
Definition: wrlproc.cpp:1011
glm::vec2 WRLVEC2F
Definition: wrltypes.h:187

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, Pop(), and ReadSFVec2f().

◆ ReadMFVec3f()

bool WRLPROC::ReadMFVec3f ( std::vector< WRLVEC3F > &  aMFVec3f)

Definition at line 1839 of file wrlproc.cpp.

1840{
1841 aMFVec3f.clear();
1842 size_t fileline = m_fileline;
1843 size_t linepos = m_bufpos;
1844
1845 if( !m_file )
1846 {
1847 m_error = "no open file";
1848 return false;
1849 }
1850
1851 WRLVEC3F lvec3f;
1852
1853 while( true )
1854 {
1855 if( !EatSpace() )
1856 return false;
1857
1858 // if the text is the start of a comment block, clear the buffer and loop
1859 if( '#' == m_buf[m_bufpos] )
1860 m_buf.clear();
1861 else
1862 break;
1863 }
1864
1865 if( m_buf[m_bufpos] != '[' )
1866 {
1867 if( !ReadSFVec3f( lvec3f ) )
1868 {
1869 std::ostringstream ostr;
1870 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1871 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1872 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1873 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1874 ostr << " * [INFO] " << m_error;
1875 m_error = ostr.str();
1876
1877 return false;
1878 }
1879
1880 if( !EatSpace() )
1881 {
1882 std::ostringstream ostr;
1883 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1884 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1885 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1886 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1887 ostr << " * [INFO] could not check characters after the string";
1888 m_error = ostr.str();
1889
1890 return false;
1891 }
1892
1893 if( ',' == m_buf[m_bufpos] )
1894 Pop();
1895
1896 aMFVec3f.push_back( lvec3f );
1897 return true;
1898 }
1899
1900 ++m_bufpos;
1901
1902 while( true )
1903 {
1904 if( !EatSpace() )
1905 return false;
1906
1907 if( ']' == m_buf[m_bufpos] )
1908 break;
1909
1910 if( !ReadSFVec3f( lvec3f ) )
1911 {
1912 std::ostringstream ostr;
1913 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1914 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1915 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1916 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1917 ostr << " * [INFO] " << m_error;
1918 m_error = ostr.str();
1919
1920 return false;
1921 }
1922
1923 aMFVec3f.push_back( lvec3f );
1924
1925 if( !EatSpace() )
1926 {
1927 std::ostringstream ostr;
1928 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1929 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1930 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1931 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1932 ostr << " * [INFO] could not check characters after the string";
1933 m_error = ostr.str();
1934
1935 return false;
1936 }
1937
1938 if( !EatSpace() )
1939 return false;
1940
1941 if( ']' == m_buf[m_bufpos] )
1942 break;
1943
1944 if( ',' == m_buf[m_bufpos] )
1945 Pop();
1946
1947 }
1948
1949 ++m_bufpos;
1950 return true;
1951}
bool ReadSFVec3f(WRLVEC3F &aSFVec3f)
Definition: wrlproc.cpp:1082

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, Pop(), and ReadSFVec3f().

Referenced by WRL1COORDS::Read(), WRL1MATERIAL::Read(), WRL2COLOR::Read(), WRL2COORDS::Read(), and WRL2NORMS::Read().

◆ ReadName()

bool WRLPROC::ReadName ( std::string &  aName)

Definition at line 289 of file wrlproc.cpp.

290{
291 aName.clear();
292
293 if( !m_file )
294 {
295 m_error = "no open file";
296 return false;
297 }
298
299 while( true )
300 {
301 if( !EatSpace() )
302 return false;
303
304 // if the text is the start of a comment block, clear the buffer and loop
305 if( '#' == m_buf[m_bufpos] )
306 m_buf.clear();
307 else
308 break;
309 }
310
311 size_t ssize = m_buf.size();
312
313 while( m_bufpos < ssize && m_buf[m_bufpos] > 0x20 )
314 {
315 if( '[' == m_buf[m_bufpos] || '{' == m_buf[m_bufpos]
316 || ']' == m_buf[m_bufpos] || '}' == m_buf[m_bufpos]
317 || '.' == m_buf[m_bufpos] || '#' == m_buf[m_bufpos]
318 || ',' == m_buf[m_bufpos] )
319 {
320 if( !aName.empty() )
321 {
322 return true;
323 }
324 else
325 {
326 std::ostringstream ostr;
327 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
328 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
329 ostr << " * [INFO] line " << m_fileline << ", column " << m_bufpos;
330 ostr << " -- invalid name";
331 m_error = ostr.str();
332
333 return false;
334 }
335 }
336
337 if( m_badchars.find( m_buf[m_bufpos] ) != std::string::npos )
338 {
339 std::ostringstream ostr;
340 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
341 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
342 ostr << " * [INFO] line " << m_fileline << ", column " << m_bufpos;
343 ostr << " -- invalid character in name";
344 m_error = ostr.str();
345
346 return false;
347 }
348
349 if( aName.empty() && m_buf[m_bufpos] >= '0' && m_buf[m_bufpos] <= '9' )
350 {
351 std::ostringstream ostr;
352 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
353 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
354 ostr << " * [INFO] line " << m_fileline << ", column " << m_bufpos;
355 ostr << " -- name must not start with a digit";
356 m_error = ostr.str();
357
358 return false;
359 }
360
361 aName.append( 1, m_buf[m_bufpos++] );
362 }
363
364 return true;
365}

References EatSpace(), m_badchars, m_buf, m_bufpos, m_error, m_file, m_fileline, and m_filename.

Referenced by WRL1BASE::implementDef(), WRL2BASE::implementDef(), WRL1BASE::implementUse(), WRL2BASE::implementUse(), WRL1COORDS::Read(), WRL1FACESET::Read(), WRL1MATBINDING::Read(), WRL1MATERIAL::Read(), WRL1SHAPEHINTS::Read(), WRL1SWITCH::Read(), WRL1TRANSFORM::Read(), WRL2APPEARANCE::Read(), WRL2BOX::Read(), WRL2COLOR::Read(), WRL2COORDS::Read(), WRL2FACESET::Read(), WRL2INLINE::Read(), WRL2LINESET::Read(), WRL2MATERIAL::Read(), WRL2NORMS::Read(), WRL2POINTSET::Read(), WRL2SHAPE::Read(), WRL2SWITCH::Read(), WRL2TRANSFORM::Read(), WRL1BASE::ReadNode(), and WRL2BASE::ReadNode().

◆ ReadSFBool()

bool WRLPROC::ReadSFBool ( bool &  aSFBool)

Definition at line 729 of file wrlproc.cpp.

730{
731 if( !EatSpace() )
732 return false;
733
734 size_t fileline = m_fileline;
735 size_t linepos = m_bufpos;
736 std::string tmp;
737
738 if( !ReadGlob( tmp ) )
739 return false;
740
741 if( !tmp.compare( "0" ) )
742 {
743 aSFBool = false;
744 }
745 else if( !tmp.compare( "1" ) )
746 {
747 aSFBool = true;
748 }
749 else if( !tmp.compare( "TRUE" ) )
750 {
751 aSFBool = true;
752 }
753 else if( !tmp.compare( "FALSE" ) )
754 {
755 aSFBool = false;
756 }
757 else
758 {
759 std::ostringstream ostr;
760 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
761 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
762 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
763 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
764 ostr << " * [INFO] expected one of 0, 1, TRUE, FALSE but got '" << tmp << "'\n";
765 m_error = ostr.str();
766
767 return false;
768 }
769
770 return true;
771}

References EatSpace(), m_bufpos, m_error, m_fileline, m_filename, and ReadGlob().

Referenced by WRL2FACESET::Read(), and WRL2LINESET::Read().

◆ ReadSFColor()

bool WRLPROC::ReadSFColor ( WRLVEC3F aSFColor)

Definition at line 774 of file wrlproc.cpp.

775{
776 if( !m_file )
777 {
778 m_error = "no open file";
779 return false;
780 }
781
782 size_t fileline = m_fileline;
783 size_t linepos = m_bufpos;
784
785 if( !ReadSFVec3f( aSFColor ) )
786 return false;
787
788 if( aSFColor.x < 0.0 || aSFColor.x > 1.0 || aSFColor.y < 0.0 || aSFColor.y > 1.0
789 || aSFColor.z < 0.0 || aSFColor.z > 1.0 )
790 {
791 std::ostringstream ostr;
792 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
793 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
794 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
795 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
796 ostr << " * [INFO] invalid RGB value in color triplet";
797 m_error = ostr.str();
798
799 return false;
800 }
801
802 return true;
803}

References m_bufpos, m_error, m_file, m_fileline, m_filename, and ReadSFVec3f().

Referenced by ReadMFColor().

◆ ReadSFFloat()

bool WRLPROC::ReadSFFloat ( float &  aSFFloat)

Definition at line 806 of file wrlproc.cpp.

807{
808 if( !m_file )
809 {
810 m_error = "no open file";
811 return false;
812 }
813
814 aSFFloat = 0.0;
815
816 size_t fileline = m_fileline;
817 size_t linepos = m_bufpos;
818
819 while( true )
820 {
821 if( !EatSpace() )
822 return false;
823
824 // if the text is the start of a comment block, clear the buffer and loop
825 if( '#' == m_buf[m_bufpos] )
826 m_buf.clear();
827 else
828 break;
829 }
830
831 std::string tmp;
832
833 if( !ReadGlob( tmp ) )
834 {
835 std::ostringstream ostr;
836 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
837 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
838 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
839 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
840 ostr << " * [INFO] " << m_error;
841 m_error = ostr.str();
842
843 return false;
844 }
845
846 std::istringstream istr;
847 istr.str( tmp );
848 istr >> aSFFloat;
849
850 if( istr.fail() || !istr.eof() )
851 {
852 std::ostringstream ostr;
853 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
854 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
855 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
856 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
857 ostr << " * [INFO] invalid character in SFFloat";
858 m_error = ostr.str();
859
860 return false;
861 }
862
863 return true;
864}

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, and ReadGlob().

Referenced by WRL1SHAPEHINTS::Read(), WRL2FACESET::Read(), WRL2MATERIAL::Read(), and ReadMFFloat().

◆ ReadSFInt()

bool WRLPROC::ReadSFInt ( int &  aSFInt32)

Definition at line 867 of file wrlproc.cpp.

868{
869 if( !m_file )
870 {
871 m_error = "no open file";
872 return false;
873 }
874
875 aSFInt32 = 0;
876 size_t fileline = m_fileline;
877 size_t linepos = m_bufpos;
878
879 while( true )
880 {
881 if( !EatSpace() )
882 return false;
883
884 // if the text is the start of a comment block, clear the buffer and loop
885 if( '#' == m_buf[m_bufpos] )
886 m_buf.clear();
887 else
888 break;
889 }
890
891 std::string tmp;
892
893 if( !ReadGlob( tmp ) )
894 {
895 std::ostringstream ostr;
896 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
897 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
898 ostr << " * [INFO] line " << fileline<< ", char " << linepos << " -- ";
899 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
900 ostr << " * [INFO] " << m_error;
901 m_error = ostr.str();
902
903 return false;
904 }
905
906 if( std::string::npos != tmp.find( "0x" ) )
907 {
908 // Rules: "0x" + "0-9, A-F" - VRML is case sensitive but in
909 // this instance we do no enforce case.
910 std::stringstream sstr;
911 sstr << std::hex << tmp;
912 sstr >> aSFInt32;
913 return true;
914 }
915
916 std::istringstream istr;
917 istr.str( tmp );
918 istr >> aSFInt32;
919
920 if( istr.fail() || !istr.eof() )
921 {
922 std::ostringstream ostr;
923 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
924 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
925 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
926 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
927 ostr << " * [INFO] invalid character in SFInt";
928 m_error = ostr.str();
929
930 return false;
931 }
932
933 return true;
934}

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, and ReadGlob().

Referenced by WRL1SWITCH::Read(), WRL2SWITCH::Read(), and ReadMFInt().

◆ ReadSFRotation()

bool WRLPROC::ReadSFRotation ( WRLROTATION aSFRotation)

Definition at line 937 of file wrlproc.cpp.

938{
939 if( !m_file )
940 {
941 m_error = "no open file";
942 return false;
943 }
944
945 aSFRotation.x = 0.0;
946 aSFRotation.y = 0.0;
947 aSFRotation.z = 1.0;
948 aSFRotation.w = 0.0;
949
950 size_t fileline = m_fileline;
951 size_t linepos = m_bufpos;
952
953 while( true )
954 {
955 if( !EatSpace() )
956 return false;
957
958 // if the text is the start of a comment block, clear the buffer and loop
959 if( '#' == m_buf[m_bufpos] )
960 m_buf.clear();
961 else
962 break;
963 }
964
965 std::string tmp;
966 float trot[4];
967
968 for( int i = 0; i < 4; ++i )
969 {
970 if( !ReadGlob( tmp ) )
971 {
972 std::ostringstream ostr;
973 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
974 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
975 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
976 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
977 ostr << " * [INFO] " << m_error;
978 m_error = ostr.str();
979
980 return false;
981 }
982
983 std::istringstream istr;
984 istr.str( tmp );
985 istr >> trot[i];
986
987 if( istr.fail() || !istr.eof() )
988 {
989 std::ostringstream ostr;
990 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
991 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
992 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
993 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
994 ostr << " * [INFO] invalid character in space delimited quartet";
995 m_error = ostr.str();
996
997 return false;
998 }
999
1000 }
1001
1002 aSFRotation.x = trot[0];
1003 aSFRotation.y = trot[1];
1004 aSFRotation.z = trot[2];
1005 aSFRotation.w = trot[3];
1006
1007 return true;
1008}

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, and ReadGlob().

Referenced by WRL1TRANSFORM::Read(), WRL2TRANSFORM::Read(), and ReadMFRotation().

◆ ReadSFVec2f()

bool WRLPROC::ReadSFVec2f ( WRLVEC2F aSFVec2f)

Definition at line 1011 of file wrlproc.cpp.

1012{
1013 if( !m_file )
1014 {
1015 m_error = "no open file";
1016 return false;
1017 }
1018
1019 aSFVec2f.x = 0.0;
1020 aSFVec2f.y = 0.0;
1021
1022 size_t fileline = m_fileline;
1023 size_t linepos = m_bufpos;
1024
1025 while( true )
1026 {
1027 if( !EatSpace() )
1028 return false;
1029
1030 // if the text is the start of a comment block, clear the buffer and loop
1031 if( '#' == m_buf[m_bufpos] )
1032 m_buf.clear();
1033 else
1034 break;
1035 }
1036
1037 std::string tmp;
1038
1039 float tcol[2];
1040
1041 for( int i = 0; i < 2; ++i )
1042 {
1043 if( !ReadGlob( tmp ) )
1044 {
1045 std::ostringstream ostr;
1046 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1047 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1048 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1049 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1050 ostr << " * [INFO] " << m_error;
1051 m_error = ostr.str();
1052
1053 return false;
1054 }
1055
1056 std::istringstream istr;
1057 istr.str( tmp );
1058 istr >> tcol[i];
1059
1060 if( istr.fail() || !istr.eof() )
1061 {
1062 std::ostringstream ostr;
1063 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1064 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1065 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1066 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1067 ostr << " * [INFO] invalid character in space delimited pair";
1068 m_error = ostr.str();
1069
1070 return false;
1071 }
1072
1073 }
1074
1075 aSFVec2f.x = tcol[0];
1076 aSFVec2f.y = tcol[1];
1077
1078 return true;
1079}

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, and ReadGlob().

Referenced by ReadMFVec2f().

◆ ReadSFVec3f()

bool WRLPROC::ReadSFVec3f ( WRLVEC3F aSFVec3f)

Definition at line 1082 of file wrlproc.cpp.

1083{
1084 if( !m_file )
1085 {
1086 m_error = "no open file";
1087 return false;
1088 }
1089
1090 aSFVec3f.x = 0.0;
1091 aSFVec3f.y = 0.0;
1092 aSFVec3f.z = 0.0;
1093
1094 size_t fileline = m_fileline;
1095 size_t linepos = m_bufpos;
1096
1097 while( true )
1098 {
1099 if( !EatSpace() )
1100 return false;
1101
1102 // if the text is the start of a comment block, clear the buffer and loop
1103 if( '#' == m_buf[m_bufpos] )
1104 m_buf.clear();
1105 else
1106 break;
1107 }
1108
1109 std::string tmp;
1110
1111 float tcol[3];
1112
1113 for( int i = 0; i < 3; ++i )
1114 {
1115 if( !ReadGlob( tmp ) )
1116 {
1117 std::ostringstream ostr;
1118 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1119 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1120 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1121 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1122 ostr << " * [INFO] " << m_error;
1123 m_error = ostr.str();
1124
1125 return false;
1126 }
1127
1128 // ignore any commas
1129 if( !EatSpace() )
1130 return false;
1131
1132 if( ',' == m_buf[m_bufpos] )
1133 Pop();
1134
1135 std::istringstream istr;
1136 istr.str( tmp );
1137 istr >> tcol[i];
1138
1139 if( istr.fail() || !istr.eof() )
1140 {
1141 std::ostringstream ostr;
1142 ostr << __FILE__ << ":" << __FUNCTION__ << ":" << __LINE__ << "\n";
1143 ostr << " * [INFO] failed on file '" << m_filename << "'\n";
1144 ostr << " * [INFO] line " << fileline << ", char " << linepos << " -- ";
1145 ostr << "line " << m_fileline << ", char " << m_bufpos << "\n";
1146 ostr << " * [INFO] invalid character in space delimited triplet";
1147 m_error = ostr.str();
1148
1149 return false;
1150 }
1151
1152 }
1153
1154 aSFVec3f.x = tcol[0];
1155 aSFVec3f.y = tcol[1];
1156 aSFVec3f.z = tcol[2];
1157
1158 return true;
1159}

References EatSpace(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_filename, Pop(), and ReadGlob().

Referenced by WRL1TRANSFORM::Read(), WRL2BOX::Read(), WRL2INLINE::Read(), WRL2MATERIAL::Read(), WRL2TRANSFORM::Read(), ReadMFVec3f(), and ReadSFColor().

◆ ReadString()

bool WRLPROC::ReadString ( std::string &  aSFString)

Definition at line 612 of file wrlproc.cpp.

613{
614 // In VRML1 a string may be unquoted provided there are no space characters
615 // In VRML2 all strings must be quoted
616 aSFString.clear();
617
618 if( !m_file )
619 {
620 m_error = "no open file";
621 return false;
622 }
623
624 // remember the line number in case of errors
625 size_t ifline = m_fileline;
626
627 while( true )
628 {
629 if( !EatSpace() )
630 {
631 std::ostringstream ostr;
632 ostr << "invalid VRML file; expecting string at line " << ifline <<
633 " but found nothing";
634 m_error = ostr.str();
635
636 return false;
637 }
638
639 // if the text is the start of a comment block, clear the buffer and loop
640 if( '#' == m_buf[m_bufpos] )
641 m_buf.clear();
642 else
643 break;
644 }
645
647 {
648 m_error = "invalid VRML2 file (string not quoted)";
649 return false;
650 }
651
652 ifline = m_fileline;
653
654 if( '"' != m_buf[m_bufpos] )
655 {
656 if( !ReadGlob( aSFString ) )
657 {
658 std::ostringstream ostr;
659 ostr << "invalid VRML1 file at lines " << ifline << "--" << m_fileline;
660
661 if( !m_error.empty() )
662 ostr << " : " << m_error;
663
664 m_error = ostr.str();
665
666 return false;
667 }
668
669 return true;
670 }
671
672 bool isesc = false; // true if an escape character was found
673
674 while( true )
675 {
676 ++m_bufpos;
677
678 if( m_bufpos >= m_buf.size() )
679 {
680 aSFString.append( 1, '\n' );
681
682 if( !getRawLine() )
683 {
684 std::ostringstream ostr;
685 ostr << "invalid VRML1 file at lines " << ifline << "--" << m_fileline;
686 ostr << "; could not find end of string\n";
687 m_error = ostr.str();
688
689 return false;
690 }
691 }
692
693 if( '\\' == m_buf[m_bufpos] )
694 {
695 if( isesc )
696 {
697 aSFString.append( 1, '\n' );
698 isesc = false;
699 }
700 else
701 {
702 isesc = true;
703 }
704
705 continue;
706 }
707 else if( '"' == m_buf[m_bufpos] )
708 {
709 if( isesc )
710 aSFString.append( 1, '"' );
711 else
712 break;
713 }
714 else
715 {
716 aSFString.append( 1, m_buf[m_bufpos] );
717 }
718
719 // ensure that the backslash escape cannot extend beyond the first character
720 isesc = false;
721 }
722
723 ++m_bufpos;
724
725 return true;
726}

References EatSpace(), getRawLine(), m_buf, m_bufpos, m_error, m_file, m_fileline, m_fileVersion, ReadGlob(), and VRML_V2.

Referenced by DiscardList(), DiscardNode(), and ReadMFString().

Member Data Documentation

◆ m_badchars

std::string WRLPROC::m_badchars
private

Definition at line 116 of file wrlproc.h.

Referenced by ReadName(), and WRLPROC().

◆ m_buf

◆ m_bufpos

◆ m_eof

bool WRLPROC::m_eof
private

Definition at line 110 of file wrlproc.h.

Referenced by EatSpace(), eof(), getRawLine(), and WRLPROC().

◆ m_error

◆ m_file

◆ m_filedir

std::string WRLPROC::m_filedir
private

Definition at line 118 of file wrlproc.h.

Referenced by GetParentDir(), and WRLPROC().

◆ m_fileline

◆ m_filename

◆ m_fileVersion

WRLVERSION WRLPROC::m_fileVersion
private

Definition at line 114 of file wrlproc.h.

Referenced by getRawLine(), GetVRMLType(), ReadString(), and WRLPROC().


The documentation for this class was generated from the following files: