static void parseHostStrings( JSON::Entity const &entity, HostStrings &result )
{
if ( entity.isString() )
{
HostSpec hostSpec;
hostSpec.push_back( "*" );
result.insert( HostStrings::value_type( entity.stringToStdString(), hostSpec ) );
}
else if ( entity.isObject() )
{
JSON::ObjectDecoder objectDecoder( entity );
JSON::Entity keyString, valueEntity;
while ( objectDecoder.getNext( keyString, valueEntity ) )
{
try
{
HostSpec hostSpec = parseHostSpec( valueEntity );
result.insert( HostStrings::value_type( keyString.stringToStdString(), hostSpec ) );
}
catch ( Exception e )
{
objectDecoder.rethrow( e );
}
}
}
else throw Exception( "must be a string or an object" );
}
void ResourceLoadNode::jsonExecCreate(
JSON::Entity const &arg,
RC::Handle<Context> const &context,
JSON::ArrayEncoder &resultArrayEncoder
)
{
arg.requireString();
Create( arg.stringToStdString(), context );
}
void ValueProducerWrapper::jsonExec(
JSON::Entity const &cmd,
JSON::Entity const &arg,
JSON::ArrayEncoder &resultArrayEncoder
)
{
if ( cmd.stringIs( "produce", 7 ) )
jsonExecProduce( arg, resultArrayEncoder );
else if ( cmd.stringIs( "produceAsync", 12 ) )
jsonExecProduceAsync( arg, resultArrayEncoder );
else if ( cmd.stringIs( "flush", 5 ) )
jsonExecFlush( arg, resultArrayEncoder );
else ProducerWrapper::jsonExec( cmd, arg, resultArrayEncoder );
}
static void parseHostStringsVector( JSON::Entity const &entity, HostStringsVector &result )
{
if ( entity.isArray() )
{
JSON::ArrayDecoder arrayDecoder( entity );
JSON::Entity elementEntity;
while ( !arrayDecoder.getNext( elementEntity ) )
{
try
{
HostStrings hostStrings;
parseHostStrings( elementEntity, hostStrings );
result.push_back( hostStrings );
}
catch ( Exception e )
{
arrayDecoder.rethrow( e );
}
}
}
else
{
HostStrings hostStrings;
parseHostStrings( entity, hostStrings );
result.push_back( hostStrings );
}
}
void SlicedArrayImpl::decodeJSON( JSON::Entity const &entity, void *data ) const
{
entity.requireArray();
bits_t *dstBits = reinterpret_cast<bits_t *>(data);
if ( entity.value.array.size != dstBits->size )
throw Exception( "JSON array size must equal sliced array size" );
size_t membersFound = 0;
JSON::ArrayDecoder arrayDecoder( entity );
JSON::Entity elementEntity;
while ( arrayDecoder.getNext( elementEntity ) )
{
FABRIC_ASSERT( membersFound < entity.value.array.size );
try
{
void *memberData = (void*)m_variableArrayImpl->getImmutableMemberData_NoCheck( &dstBits->rcva->varArray, dstBits->offset + membersFound );
m_memberImpl->decodeJSON( elementEntity, memberData );
}
catch ( Exception e )
{
throw _(membersFound) + ": " + e;
}
++membersFound;
}
FABRIC_ASSERT( membersFound == entity.value.array.size );
}
void parseMethods( JSON::Entity const &methodsArray, std::vector<std::string> &methods )
{
JSON::ArrayDecoder methodArrayDecoder( methodsArray );
JSON::Entity methodEntity;
while ( methodArrayDecoder.getNext( methodEntity ) )
{
try
{
methodEntity.requireString();
methods.push_back( methodEntity.stringToStdString() );
}
catch ( Exception e )
{
methodArrayDecoder.rethrow( e );
}
}
}
void ProducerWrapper::jsonExec(
JSON::Entity const &cmd,
JSON::Entity const &arg,
JSON::ArrayEncoder &resultArrayEncoder
)
{
if ( cmd.stringIs( "toJSON", 6 ) )
jsonExecGetJSONDesc( arg, resultArrayEncoder );
else GC::Object::jsonExec( cmd, arg, resultArrayEncoder );
}
void ValueProducerWrapper::jsonExecProduceAsync( JSON::Entity const &arg, JSON::ArrayEncoder &resultArrayEncoder )
{
arg.requireInteger();
JSONProduceAsyncUserdata *jsonProduceAsyncUserdata = new JSONProduceAsyncUserdata( this, arg.integerValue() );
getUnwrapped()->createComputeState()->produceJSONAsync(
jsonProduceAsyncUserdata->notifyJSONArgObjectEncoder,
&ValueProducerWrapper::JSONExecProduceAsyncFinishedCallback,
jsonProduceAsyncUserdata
);
}
ConstArray::ConstArray(
RC::ConstHandle<RT::Manager> const &rtManager,
RC::ConstHandle<RT::Desc> const &elementDesc,
JSON::Entity const &entity
)
{
entity.requireArray();
m_fixedArrayDesc = rtManager->getFixedArrayOf( elementDesc, entity.value.array.size );
m_data.resize( m_fixedArrayDesc->getAllocSize(), 0 );
m_fixedArrayDesc->decodeJSON( entity, &m_data[0] );
}
static HostSpec parseHostSpec( JSON::Entity const &entity )
{
HostSpec result;
if ( entity.isString() )
result.push_back( entity.stringToStdString() );
else if ( entity.isArray() )
{
JSON::ArrayDecoder arrayDecoder( entity );
JSON::Entity elementEntity;
while ( arrayDecoder.getNext( elementEntity ) )
{
try
{
elementEntity.requireString();
result.push_back( elementEntity.stringToStdString() );
}
catch ( Exception e )
{
arrayDecoder.rethrow( e );
}
}
}
else
throw Exception( "must be a string or an array" );
return result;
}
void DictImpl::decodeJSON( JSON::Entity const &entity, void *data ) const
{
entity.requireObject();
RC::ConstHandle<StringImpl> keyImplAsStringImpl;
if ( isString( m_keyImpl->getType() ) )
keyImplAsStringImpl = RC::ConstHandle<StringImpl>::StaticCast( m_keyImpl );
disposeData( data );
memset( data, 0, sizeof(bits_t *) );
void *keyData = alloca( m_keySize );
m_keyImpl->initializeData( m_keyImpl->getDefaultData(), keyData );
JSON::ObjectDecoder jsonObjectDecoder( entity );
JSON::Entity keyString, valueEntity;
while ( jsonObjectDecoder.getNext( keyString, valueEntity ) )
{
if ( keyImplAsStringImpl )
{
keyString.stringGetData( StringImpl::GetMutableValueData( keyData, keyString.stringLength() ) );
}
else
{
char *mutableData;
char const *data;
if ( keyString.stringIsShort() )
data = keyString.stringShortData();
else
{
mutableData = reinterpret_cast<char *>( alloca( keyString.stringLength() ) );
keyString.stringGetData( mutableData );
data = mutableData;
}
JSON::Decoder jsonDecoder( data, keyString.value.string.length );
JSON::Entity jsonDecodedEntity;
if ( !jsonDecoder.getNext( jsonDecodedEntity ) )
throw Exception( "invalid JSON key" );
m_keyImpl->decodeJSON( jsonDecodedEntity, keyData );
if ( jsonDecoder.getNext( jsonDecodedEntity ) )
throw Exception( "invalid JSON key" );
}
void *valueData = getMutable( data, keyData );
m_valueImpl->decodeJSON( valueEntity, valueData );
}
m_keyImpl->disposeData( keyData );
}
Inst::Inst(
RC::ConstHandle<IO::Dir> const &extensionDir,
std::string const &extensionName,
std::string const &jsonDesc,
std::vector<std::string> const &pluginDirs,
RC::Handle<CG::Manager> const &cgManager,
EDK::Callbacks const &callbacks,
std::map< std::string, void (*)( void * ) > &implNameToDestructorMap
)
: m_name( extensionName )
, m_jsonDesc( jsonDesc )
{
try
{
JSON::Decoder jsonDecode( jsonDesc.data(), jsonDesc.length() );
JSON::Entity jsonEntity;
if ( !jsonDecode.getNext( jsonEntity ) )
throw Exception( "missing JSON entity" );
jsonEntity.requireObject();
m_desc = parseDesc( jsonEntity );
if ( jsonDecode.getNext( jsonEntity ) )
throw Exception( "extra JSON entity" );
}
catch ( Exception e )
{
throw "JSON description: " + e;
}
/*
m_fabricLIBObject = LIB::NakedObject::Create();
m_fabricLIBObject->set( "hostTriple", LIB::ReferencedString::Create( Util::getHostTriple() ) );
m_fabricLIBObject->set( "DependencyGraph", LIBDG::Namespace::Create( dgContext ) );
*/
std::vector< std::string > libs;
m_desc.libs.appendMatching( Util::getHostTriple(), libs );
std::string libSuffix = "-" + std::string(buildOS) + "-" + std::string(buildArch);
for ( size_t i=0; i<libs.size(); ++i )
{
std::string resolvedName;
SOLibHandle soLibHandle = SOLibOpen( libs[i]+libSuffix, resolvedName, false, pluginDirs );
m_resolvedNameToSOLibHandleMap.insert( ResolvedNameToSOLibHandleMap::value_type( resolvedName, soLibHandle ) );
m_orderedSOLibHandles.push_back( soLibHandle );
}
if ( !m_orderedSOLibHandles.empty() )
{
void *resolvedFabricEDKInitFunction = 0;
for ( size_t i=0; i<m_orderedSOLibHandles.size(); ++i )
{
resolvedFabricEDKInitFunction = SOLibResolve( m_orderedSOLibHandles[i], "FabricEDKInit" );
if ( resolvedFabricEDKInitFunction )
break;
}
if ( !resolvedFabricEDKInitFunction )
throw Exception( "error: extension doesn't implement function FabricEDKInit through macro IMPLEMENT_FABRIC_EDK_ENTRIES" );
( *( FabricEDKInitPtr )resolvedFabricEDKInitFunction )( callbacks );
}
for ( size_t i=0; i<m_orderedSOLibHandles.size(); ++i )
{
/*
OnLoadFn onLoadFn = (OnLoadFn)SOLibResolve( m_orderedSOLibHandles[i], "FabricOnLoad" );
if ( onLoadFn )
onLoadFn( SDK::Value::Bind( m_fabricLIBObject ) );
*/
}
/*
for ( size_t i=0; i<m_desc.interface.methods.size(); ++i )
{
std::string const &methodName = m_desc.interface.methods[i];
Method method = 0;
for ( size_t j=0; j<m_orderedSOLibHandles.size(); ++j )
{
SOLibHandle soLibHandle = m_orderedSOLibHandles[j];
method = (Method)SOLibResolve( soLibHandle, methodName );
if ( method )
break;
}
if ( !method )
throw Exception( "method "+_(methodName)+" not found" );
m_methodMap.insert( MethodMap::value_type( methodName, method ) );
}
*/
std::vector<std::string> codeFiles;
m_desc.code.appendMatching( Util::getHostTriple(), codeFiles );
std::string filename;
m_code = "";
for ( std::vector<std::string>::const_iterator it=codeFiles.begin(); it!=codeFiles.end(); ++it )
{
std::string const &codeEntry = *it;
if ( filename.empty() )
filename = codeEntry;
std::string code;
try
{
code = extensionDir->getFileContents( codeEntry );
}
catch ( Exception e )
{
throw _(codeEntry) + ": " + e;
}
m_code += code + "\n";
}
RC::ConstHandle<KL::Source> source = KL::StringSource::Create( filename, m_code );
RC::Handle<KL::Scanner> scanner = KL::Scanner::Create( source );
m_ast = KL::Parse( scanner, m_diagnostics );
if ( !m_diagnostics.containsError() )
m_ast->registerTypes( cgManager, m_diagnostics );
for ( CG::Diagnostics::const_iterator it=m_diagnostics.begin(); it!=m_diagnostics.end(); ++it )
{
CG::Location const &location = it->first;
CG::Diagnostic const &diagnostic = it->second;
FABRIC_LOG( "[%s] %s:%u:%u: %s: %s", extensionName.c_str(), location.getFilename()->c_str(), (unsigned)location.getLine(), (unsigned)location.getColumn(), diagnostic.getLevelDesc(), diagnostic.getDesc().c_str() );
}
if ( m_diagnostics.containsError() )
throw Exception( "KL compile failed" );
std::vector< RC::ConstHandle<AST::FunctionBase> > functionBases;
m_ast->collectFunctionBases( functionBases );
for ( std::vector< RC::ConstHandle<AST::FunctionBase> >::const_iterator it=functionBases.begin(); it!=functionBases.end(); ++it )
{
RC::ConstHandle<AST::FunctionBase> const &functionBase = *it;
if ( !functionBase->getBody() )
{
std::string symbolName = functionBase->getSymbolName( cgManager );
void *resolvedFunction = 0;
for ( size_t i=0; i<m_orderedSOLibHandles.size(); ++i )
{
resolvedFunction = SOLibResolve( m_orderedSOLibHandles[i], symbolName );
if ( resolvedFunction )
break;
}
if ( !resolvedFunction )
throw Exception( "error: symbol " + _(symbolName) + ", prototyped in KL, not found in native code" );
m_externalFunctionMap.insert( ExternalFunctionMap::value_type( symbolName, resolvedFunction ) );
if ( functionBase->isDestructor() )
{
RC::ConstHandle<AST::Destructor> destructor = RC::ConstHandle<AST::Destructor>::StaticCast( functionBase );
std::string thisTypeName = destructor->getThisTypeName();
implNameToDestructorMap[thisTypeName] = (void (*)( void * )) resolvedFunction;
}
}
}
m_jsConstants = m_desc.jsConstants.concatMatching( Util::getHostTriple() );
}
void OpaqueImpl::decodeJSON( JSON::Entity const &entity, void *dst ) const
{
entity.requireNullOrBoolean();
}
void StringImpl::decodeJSON( JSON::Entity const &entity, void *dst ) const
{
entity.requireString();
entity.stringGetData( GetMutableValueData( dst, entity.stringLength() ) );
}
void OpaqueImpl::decodeJSON( JSON::Entity const &entity, void *dst ) const
{
entity.requireNull();
memset( dst, 0, getAllocSize() );
}