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();
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
unsigned int m_bufpos
Definition: wrlproc.h:112
std::string m_filedir
Definition: wrlproc.h:118
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_badchars
Definition: wrlproc.h:116
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool m_eof
Definition: wrlproc.h:110
#define GETLINE
Definition: wrlproc.cpp:32
WRLVERSION m_fileVersion
Definition: wrlproc.h:114

References 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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool ReadString(std::string &aSFString)
Definition: wrlproc.cpp:612
const wxChar *const traceVrmlPlugin
Flag to enable VRML plugin trace output.
Definition: vrml.cpp:63
bool EatSpace(void)
Definition: wrlproc.cpp:191

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 
202 RETRY:
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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
bool m_eof
Definition: wrlproc.h:110
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()

std::string WRLPROC::GetFileName ( void  )

Definition at line 1995 of file wrlproc.cpp.

1996 {
1997  if( !m_file )
1998  {
1999  m_error = "no open file";
2000  return "";
2001  }
2002 
2003  return std::string( m_file->GetSource().ToUTF8() );
2004 }
virtual const wxString & GetSource() const
Returns the name of the source of the lines in an abstract sense.
Definition: richio.h:109
LINE_READER * m_file
Definition: wrlproc.h:108
std::string m_error
Definition: wrlproc.h:115

References LINE_READER::GetSource(), m_error, and m_file.

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

◆ 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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111

References m_bufpos, m_file, and m_fileline.

Referenced by WRL2TRANSFORM::Read().

◆ GetFilePosition()

std::string WRLPROC::GetFilePosition ( ) const

◆ 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 }
std::string m_filedir
Definition: wrlproc.h:118

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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
bool m_eof
Definition: wrlproc.h:110
#define GETLINE
Definition: wrlproc.cpp:32
WRLVERSION m_fileVersion
Definition: wrlproc.h:114

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 }
WRLVERSION m_fileVersion
Definition: wrlproc.h:114

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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
bool EatSpace(void)
Definition: wrlproc.cpp:191

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

Referenced by WRL1GROUP::Read(), WRL1SWITCH::Read(), WRL2INLINE::Read(), WRL2MATERIAL::Read(), WRL1TRANSFORM::Read(), WRL2SHAPE::Read(), WRL2APPEARANCE::Read(), WRL1SEPARATOR::Read(), WRL2BOX::Read(), WRL1MATBINDING::Read(), WRL1SHAPEHINTS::Read(), WRL2SWITCH::Read(), WRL2TRANSFORM::Read(), WRL2FACESET::Read(), WRL2LINESET::Read(), WRL1FACESET::Read(), WRL2NORMS::Read(), WRL2POINTSET::Read(), WRL2COLOR::Read(), WRL2COORDS::Read(), WRL1MATERIAL::Read(), WRL1COORDS::Read(), WRL1BASE::Read(), WRL2TRANSFORM::readChildren(), and WRL2SWITCH::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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
bool EatSpace(void)
Definition: wrlproc.cpp:191

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
glm::vec3 WRLVEC3F
Definition: wrltypes.h:188
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool ReadSFColor(WRLVEC3F &aSFColor)
Definition: wrlproc.cpp:774
bool EatSpace(void)
Definition: wrlproc.cpp:191

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 }
void Pop(void)
Definition: wrlproc.cpp:2035
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
bool ReadSFFloat(float &aSFFloat)
Definition: wrlproc.cpp:806
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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 }
void Pop(void)
Definition: wrlproc.cpp:2035
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool ReadSFInt(int &aSFInt32)
Definition: wrlproc.cpp:867
bool EatSpace(void)
Definition: wrlproc.cpp:191

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

Referenced by WRL1FACESET::Read(), WRL2LINESET::Read(), and WRL2FACESET::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
void Pop(void)
Definition: wrlproc.cpp:2035
unsigned int m_bufpos
Definition: wrlproc.h:112
glm::vec4 WRLROTATION
Definition: wrltypes.h:189
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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 }
void Pop(void)
Definition: wrlproc.cpp:2035
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
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, 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 }
void Pop(void)
Definition: wrlproc.cpp:2035
unsigned int m_bufpos
Definition: wrlproc.h:112
glm::vec2 WRLVEC2F
Definition: wrltypes.h:187
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool ReadSFVec2f(WRLVEC2F &aSFVec2f)
Definition: wrlproc.cpp:1011
bool EatSpace(void)
Definition: wrlproc.cpp:191

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 }
void Pop(void)
Definition: wrlproc.cpp:2035
glm::vec3 WRLVEC3F
Definition: wrltypes.h:188
bool ReadSFVec3f(WRLVEC3F &aSFVec3f)
Definition: wrlproc.cpp:1082
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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

Referenced by WRL2COLOR::Read(), WRL2NORMS::Read(), WRL2COORDS::Read(), WRL1COORDS::Read(), and WRL1MATERIAL::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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_badchars
Definition: wrlproc.h:116
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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(), WRL1SWITCH::Read(), WRL2INLINE::Read(), WRL1TRANSFORM::Read(), WRL2MATERIAL::Read(), WRL2APPEARANCE::Read(), WRL2SHAPE::Read(), WRL2BOX::Read(), WRL2SWITCH::Read(), WRL1SHAPEHINTS::Read(), WRL2TRANSFORM::Read(), WRL1MATBINDING::Read(), WRL2COLOR::Read(), WRL1FACESET::Read(), WRL2NORMS::Read(), WRL2POINTSET::Read(), WRL2LINESET::Read(), WRL2FACESET::Read(), WRL2COORDS::Read(), WRL1MATERIAL::Read(), WRL1COORDS::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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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 }
bool ReadSFVec3f(WRLVEC3F &aSFVec3f)
Definition: wrlproc.cpp:1082
unsigned int m_bufpos
Definition: wrlproc.h:112
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_filename
Definition: wrlproc.h:117

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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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

Referenced by WRL2MATERIAL::Read(), WRL1SHAPEHINTS::Read(), WRL2FACESET::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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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 }
void Pop(void)
Definition: wrlproc.cpp:2035
unsigned int m_bufpos
Definition: wrlproc.h:112
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
std::string m_filename
Definition: wrlproc.h:117
bool EatSpace(void)
Definition: wrlproc.cpp:191

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

Referenced by WRL1TRANSFORM::Read(), WRL2BOX::Read(), WRL2MATERIAL::Read(), WRL2INLINE::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 
646  if( WRLVERSION::VRML_V2 == m_fileVersion && '"' != m_buf[m_bufpos] )
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 }
unsigned int m_bufpos
Definition: wrlproc.h:112
bool ReadGlob(std::string &aGlob)
Definition: wrlproc.cpp:245
LINE_READER * m_file
Definition: wrlproc.h:108
unsigned int m_fileline
Definition: wrlproc.h:111
std::string m_error
Definition: wrlproc.h:115
std::string m_buf
Definition: wrlproc.h:109
bool EatSpace(void)
Definition: wrlproc.cpp:191
bool getRawLine(void)
Definition: wrlproc.cpp:142
WRLVERSION m_fileVersion
Definition: wrlproc.h:114

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: