SoInput.h

/*=======================================================================
 * Copyright 1991-1996, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
**=======================================================================*/
/*=======================================================================
** Author      : Paul S. Strauss (MMM yyyy)
**=======================================================================*/
/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2022 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef _SO_INPUT_
#define _SO_INPUT_
 
#include <Inventor/misc/SoBasic.h>
#include <Inventor/SbDict.h>
#include <Inventor/SbPList.h>
#include <Inventor/SbString.h>
#include <Inventor/SoDB.h>
#include <Inventor/threads/SbThreadMutex.h>
#include <Inventor/threads/SbThreadSpinlock.h>
 
#include <Inventor/STL/fstream>
#include <Inventor/STL/iostream>
#include <Inventor/STL/list>
#include <Inventor/STL/vector>
#include <Inventor/STL/map>
 
#if defined(_WIN32)
#pragma warning( push )
#pragma warning( disable: 4251 ) // 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
#endif
 
 
class SoNode;
class SoPath;
class SoBase;
class SoDB;
class SbStringList;
class SoInputImpl;
class SoStreamBuffer;
class SbThreadSignal;
class SoInputParameters;
 
#ifndef HIDDEN_FROM_DOC
//
// Structure: SoInputFile (internal)
//
// This structure holds info about an opened file for use in the SoInput
// class.
//
// One of the items is a dictionary that correlates reference names
// in files to nodes and paths (SoBase instances).
//
 
 
{
  // Name of file
  SbString name;
  // Name of file with full path
  SbString fullName;
  // File pointer
  FILE *fp;
  // ZCompressed file pointer
  void* zFp;
  // Buffer to read from (or NULL)
  void *buffer;
  // TRUE if buffer is created internally
  SbBool bufferOwnership;
  // Current location in buffer
  char *curBuf;
  // Buffer size
  size_t bufSize;
  // Number of line currently reading
  int lineNum;
  // TRUE if opened by SoInput
  SbBool openedHere;
#ifdef _WIN32
  // TRUE if opened from handle
  SbBool openedFromHandle;
#endif
  // TRUE if file has binary data
  SbBool binary;
  // TRUE if file uses UTF8 incoding
  SbBool utf8;
  // True if file is compressed using zlib
  SbBool zCompressed;
  // TRUE if current platform endianness is big endian
  SbBool isBigEndian;
  // TRUE if the file is streamed
  SbBool isStreamed;
  // Number of buffers used for the streaming process
  int streamedBuffersNumber;
  // Size of a streamBuffer;
  int streamedBuffersSize;
  // Size of the file in bytes
  long long fileSize;
  // TRUE if header was checked for A/B
  SbBool readHeader;
  // TRUE if header was read ok
  bool headerOk;
  // Node/path reference dictionary
  SbDict *refDict;
  // TRUE if dict from another SoInput
  SbBool borrowedDict;
  // Version if standard Inventor file;
  float ivVersion;
  // The header string of the input file
  SbString headerString;
  // CB to be called after reading file
  SoDBHeaderCB *postReadCB;
  // User data to pass to the postReadCB
  void *CBData;
  // Too complex for inlining
  SoInputFile();
};
 
 
{
};
 
#endif // HIDDEN_FROM_DOC
 
//
// Class: SoInput
//
// This file contains the definition of the SoInput (input stream)
// class. This class is used for reading Inventor data files; it
// supports both ASCII (default) and binary formats. It skips over
// Inventor comments (from '#' to end of line) and can stack input
// files when file inclusion is encountered; when EOF is reached, the
// stack is popped. Both the ASCII and binary formats can be compressed
// using the gz format (e.g: Using gzip). The file extension for compressed files is 'ivz' but it's
// not mandatory, the gz header is checked when the file is opened in order
// to figure out if it is compressed or not. This feature uses the module IvDLZlib.
//
// Another feature is file opening. This will open a named file,
// looking for it in any of several user-specified directories.
// Alternatively, the caller can specify a buffer in memory (and its
// size) to read from. The specified filenames can contain variables
// which are replaced by SoInput using SoPreferences. The variables must
// follow the usual $name format. (e.g: $OIVHOME).
//
//
// SoInput also contains a dictionary that correlates node and path
// pointers to temporary names written to files. This is so
// references to previously defined nodes and paths are written
// correctly.
//
 
class  SoInput
{
 
 public:
 
  SoInput();
 
  virtual ~SoInput();
 
  SoNONUNICODE static void addDirectoryFirst(const char *dirName);
 
 
  static void addDirectoryFirst( const SbString& dirName );
 
  SoNONUNICODE static void addDirectoryLast(const char *dirName);
 
  static void addDirectoryLast( const SbString& dirName );
 
#define DIRECTORIES_SEPARATOR ":;"
  SoNONUNICODE static void addEnvDirectoriesFirst(const char *envVarName,
                                     const char *dirSep = DIRECTORIES_SEPARATOR);
 
  static void addEnvDirectoriesFirst(const SbString& envVarName,
                                     const SbString& dirSep = DIRECTORIES_SEPARATOR);
 
  SoNONUNICODE static void addEnvDirectoriesLast(const char *envVarName,
                                    const char *dirSep = DIRECTORIES_SEPARATOR);
 
  static void addEnvDirectoriesLast(const SbString& envVarName,
                                    const SbString& dirSep = DIRECTORIES_SEPARATOR);
 
  SoNONUNICODE static void removeDirectory(const char *dirName);
 
  static void removeDirectory( const SbString& dirName );
 
  static void clearDirectories();
 
  static const SbStringList &getDirectories();
 
 
  virtual void setFilePointer(FILE *newFP);
 
  virtual FILE* getFilePointer();
 
  SoNONUNICODE virtual SbBool openFile(const char *fileName, SbBool okIfNotFound = FALSE, SbBool aSync = FALSE);
 
  virtual SbBool openFile( const SbString& fileName, SbBool okIfNotFound = FALSE, SbBool aSync = FALSE);
 
  SoNONUNICODE virtual SbBool pushFile(const char *fileName);
 
  virtual SbBool pushFile( const SbString& fileName );
 
  virtual void closeFile();
 
  virtual SbBool isValidFile();
 
  virtual SbBool isValidBuffer();
 
  virtual FILE *getCurFile() const;
 
  SoNONUNICODE virtual const char *getCurFileName() const;
 
  virtual SbString getCurStringFileName() const;
 
  virtual void setBuffer(void *buffer, size_t bufSize);
 
  virtual int getNumBytesRead() const;
 
  virtual SbString getHeader();
 
  virtual float getIVVersion() { return curFile->ivVersion; }
 
  virtual void updateReadPercent( double readPercentage );
 
  static SbBool findAbsolutePath( const SbString& fileName, SbString &fullName );
 
 
  void setInputParameters( SoInputParameters* parameters);
 
  SoInputParameters* getInputParameters() const;
 
private:
 
  // Returns whether current file/buffer being read is binary
  virtual SbBool isBinary();
 
  // Returns whether current file/buffer being read uses utf8 encoding
  virtual SbBool isUtf8();
 
  // Returns whether current file/buffer is compressed using ZLIB
  virtual SbBool isZCompressed();
 
  // Reads next character from current file/buffer. Returns FALSE on
  // EOF or error.
  virtual SbBool get(char &c);
 
  // Reads next ASCII character from current buffer. Returns FALSE on
  // EOF or error.
  virtual SbBool getASCIIBuffer(char &c);
 
  // Reads next ASCII character from current file. Returns FALSE on
  // EOF or error.
  virtual SbBool getASCIIFile(char &c);
 
  // Reads item of particular type from current file pointer/buffer. All
  // skip white space before reading and return FALSE on EOF or if
  // item could not be read.
  virtual SbBool read(char &c);
  virtual SbBool readByte(char &c);
  virtual SbBool readByte(unsigned char &c);
  virtual SbBool read(SbString &s);
  virtual SbBool read(SbName &n, SbBool validIdent = FALSE);
  virtual SbBool readBitMask(SbName &n, SbBool validIdent = FALSE);
  virtual SbBool read(bool &i);
  virtual SbBool read(int32_t &i);
  virtual SbBool read(int64_t &i);
  virtual SbBool read(uint32_t &i);
  virtual SbBool read(uint64_t &i);
  virtual SbBool read(short &s);
  virtual SbBool read(unsigned short &s);
  virtual SbBool read(float &f);
  virtual SbBool read(double &d);
  virtual SbBool readBinaryArray(unsigned char *c, int length);
  virtual SbBool readBinaryArray(int32_t *l, int length);
  virtual SbBool readBinaryArray(int64_t *l, int length);
  virtual SbBool readBinaryArray(float *f, int length);
  virtual SbBool readBinaryArray(short *s, int length);
  virtual SbBool readBinaryArray(double *d, int length);
 
  // Returns TRUE if current file/buffer is at EOF
  virtual SbBool eof() const;
 
  // This read does not skip whiteSpace. It's used to read a PROTO into
  // the buffer. The second argument is just to differentiate the two
  // character reads.
  virtual SbBool read(char &c, SbBool skip);
 
  // Returns TRUE if current header is VRML V2.0
  SbBool isFileVRML2();
 
  // Sets the vrmlFile flag. This is necessary for
  // SoFieldData::readFieldDescriptions for UnKnownNodes to temporarily i
  // turn off the flag so Inventor extension nodes field descriptions will
  // read in correctly. They assume that the comma is between the fields
  // but in VRML2, commas are whitespace.
  void setFileVRML2(SbBool flag);
 
  // Returns 0 for Inventor, 2 for VRML2.0 and 3 for VRML 3.0
  int  getVRMLVersion() { return vrmlFile; }
 
  // Sets the vrmlFile flag. This is necessary for
  // SoFieldData::readFieldDescriptions for UnKnownNodes to temporarily i
  // turn off the flag so Inventor extension nodes field descriptions will
  // read in correctly. They assume that the comma is between the fields
  // but in VRML2, commas are whitespace.
  void setVRMLVersion(int flag) { vrmlFile = flag; }
 
#ifdef _WIN32
  // Returns the file name from its handle.
  SbString getFileNameFromHandle( HANDLE hFile ) const;
 
  virtual SbBool openFromHandle( UINT hFile, SbBool okIfNotFound = FALSE, SbBool aSync = FALSE );
#endif
 
 private:
 
  // Init function sets up global directory list
  static void init();
  static void finish();
 
  // Constructor that gets reference dictionary from another SoInput
  SoInput(SoInput *dictIn);
 
  // Fills in passed string to contain description of current
  // location in all open input files
  virtual void getLocationString(SbString &string) const;
 
  // Puts a just-read character or string back in input stream/buffer
  virtual void putBack(char c);
  virtual void putBack(const char *string);
 
  // Adds a reference to dictionary in current file. This may also
  // add a reference to the global dictionary if addToGlobalDict is
  // TRUE (the default).
  virtual void addReference(const SbName &name, SoBase *base,
                            SbBool addToGlobalDict = TRUE);
 
  // Removes a reference to dictionary in current file. This may
  // also remove a reference from the global dictionary.
  virtual void removeReference(const SbName &name);
 
  // Looks up a reference, returning the base pointer or NULL
  virtual SoBase * findReference(const SbName &name) const;
 
  virtual void resetFilePointer(FILE *fptr) { curFile->fp = fptr;}
 
  virtual SbBool readLargeBinaryArray(unsigned char *c, size_t length);
 
  SoInputImpl* m_soInputImpl;
 
  // find absolute path of a file return TRUE if found
  // and the absolute found path in fullName
  //
  // @UNICODE_WARNING
  //
  SoNONUNICODE static SbBool findAbsolutePath( const char* fileName, const SbStringList *some_dir, SbString &fullName );
 
 
  // find absolute path of a file return TRUE if found
  // and the absolute found path in fullName
  //
  static SbBool findAbsolutePath( const SbString& fileName, const SbStringList *some_dir, SbString &fullName );
 
  int32_t isReadingBinArrayAsMemObj() const;
 
  // Adds/subtracts the new value to/from the number of read bytes. Useful when an fseek is done on the
  // currently opened file in order to keep m_numReadBytes up to date (i.e. reading PROTO of vrml files).
  void updateNumReadBytes( int value);
 
  // Set the Inventor version number of the current file
  void setIVVersion(float version) { curFile->ivVersion = version; }
  bool isHeaderOk() { return curFile->headerOk; }
 
  void seekCurBuf( size_t size ) { curFile->curBuf += size; updateNumReadBytes(static_cast<int>(size) ); }
 
  static bool readTextFile(const SbString& filename, SbString& dest);
 
  static bool addInMemoryTextFile(const SbString& filename, const SbString& fileContent);
 
  static bool removeInMemoryTextFile(const SbString& filename);
 
  static bool isInMemoryTextFile(const SbString& filename);
 
  long fileTell();
 
  int fileSeek( long offset, int whence );
 
  bool isReadByPlugin();
 
  SbBool isReadingHeader();
 
 private:
 
  // Directory search path.
  static void setDirectories(SbStringList *dir);
  // Stack of SoInputFiles (depth >=1)
  SbPList files;
  // Top of stack
  struct SoInputFile *curFile;
  // For strings that are put back
  SbString backBuf;
  // Index into backBuf (-1 if no buf)
  int backBufIndex;
 
  // Buffer for binary read from file
  void *tmpBuffer;
  // Current location in temporary buffer
  char *curTmpBuf;
  // Size of temporary buffer
  size_t tmpBufSize;
 
  // Buffer for storing data that
  // has been read but can't be put back.
  char backupBuf[8];
  // True if backupBuf contains data
  SbBool backupBufUsed;
  // Contains char that were put back in the stream in ascii mode.
  std::vector<char> putBackCharBuffer;
 
  // Looks for named file and opens it. Returns NULL if not found.
  FILE *findFile(const SbString& fileName, SbString &fullName);
 
  // Initializes reading from file
  void initFile(FILE *newFP, const SbString& fileName,
                SbString *fullName, SbBool openedHere,
                SbDict *refDict = NULL);
 
  // Initializes streamed reading from file
  void initStreamedFile( FILE* newFP, const SbString& fileName, SbString* fullName, SbBool openedHere,
                         SbDict* refDict = NULL );
 
#ifdef _WIN32
  FILE *findFromHandle(int nHandle) const;
 
  void initFromHandle(FILE *newFP,
                      int nHandle, SbBool openedHere,
                      SbDict *refDict = NULL);
#endif
 
  // Checks current Inventor/VRML file for ASCII/binary header comment.
  // Returns FALSE if no header was found.
  SbBool checkInventorHeader(SbBool bValidateBufferHeader=FALSE);
 
  // Checks current file for ASCII/binary header comment. Returns
  // FALSE if no header was found.
  SbBool checkHeader(SbBool bValidateBufferHeader=FALSE);
 
  // Returns TRUE if reading from memory buffer rather than file
  SbBool fromBuffer() const { return (curFile->buffer != NULL); }
 
  // Skips over white space in input. Pops file if EOF is hit.
  // Returns FALSE on error.
  SbBool skipWhiteSpace();
 
  // Pops current file from stack, if possible.
  SbBool popFile();
 
  // Returns number of bytes left in current buffer
  size_t freeBytesInBuf() const
  { return (curFile->bufSize - (curFile->curBuf - static_cast<char *>(curFile->buffer) )); }
 
  // Reads integer, unsigned integer, or floating-point number.
  // Returns FALSE on EOF or error
  SbBool readInteger(int32_t &l);
  SbBool readUnsignedInteger(uint32_t &l);
  SbBool readInteger(int64_t &l);
  SbBool readUnsignedInteger(uint64_t &l);
  SbBool readReal(double &d);
 
  // Reads next ASCII format hex value from current file/buffer.
  // Returns FALSE on EOF or error.
  virtual SbBool readHex(uint32_t &l);
 
