545 lines
19 KiB
C++
545 lines
19 KiB
C++
/*
|
|
Open Asset Import Library (assimp)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2017, assimp team
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the
|
|
following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
----------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file STEPFileReader.cpp
|
|
* @brief Implementation of the STEP file parser, which fills a
|
|
* STEP::DB with data read from a file.
|
|
*/
|
|
|
|
#include "STEPFileReader.h"
|
|
#include "STEPFileEncoding.h"
|
|
#include "TinyFormatter.h"
|
|
#include "fast_atof.h"
|
|
#include <memory>
|
|
|
|
|
|
using namespace Assimp;
|
|
namespace EXPRESS = STEP::EXPRESS;
|
|
|
|
#include <functional>
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
std::string AddLineNumber(const std::string& s,uint64_t line /*= LINE_NOT_SPECIFIED*/, const std::string& prefix = "")
|
|
{
|
|
return line == STEP::SyntaxError::LINE_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(line ",line,") ",s) );
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
std::string AddEntityID(const std::string& s,uint64_t entity /*= ENTITY_NOT_SPECIFIED*/, const std::string& prefix = "")
|
|
{
|
|
return entity == STEP::TypeError::ENTITY_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(entity #",entity,") ",s));
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
STEP::SyntaxError::SyntaxError (const std::string& s,uint64_t line /* = LINE_NOT_SPECIFIED */)
|
|
: DeadlyImportError(AddLineNumber(s,line))
|
|
{
|
|
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
STEP::TypeError::TypeError (const std::string& s,uint64_t entity /* = ENTITY_NOT_SPECIFIED */,uint64_t line /*= LINE_NOT_SPECIFIED*/)
|
|
: DeadlyImportError(AddLineNumber(AddEntityID(s,entity),line))
|
|
{
|
|
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream)
|
|
{
|
|
std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
|
|
std::unique_ptr<STEP::DB> db = std::unique_ptr<STEP::DB>(new STEP::DB(reader));
|
|
|
|
LineSplitter& splitter = db->GetSplitter();
|
|
if (!splitter || *splitter != "ISO-10303-21;") {
|
|
throw STEP::SyntaxError("expected magic token: ISO-10303-21",1);
|
|
}
|
|
|
|
HeaderInfo& head = db->GetHeader();
|
|
for(++splitter; splitter; ++splitter) {
|
|
const std::string& s = *splitter;
|
|
if (s == "DATA;") {
|
|
// here we go, header done, start of data section
|
|
++splitter;
|
|
break;
|
|
}
|
|
|
|
// want one-based line numbers for human readers, so +1
|
|
const uint64_t line = splitter.get_index()+1;
|
|
|
|
if (s.substr(0,11) == "FILE_SCHEMA") {
|
|
const char* sz = s.c_str()+11;
|
|
SkipSpaces(sz,&sz);
|
|
std::shared_ptr< const EXPRESS::DataType > schema = EXPRESS::DataType::Parse(sz);
|
|
|
|
// the file schema should be a regular list entity, although it usually contains exactly one entry
|
|
// since the list itself is contained in a regular parameter list, we actually have
|
|
// two nested lists.
|
|
const EXPRESS::LIST* list = dynamic_cast<const EXPRESS::LIST*>(schema.get());
|
|
if (list && list->GetSize()) {
|
|
list = dynamic_cast<const EXPRESS::LIST*>( (*list)[0].get() );
|
|
if (!list) {
|
|
throw STEP::SyntaxError("expected FILE_SCHEMA to be a list",line);
|
|
}
|
|
|
|
// XXX need support for multiple schemas?
|
|
if (list->GetSize() > 1) {
|
|
DefaultLogger::get()->warn(AddLineNumber("multiple schemas currently not supported",line));
|
|
}
|
|
const EXPRESS::STRING* string( nullptr );
|
|
if (!list->GetSize() || !(string=dynamic_cast<const EXPRESS::STRING*>( (*list)[0].get() ))) {
|
|
throw STEP::SyntaxError("expected FILE_SCHEMA to contain a single string literal",line);
|
|
}
|
|
head.fileSchema = *string;
|
|
}
|
|
}
|
|
|
|
// XXX handle more header fields
|
|
}
|
|
|
|
return db.release();
|
|
}
|
|
|
|
|
|
namespace {
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// check whether the given line contains an entity definition (i.e. starts with "#<number>=")
|
|
bool IsEntityDef(const std::string& snext)
|
|
{
|
|
if (snext[0] == '#') {
|
|
// it is only a new entity if it has a '=' after the
|
|
// entity ID.
|
|
for(std::string::const_iterator it = snext.begin()+1; it != snext.end(); ++it) {
|
|
if (*it == '=') {
|
|
return true;
|
|
}
|
|
if ((*it < '0' || *it > '9') && *it != ' ') {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
|
|
const char* const* types_to_track, size_t len,
|
|
const char* const* inverse_indices_to_track, size_t len2)
|
|
{
|
|
db.SetSchema(scheme);
|
|
db.SetTypesToTrack(types_to_track,len);
|
|
db.SetInverseIndicesToTrack(inverse_indices_to_track,len2);
|
|
|
|
const DB::ObjectMap& map = db.GetObjects();
|
|
LineSplitter& splitter = db.GetSplitter();
|
|
|
|
while (splitter) {
|
|
bool has_next = false;
|
|
std::string s = *splitter;
|
|
if (s == "ENDSEC;") {
|
|
break;
|
|
}
|
|
s.erase(std::remove(s.begin(), s.end(), ' '), s.end());
|
|
|
|
// want one-based line numbers for human readers, so +1
|
|
const uint64_t line = splitter.get_index()+1;
|
|
// LineSplitter already ignores empty lines
|
|
ai_assert(s.length());
|
|
if (s[0] != '#') {
|
|
DefaultLogger::get()->warn(AddLineNumber("expected token \'#\'",line));
|
|
++splitter;
|
|
continue;
|
|
}
|
|
// ---
|
|
// extract id, entity class name and argument string,
|
|
// but don't create the actual object yet.
|
|
// ---
|
|
const std::string::size_type n0 = s.find_first_of('=');
|
|
if (n0 == std::string::npos) {
|
|
DefaultLogger::get()->warn(AddLineNumber("expected token \'=\'",line));
|
|
++splitter;
|
|
continue;
|
|
}
|
|
|
|
const uint64_t id = strtoul10_64(s.substr(1,n0-1).c_str());
|
|
if (!id) {
|
|
DefaultLogger::get()->warn(AddLineNumber("expected positive, numeric entity id",line));
|
|
++splitter;
|
|
continue;
|
|
}
|
|
std::string::size_type n1 = s.find_first_of('(',n0);
|
|
if (n1 == std::string::npos) {
|
|
has_next = true;
|
|
bool ok = false;
|
|
for( ++splitter; splitter; ++splitter) {
|
|
const std::string& snext = *splitter;
|
|
if (snext.empty()) {
|
|
continue;
|
|
}
|
|
|
|
// the next line doesn't start an entity, so maybe it is
|
|
// just a continuation for this line, keep going
|
|
if (!IsEntityDef(snext)) {
|
|
s.append(snext);
|
|
n1 = s.find_first_of('(',n0);
|
|
ok = (n1 != std::string::npos);
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!ok) {
|
|
DefaultLogger::get()->warn(AddLineNumber("expected token \'(\'",line));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
std::string::size_type n2 = s.find_last_of(')');
|
|
if (n2 == std::string::npos || n2 < n1 || n2 == s.length() - 1 || s[n2 + 1] != ';') {
|
|
|
|
has_next = true;
|
|
bool ok = false;
|
|
for( ++splitter; splitter; ++splitter) {
|
|
const std::string& snext = *splitter;
|
|
if (snext.empty()) {
|
|
continue;
|
|
}
|
|
// the next line doesn't start an entity, so maybe it is
|
|
// just a continuation for this line, keep going
|
|
if (!IsEntityDef(snext)) {
|
|
s.append(snext);
|
|
n2 = s.find_last_of(')');
|
|
ok = !(n2 == std::string::npos || n2 < n1 || n2 == s.length() - 1 || s[n2 + 1] != ';');
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
if(!ok) {
|
|
DefaultLogger::get()->warn(AddLineNumber("expected token \')\'",line));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (map.find(id) != map.end()) {
|
|
DefaultLogger::get()->warn(AddLineNumber((Formatter::format(),"an object with the id #",id," already exists"),line));
|
|
}
|
|
|
|
std::string::size_type ns = n0;
|
|
do ++ns; while( IsSpace(s.at(ns)));
|
|
std::string::size_type ne = n1;
|
|
do --ne; while( IsSpace(s.at(ne)));
|
|
std::string type = s.substr(ns,ne-ns+1);
|
|
std::transform( type.begin(), type.end(), type.begin(), &Assimp::ToLower<char> );
|
|
const char* sz = scheme.GetStaticStringForToken(type);
|
|
if(sz) {
|
|
const std::string::size_type len = n2-n1+1;
|
|
char* const copysz = new char[len+1];
|
|
std::copy(s.c_str()+n1,s.c_str()+n2+1,copysz);
|
|
copysz[len] = '\0';
|
|
db.InternInsert(new LazyObject(db,id,line,sz,copysz));
|
|
}
|
|
if(!has_next) {
|
|
++splitter;
|
|
}
|
|
}
|
|
|
|
if (!splitter) {
|
|
DefaultLogger::get()->warn("STEP: ignoring unexpected EOF");
|
|
}
|
|
|
|
if ( !DefaultLogger::isNullLogger()){
|
|
DefaultLogger::get()->debug((Formatter::format(),"STEP: got ",map.size()," object records with ",
|
|
db.GetRefs().size()," inverse index entries"));
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
std::shared_ptr<const EXPRESS::DataType> EXPRESS::DataType::Parse(const char*& inout,uint64_t line, const EXPRESS::ConversionSchema* schema /*= NULL*/)
|
|
{
|
|
const char* cur = inout;
|
|
SkipSpaces(&cur);
|
|
if (*cur == ',' || IsSpaceOrNewLine(*cur)) {
|
|
throw STEP::SyntaxError("unexpected token, expected parameter",line);
|
|
}
|
|
|
|
// just skip over constructions such as IFCPLANEANGLEMEASURE(0.01) and read only the value
|
|
if (schema) {
|
|
bool ok = false;
|
|
for(const char* t = cur; *t && *t != ')' && *t != ','; ++t) {
|
|
if (*t=='(') {
|
|
if (!ok) {
|
|
break;
|
|
}
|
|
for(--t;IsSpace(*t);--t);
|
|
std::string s(cur,static_cast<size_t>(t-cur+1));
|
|
std::transform(s.begin(),s.end(),s.begin(),&ToLower<char> );
|
|
if (schema->IsKnownToken(s)) {
|
|
for(cur = t+1;*cur++ != '(';);
|
|
const std::shared_ptr<const EXPRESS::DataType> dt = Parse(cur);
|
|
inout = *cur ? cur+1 : cur;
|
|
return dt;
|
|
}
|
|
break;
|
|
}
|
|
else if (!IsSpace(*t)) {
|
|
ok = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (*cur == '*' ) {
|
|
inout = cur+1;
|
|
return std::make_shared<EXPRESS::ISDERIVED>();
|
|
}
|
|
else if (*cur == '$' ) {
|
|
inout = cur+1;
|
|
return std::make_shared<EXPRESS::UNSET>();
|
|
}
|
|
else if (*cur == '(' ) {
|
|
// start of an aggregate, further parsing is done by the LIST factory constructor
|
|
inout = cur;
|
|
return EXPRESS::LIST::Parse(inout,line,schema);
|
|
}
|
|
else if (*cur == '.' ) {
|
|
// enum (includes boolean)
|
|
const char* start = ++cur;
|
|
for(;*cur != '.';++cur) {
|
|
if (*cur == '\0') {
|
|
throw STEP::SyntaxError("enum not closed",line);
|
|
}
|
|
}
|
|
inout = cur+1;
|
|
return std::make_shared<EXPRESS::ENUMERATION>(std::string(start, static_cast<size_t>(cur-start) ));
|
|
}
|
|
else if (*cur == '#' ) {
|
|
// object reference
|
|
return std::make_shared<EXPRESS::ENTITY>(strtoul10_64(++cur,&inout));
|
|
}
|
|
else if (*cur == '\'' ) {
|
|
// string literal
|
|
const char* start = ++cur;
|
|
|
|
for(;*cur != '\'';++cur) {
|
|
if (*cur == '\0') {
|
|
throw STEP::SyntaxError("string literal not closed",line);
|
|
}
|
|
}
|
|
|
|
if (cur[1] == '\'') {
|
|
// Vesanen: more than 2 escaped ' in one literal!
|
|
do {
|
|
for(cur += 2;*cur != '\'';++cur) {
|
|
if (*cur == '\0') {
|
|
throw STEP::SyntaxError("string literal not closed",line);
|
|
}
|
|
}
|
|
}
|
|
while(cur[1] == '\'');
|
|
}
|
|
|
|
inout = cur + 1;
|
|
|
|
// assimp is supposed to output UTF8 strings, so we have to deal
|
|
// with foreign encodings.
|
|
std::string stemp = std::string(start, static_cast<size_t>(cur - start));
|
|
if(!StringToUTF8(stemp)) {
|
|
// TODO: route this to a correct logger with line numbers etc., better error messages
|
|
DefaultLogger::get()->error("an error occurred reading escape sequences in ASCII text");
|
|
}
|
|
|
|
return std::make_shared<EXPRESS::STRING>(stemp);
|
|
}
|
|
else if (*cur == '\"' ) {
|
|
throw STEP::SyntaxError("binary data not supported yet",line);
|
|
}
|
|
|
|
// else -- must be a number. if there is a decimal dot in it,
|
|
// parse it as real value, otherwise as integer.
|
|
const char* start = cur;
|
|
for(;*cur && *cur != ',' && *cur != ')' && !IsSpace(*cur);++cur) {
|
|
if (*cur == '.') {
|
|
double f;
|
|
inout = fast_atoreal_move<double>(start,f);
|
|
return std::make_shared<EXPRESS::REAL>(f);
|
|
}
|
|
}
|
|
|
|
bool neg = false;
|
|
if (*start == '-') {
|
|
neg = true;
|
|
++start;
|
|
}
|
|
else if (*start == '+') {
|
|
++start;
|
|
}
|
|
int64_t num = static_cast<int64_t>( strtoul10_64(start,&inout) );
|
|
return std::make_shared<EXPRESS::INTEGER>(neg?-num:num);
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
std::shared_ptr<const EXPRESS::LIST> EXPRESS::LIST::Parse(const char*& inout,uint64_t line, const EXPRESS::ConversionSchema* schema /*= NULL*/)
|
|
{
|
|
const std::shared_ptr<EXPRESS::LIST> list = std::make_shared<EXPRESS::LIST>();
|
|
EXPRESS::LIST::MemberList& members = list->members;
|
|
|
|
const char* cur = inout;
|
|
if (*cur++ != '(') {
|
|
throw STEP::SyntaxError("unexpected token, expected \'(\' token at beginning of list",line);
|
|
}
|
|
|
|
// estimate the number of items upfront - lists can grow large
|
|
size_t count = 1;
|
|
for(const char* c=cur; *c && *c != ')'; ++c) {
|
|
count += (*c == ',' ? 1 : 0);
|
|
}
|
|
|
|
members.reserve(count);
|
|
|
|
for(;;++cur) {
|
|
if (!*cur) {
|
|
throw STEP::SyntaxError("unexpected end of line while reading list");
|
|
}
|
|
SkipSpaces(cur,&cur);
|
|
if (*cur == ')') {
|
|
break;
|
|
}
|
|
|
|
members.push_back( EXPRESS::DataType::Parse(cur,line,schema));
|
|
SkipSpaces(cur,&cur);
|
|
|
|
if (*cur != ',') {
|
|
if (*cur == ')') {
|
|
break;
|
|
}
|
|
throw STEP::SyntaxError("unexpected token, expected \',\' or \')\' token after list element",line);
|
|
}
|
|
}
|
|
|
|
inout = cur+1;
|
|
return list;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
STEP::LazyObject::LazyObject(DB& db, uint64_t id,uint64_t /*line*/, const char* const type,const char* args)
|
|
: id(id)
|
|
, type(type)
|
|
, db(db)
|
|
, args(args)
|
|
, obj()
|
|
{
|
|
// find any external references and store them in the database.
|
|
// this helps us emulate STEPs INVERSE fields.
|
|
if (db.KeepInverseIndicesForType(type)) {
|
|
const char* a = args;
|
|
|
|
// do a quick scan through the argument tuple and watch out for entity references
|
|
int64_t skip_depth = 0;
|
|
while(*a) {
|
|
if (*a == '(') {
|
|
++skip_depth;
|
|
}
|
|
else if (*a == ')') {
|
|
--skip_depth;
|
|
}
|
|
|
|
if (skip_depth >= 1 && *a=='#') {
|
|
const char* tmp;
|
|
const int64_t num = static_cast<int64_t>( strtoul10_64(a+1,&tmp) );
|
|
db.MarkRef(num,id);
|
|
}
|
|
++a;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
STEP::LazyObject::~LazyObject()
|
|
{
|
|
// make sure the right dtor/operator delete get called
|
|
if (obj) {
|
|
delete obj;
|
|
}
|
|
else delete[] args;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void STEP::LazyObject::LazyInit() const
|
|
{
|
|
const EXPRESS::ConversionSchema& schema = db.GetSchema();
|
|
STEP::ConvertObjectProc proc = schema.GetConverterProc(type);
|
|
|
|
if (!proc) {
|
|
throw STEP::TypeError("unknown object type: " + std::string(type),id);
|
|
}
|
|
|
|
const char* acopy = args;
|
|
std::shared_ptr<const EXPRESS::LIST> conv_args = EXPRESS::LIST::Parse(acopy,STEP::SyntaxError::LINE_NOT_SPECIFIED,&db.GetSchema());
|
|
delete[] args;
|
|
args = NULL;
|
|
|
|
// if the converter fails, it should throw an exception, but it should never return NULL
|
|
try {
|
|
obj = proc(db,*conv_args);
|
|
}
|
|
catch(const TypeError& t) {
|
|
// augment line and entity information
|
|
throw TypeError(t.what(),id);
|
|
}
|
|
++db.evaluated_count;
|
|
ai_assert(obj);
|
|
|
|
// store the original id in the object instance
|
|
obj->SetID(id);
|
|
}
|
|
|