  // Reads unsigned integer string into str. Accepts decimal, octal,
  // and hex integers. Returns FALSE on EOF or error
  SbBool readUnsignedIntegerString(char *str);
 
  // Reads string of decimal or hexadecimal digits into string.
  // Returns number of bytes read.
  int readDigits(char *string);
  int readHexDigits(char *string);
 
  // Reads given character from buffer into string. Returns 0 or 1
  int readChar(char *string, char charToRead);
 
  // Make room in the temporary buffer for reading from a binary file
  SbBool makeRoomInBuf(size_t nBytes);
 
  // Convert datatypes to network format during writing
  void convertShort(char *from, short *s);
  void convertInt32(char *from, int32_t *l);
  void convertInt64(char *from, int64_t *l);
  void convertFloat(char *from, float *f);
  void convertDouble(char *from, double *d);
  void convertShortArray(char *from, short *to, size_t len);
  void convertInt32Array(char *from, int32_t *to, size_t len);
  void convertInt64Array(char *from, int64_t *to, size_t len);
  void convertFloatArray(char *from, float *to, size_t len);
  void convertDoubleArray(char *from, double *to, size_t len);
 
  SbString bufferToString( const char* buffer );
 
  size_t fileRead( void* ptr, size_t size, size_t count );
 
  int fileReadByte();
 
  static SbBool checkFileCompression( FILE* file, int64_t& fileSize, SbBool& isCompressed );
  static SbBool checkFileCompression( unsigned char byte1, unsigned char byte2 );
 
  // deprecated
  void convertShortArray(char *from, short *to, int len);
  void convertInt32Array(char *from, int32_t *to, int len);
  void convertFloatArray(char *from, float *to, int len);
  void convertDoubleArray(char *from, double *to, int len);
 
  int vrmlFile;
 
//  friend class SoBase;
//  friend class SoDB;
 
 private:
 
   SoInputParameters*  m_inputParameters;
 
  // Directory search path.
  static SbStringList *directories;
  static SbString *defaultString;
 
  // Callback put in a thread to fill-in the stack of streamed buffers.
  static void* streamingStackCB( void* data );
 
  void commonInit();
 
  // Method called when the current streamed buffer is read and needed to be swapped
  void swapStreamBuffer();
  // Methods called for binary files when there's not enough available space in the buffer to read the type
  char* getType( char* from, size_t sizeOfType, size_t freeBytes );
  char* getLongType( char* from, size_t sizeOfType, size_t freeBytes );
 
  static std::list<SoStreamBuffer*>* m_streamBufStack; // Streamed buffers stack
  // Synchronization between app thread and streaming thread
  static SbThreadSignal* m_availableSig; // Used to signal the app thread that a buffer has been pushed in the stack
  static SbThreadMutex* m_availableSigMutex;
  static SbThreadSignal* m_stackFillSig; // Used to signal the callback thread that a buffer has been popped out of the stack
  static SbThreadMutex* m_stackFillSigMutex;
  static SbThreadMutex* m_stackMutex; // Used when accessing in the stack.
  static SbThreadMutex m_directoriesMutex; // Used when accessing in the directories list.
  SbThread* m_stackThread;
 
  int64_t m_numReadBytes;
 
  // Progress bar for debug purposes only!
  int m_percent, m_progress, m_prevProgressVal, m_prevPercentVal;
  double m_result;
  std::string m_progressBar;
 
  // manage in memory text file for readTextFile method (filename,fileContent)
  typedef std::map<SbString, SbString> InMemoryTextFileMap;
  static InMemoryTextFileMap s_InMemoryTextFileMap;
  static SbThreadSpinlock s_InMemoryTextFileMapMutex;
  static SbBool s_InMemoryTextFileEnabled;
 
  // manage zlib buffer uncompressing
  SbBool uncompressZData(const void *src, size_t srcLen, void*& dst, size_t& dstLen);
  int inflateZData(const void *src, size_t srcLen, void *dst, size_t dstLen);
 
};
 
#if defined(_WIN32)
#pragma warning( pop )
#endif
 
#endif /* _SO_INPUT_ */