void
MMO_Expression_::_addDeps (Dependencies deps, DEP_Type type, Index index)
{
DEP_Type vectorType = DEP_STATE_VECTOR;
if (type == DEP_DISCRETE)
{
vectorType = DEP_DISCRETE_VECTOR;
}
else if (type == DEP_ALGEBRAIC)
{
vectorType = DEP_ALGEBRAIC_VECTOR;
}
for (Index *idx = deps->begin (type); !deps->end (type);
idx = deps->next (type))
{
Index dIdx (*idx);
if (dIdx.hasRange ())
{
// TODO: Agregar las dependencias vectoriales con el rango correcto cuando no
// estan definidas en el mismo rango que la discreta.
Index vi (index);
vi.setOffset (dIdx.offset ());
_deps->insert (vi, vectorType);
}
else
{
_deps->insert (dIdx, type);
}
}
}
// GetNodeList
//------------------------------------------------------------------------------
bool Function::GetNodeList( NodeGraph & nodeGraph, const BFFIterator & iter, const char * propertyName, Dependencies & nodes, bool required,
bool allowCopyDirNodes, bool allowUnityNodes, bool allowRemoveDirNodes ) const
{
ASSERT( propertyName );
const BFFVariable * var = BFFStackFrame::GetVar( propertyName );
if ( !var )
{
// missing
if ( required )
{
Error::Error_1101_MissingProperty( iter, this, AStackString<>( propertyName ) );
return false; // required!
}
return true; // missing but not required
}
if ( var->IsArrayOfStrings() )
{
// an array of references
const Array< AString > & nodeNames = var->GetArrayOfStrings();
nodes.SetCapacity( nodes.GetSize() + nodeNames.GetSize() );
for ( const AString & nodeName : nodeNames )
{
if ( nodeName.IsEmpty() )
{
Error::Error_1004_EmptyStringPropertyNotAllowed( iter, this, propertyName );
return false;
}
if ( !GetNodeList( nodeGraph, iter, this, propertyName, nodeName, nodes, allowCopyDirNodes, allowUnityNodes, allowRemoveDirNodes ) )
{
// child func will have emitted error
return false;
}
}
}
else if ( var->IsString() )
{
if ( var->GetString().IsEmpty() )
{
Error::Error_1004_EmptyStringPropertyNotAllowed( iter, this, propertyName );
return false;
}
if ( !GetNodeList( nodeGraph, iter, this, propertyName, var->GetString(), nodes, allowCopyDirNodes, allowUnityNodes, allowRemoveDirNodes ) )
{
// child func will have emitted error
return false;
}
}
else
{
// unsupported type
Error::Error_1050_PropertyMustBeOfType( iter, this, propertyName, var->GetType(), BFFVariable::VAR_STRING, BFFVariable::VAR_ARRAY_OF_STRINGS );
return false;
}
return true;
}
long ConditionsMappedUserPool<MAPPING>::compute(const Dependencies& deps, void* user_param) {
long num_updates = 0;
if ( !deps.empty() ) {
typedef Dependencies _D;
ConditionsDependencyHandler handler(m_manager.ptr(), *this, deps, user_param);
ConditionsPool* pool = m_manager->registerIOV(*m_iov.iovType, m_iov.keyData);
// Loop over the dependencies and check if they have to be upgraded
for(_D::const_iterator i = deps.begin(); i!=deps.end(); ++i) {
key_type key = (*i).first;
typename MAPPING::iterator j = m_conditions.find(key);
if ( j != m_conditions.end() ) {
Condition::Object* cond = (*j).second;
if ( IOV::key_is_contained(m_iov.keyData,cond->iov->keyData) )
continue;
/// This condition is no longer valid. remove it! Will be added again afterwards.
m_conditions.erase(j);
}
const ConditionDependency* d = (*i).second.get();
Condition::Object* cond = handler(d);
m_manager->registerUnlocked(pool, cond); // Would bulk update be more efficient?
++num_updates;
}
}
return num_updates;
}
int
main(int argc, char *argv[]) {
Sawyer::initializeLibrary();
mlog = Sawyer::Message::Facility("tool");
Sawyer::Message::mfacilities.insertAndAdjust(mlog);
Settings settings;
parseCommandLine(argc, argv, settings);
SqlDatabase::TransactionPtr tx = SqlDatabase::Connection::create(settings.databaseUri)->transaction();
Dependencies dependencies = loadAllDependencies(tx);
// For each dependency, select a random version
LinearCongruentialGenerator prand;
BOOST_FOREACH (const Dependencies::Node &node, dependencies.nodes()) {
size_t idx = prand() % node.value().size();
switch (settings.outputMode) {
case OUTPUT_HUMAN:
std::cout <<std::left <<std::setw(16) <<node.key() <<": " <<node.value()[idx] <<"\n";
break;
case OUTPUT_RMC:
std::cout <<std::left <<std::setw(20) <<("rmc_"+node.key()) <<" " <<shellEscape(node.value()[idx]) <<"\n";
break;
case OUTPUT_SHELL:
std::cout <<" " <<node.key() <<"=" <<shellEscape(node.value()[idx]);
break;
}
}
if (settings.outputMode == OUTPUT_SHELL)
std::cout <<"\n";
}
// GetLibraryStatsRecurse
//------------------------------------------------------------------------------
void Report::GetLibraryStatsRecurse( Array< LibraryStats * > & libStats, const Dependencies & dependencies, LibraryStats * currentLib ) const
{
const Dependency * const end = dependencies.End();
for ( const Dependency * it = dependencies.Begin(); it != end; ++it )
{
GetLibraryStatsRecurse( libStats, it->GetNode(), currentLib );
}
}
static Dependencies
loadAllDependencies(const SqlDatabase::TransactionPtr &tx) {
Dependencies dependencies;
SqlDatabase::StatementPtr q = tx->statement("select name, value from dependencies where enabled <> 0");
for (SqlDatabase::Statement::iterator row = q->begin(); row != q->end(); ++row)
dependencies.insertMaybeDefault(row.get<std::string>(0)).push_back(row.get<std::string>(1));
return dependencies;
}
// Generate
//------------------------------------------------------------------------------
bool ToolManifest::Generate( const Node * mainExecutable, const Dependencies & dependencies )
{
m_Files.Clear();
m_TimeStamp = 0;
m_Files.SetCapacity( 1 + dependencies.GetSize() );
// unify "main executable" and "extra files"
// (loads contents of file into memory, and creates hashes)
if ( !AddFile( mainExecutable ) )
{
return false; // AddFile will have emitted error
}
for ( size_t i=0; i<dependencies.GetSize(); ++i )
{
const FileNode & n = *( dependencies[ i ].GetNode()->CastTo< FileNode >() );
if ( !AddFile( &n ) )
{
return false; // AddFile will have emitted error
}
}
// create a hash for the whole tool chain
const size_t numFiles( m_Files.GetSize() );
const size_t memSize( numFiles * sizeof( uint32_t ) * 2 );
uint32_t * mem = (uint32_t *)ALLOC( memSize );
uint32_t * pos = mem;
for ( size_t i=0; i<numFiles; ++i )
{
const File & f = m_Files[ i ];
// file contents
*pos = f.m_Hash;
++pos;
// file name & sub-path (relative to remote folder)
AStackString<> relativePath;
GetRemoteFilePath( (uint32_t)i, relativePath, false ); // false = don't use full path
*pos = xxHash::Calc32( relativePath );
++pos;
}
m_ToolId = xxHash::Calc64( mem, memSize );
FREE( mem );
// update time stamp (most recent file in manifest)
for ( size_t i=0; i<numFiles; ++i )
{
const File & f = m_Files[ i ];
ASSERT( f.m_TimeStamp ); // should have had an error before if the file was missing
m_TimeStamp = Math::Max( m_TimeStamp, f.m_TimeStamp );
}
return true;
}
PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
const String & database, const String & table, const StoragePtr & storage_,
const Context & context_, const ASTPtr & query_ptr_, bool no_destination)
: storage(storage_), context(context_), query_ptr(query_ptr_)
{
/** TODO This is a very important line. At any insertion into the table one of streams should own lock.
* Although now any insertion into the table is done via PushingToViewsBlockOutputStream,
* but it's clear that here is not the best place for this functionality.
*/
addTableLock(storage->lockStructure(true));
/// If the "root" table deduplactes blocks, there are no need to make deduplication for children
/// Moreover, deduplication for AggregatingMergeTree children could produce false positives due to low size of inserting blocks
bool disable_deduplication_for_children = !no_destination && storage->supportsDeduplication();
if (!table.empty())
{
Dependencies dependencies = context.getDependencies(database, table);
/// We need special context for materialized views insertions
if (!dependencies.empty())
{
views_context = std::make_unique<Context>(context);
// Do not deduplicate insertions into MV if the main insertion is Ok
if (disable_deduplication_for_children)
views_context->getSettingsRef().insert_deduplicate = false;
}
for (const auto & database_table : dependencies)
{
auto dependent_table = context.getTable(database_table.first, database_table.second);
auto & materialized_view = dynamic_cast<const StorageMaterializedView &>(*dependent_table);
if (StoragePtr inner_table = materialized_view.tryGetTargetTable())
addTableLock(inner_table->lockStructure(true));
auto query = materialized_view.getInnerQuery();
BlockOutputStreamPtr out = std::make_shared<PushingToViewsBlockOutputStream>(
database_table.first, database_table.second, dependent_table, *views_context, ASTPtr());
views.emplace_back(ViewInfo{std::move(query), database_table.first, database_table.second, std::move(out)});
}
}
/* Do not push to destination table if the flag is set */
if (!no_destination)
{
output = storage->write(query_ptr, context.getSettingsRef());
replicated_output = dynamic_cast<ReplicatedMergeTreeBlockOutputStream *>(output.get());
}
}
void JSONJob::execute()
{
std::shared_ptr<Project> proj = project();
const Path root = proj->path();
const Dependencies deps = proj->dependencies();
// error() << deps.keys();
assert(proj);
const SymbolMap &map = proj->symbols();
write("{");
bool firstObject = true;
for (Dependencies::const_iterator it = deps.begin(); it != deps.end(); ++it) {
const Path path = Location::path(it->first);
if (path.startsWith(root) && (match.isEmpty() || match.match(path))) {
const Location loc(it->first, 0);
const int srcRootLength = project()->path().size();
if (firstObject) {
firstObject = false;
} else {
write(",");
}
write<64>("\"%s\":[", path.constData() + srcRootLength);
bool firstSymbol = true;
SymbolMap::const_iterator sit = map.lower_bound(loc);
while (sit != map.end() && sit->first.fileId() == it->first) {
Location targetLocation;
SymbolInfo target = sit->second.bestTarget(map, 0, &targetLocation);
const String type = sit->second.kindSpelling();
if (firstSymbol) {
firstSymbol = false;
} else {
write(",");
}
if (!targetLocation.isNull()) {
write<256>("{\"location\":%s,\"type\":\"%s\",\"target\":%s}",
toJSON(sit->first, it->first, sit->second.symbolLength, srcRootLength).constData(), type.constData(),
toJSON(targetLocation, it->first, target.symbolLength, srcRootLength).constData());
} else {
write<256>("{\"location\":%s,\"type\":\"%s\"}",
toJSON(sit->first, it->first, sit->second.symbolLength, srcRootLength).constData(), type.constData());
}
++sit;
}
write("]");
}
}
write("}");
}
// GetOtherLibrary
//------------------------------------------------------------------------------
bool LinkerNode::GetOtherLibrary( NodeGraph & nodeGraph,
const BFFIterator & iter,
const Function * function,
Dependencies & libs,
const AString & path,
const AString & lib,
bool & found ) const
{
found = false;
AStackString<> potentialNodeName( path );
if ( !potentialNodeName.IsEmpty() )
{
PathUtils::EnsureTrailingSlash( potentialNodeName );
}
potentialNodeName += lib;
AStackString<> potentialNodeNameClean;
NodeGraph::CleanPath( potentialNodeName, potentialNodeNameClean );
// see if a node already exists
Node * node = nodeGraph.FindNode( potentialNodeNameClean );
if ( node )
{
// aliases not supported - must point to something that provides a file
if ( node->IsAFile() == false )
{
Error::Error_1103_NotAFile( iter, function, ".LinkerOptions", potentialNodeNameClean, node->GetType() );
return false;
}
// found existing node
libs.Append( Dependency( node ) );
found = true;
return true; // no error
}
// see if the file exists on disk at this location
if ( FileIO::FileExists( potentialNodeNameClean.Get() ) )
{
node = nodeGraph.CreateFileNode( potentialNodeNameClean );
libs.Append( Dependency( node ) );
found = true;
FLOG_INFO( "Additional library '%s' assumed to be '%s'\n", lib.Get(), potentialNodeNameClean.Get() );
return true; // no error
}
return true; // no error
}
// GetObjectListNodes
//------------------------------------------------------------------------------
bool Function::GetObjectListNodes( const BFFIterator & iter,
const Array< AString > & objectLists,
const char * inputVarName,
Dependencies & nodes ) const
{
NodeGraph & ng = FBuild::Get().GetDependencyGraph();
const AString * const end = objectLists.End();
for ( const AString * it = objectLists.Begin(); it != end; ++it )
{
const AString & objectList = *it;
// get node for the dir we depend on
Node * node = ng.FindNode( objectList );
if ( node == nullptr )
{
Error::Error_1104_TargetNotDefined( iter, this, inputVarName, objectList );
return false;
}
else if ( node->GetType() != Node::OBJECT_LIST_NODE )
{
Error::Error_1102_UnexpectedType( iter, this, inputVarName, node->GetName(), node->GetType(), Node::OBJECT_LIST_NODE );
return false;
}
nodes.Append( Dependency( node ) );
}
return true;
}
// DependOnNode
//------------------------------------------------------------------------------
/*static*/ bool LinkerNode::DependOnNode( NodeGraph & nodeGraph,
const BFFIterator & iter,
const Function * function,
const AString & nodeName,
Dependencies & nodes )
{
// silently ignore empty nodes
if ( nodeName.IsEmpty() )
{
return true;
}
Node * node = nodeGraph.FindNode( nodeName );
// does it exist?
if ( node != nullptr )
{
// process it
return DependOnNode( iter, function, node, nodes );
}
// node not found - create a new FileNode, assuming we are
// linking against an externally built library
node = nodeGraph.CreateFileNode( nodeName );
nodes.Append( Dependency( node ) );
return true;
}
// GetDirectoryNodeList
//------------------------------------------------------------------------------
bool Function::GetDirectoryListNodeList( const BFFIterator & iter,
const Array< AString > & paths,
const Array< AString > & excludePaths,
const Array< AString > & filesToExclude,
bool recurse,
const Array< AString > * patterns,
const char * inputVarName,
Dependencies & nodes ) const
{
NodeGraph & ng = FBuild::Get().GetDependencyGraph();
// Handle special case of excluded files beginning with ../
// Since they can be used seinsibly by matching just the end
// of a path, assume they are relative to the working dir.
// TODO:C Move this during bff parsing when everything is using reflection
Array< AString > filesToExcludeCleaned( filesToExclude.GetSize(), true );
for ( const AString& file : filesToExclude )
{
if ( file.BeginsWith( ".." ) )
{
AStackString<> fullPath;
NodeGraph::CleanPath( file, fullPath );
filesToExcludeCleaned.Append( fullPath );
}
else
{
filesToExcludeCleaned.Append( file );
}
}
const AString * const end = paths.End();
for ( const AString * it = paths.Begin(); it != end; ++it )
{
const AString & path = *it;
// get node for the dir we depend on
AStackString<> name;
DirectoryListNode::FormatName( path, patterns, recurse, excludePaths, filesToExcludeCleaned, name );
Node * node = ng.FindNode( name );
if ( node == nullptr )
{
node = ng.CreateDirectoryListNode( name,
path,
patterns,
recurse,
excludePaths,
filesToExcludeCleaned );
}
else if ( node->GetType() != Node::DIRECTORY_LIST_NODE )
{
Error::Error_1102_UnexpectedType( iter, this, inputVarName, node->GetName(), node->GetType(), Node::DIRECTORY_LIST_NODE );
return false;
}
nodes.Append( Dependency( node ) );
}
return true;
}
// CONSTRUCTOR
//------------------------------------------------------------------------------
LinkerNode::LinkerNode( const AString & linkerOutputName,
const Dependencies & inputLibraries,
const Dependencies & otherLibraries,
const AString & linkerType,
const AString & linker,
const AString & linkerArgs,
uint32_t flags,
const Dependencies & assemblyResources,
const AString & importLibName,
Node * linkerStampExe,
const AString & linkerStampExeArgs )
: FileNode( linkerOutputName, Node::FLAG_NONE )
, m_Flags( flags )
, m_AssemblyResources( assemblyResources )
, m_OtherLibraries( otherLibraries )
, m_ImportLibName( importLibName )
, m_LinkerStampExe( linkerStampExe )
, m_LinkerStampExeArgs( linkerStampExeArgs )
{
m_LastBuildTimeMs = 20000;
// presize vector
size_t numStaticDeps = inputLibraries.GetSize() + assemblyResources.GetSize() + otherLibraries.GetSize();
if ( linkerStampExe )
{
numStaticDeps++;
}
m_StaticDependencies.SetCapacity( numStaticDeps );
// depend on everything we'll link together
m_StaticDependencies.Append( inputLibraries );
m_StaticDependencies.Append( assemblyResources );
m_StaticDependencies.Append( otherLibraries );
// manage optional LinkerStampExe
if ( linkerStampExe )
{
m_StaticDependencies.Append( Dependency( linkerStampExe ) );
}
// store options we'll need to use dynamically
m_LinkerType = linkerType;
m_Linker = linker; // TODO:C This should be a node
m_LinkerArgs = linkerArgs;
}
PushingToViewsBlockOutputStream::PushingToViewsBlockOutputStream(
String database, String table, StoragePtr storage,
const Context & context_, const ASTPtr & query_ptr_, bool no_destination)
: context(context_), query_ptr(query_ptr_)
{
/** TODO This is a very important line. At any insertion into the table one of streams should own lock.
* Although now any insertion into the table is done via PushingToViewsBlockOutputStream,
* but it's clear that here is not the best place for this functionality.
*/
addTableLock(storage->lockStructure(true, __PRETTY_FUNCTION__));
if (!table.empty())
{
Dependencies dependencies = context.getDependencies(database, table);
/// We need special context for materialized views insertions
if (!dependencies.empty())
{
views_context = std::make_unique<Context>(context);
// Do not deduplicate insertions into MV if the main insertion is Ok
views_context->getSettingsRef().insert_deduplicate = false;
}
for (const auto & database_table : dependencies)
{
auto dependent_table = context.getTable(database_table.first, database_table.second);
auto & materialized_view = dynamic_cast<const StorageMaterializedView &>(*dependent_table);
auto query = materialized_view.getInnerQuery();
auto out = std::make_shared<PushingToViewsBlockOutputStream>(
database_table.first, database_table.second, dependent_table, *views_context, ASTPtr());
views.emplace_back(ViewInfo{std::move(query), database_table.first, database_table.second, std::move(out)});
}
}
/* Do not push to destination table if the flag is set */
if (!no_destination)
{
output = storage->write(query_ptr, context.getSettingsRef());
replicated_output = dynamic_cast<ReplicatedMergeTreeBlockOutputStream *>(output.get());
}
}
// CONSTRUCTOR
//------------------------------------------------------------------------------
CSNode::CSNode( const AString & compilerOutput,
const Dependencies & inputNodes,
const AString & compiler,
const AString & compilerArgs,
const Dependencies & extraRefs )
: FileNode( compilerOutput, Node::FLAG_NONE )
, m_ExtraRefs( extraRefs )
{
ASSERT( !inputNodes.IsEmpty() );
m_StaticDependencies.SetCapacity( inputNodes.GetSize() + extraRefs.GetSize() );
m_StaticDependencies.Append( inputNodes );
m_StaticDependencies.Append( extraRefs );
// store options we'll need to use when building
m_CompilerPath = compiler; // TODO:C This should be a node we statically depend on
m_CompilerArgs = compilerArgs;
m_Type = CS_NODE;
m_LastBuildTimeMs = 5000; // higher default than a file node
}
RemoteDoclet::RemoteDoclet(Dependencies& dependencies) :
_component(dependencies.getTargetComponent())
{
if (!_component.containsAnnotation(REMOTE)) {
std::cout << "No match for annotation @remote. Skipping..." << std::endl;
return;
}
if (_component.containsAttributeAnnotation(REMOTE)) {
throw "@remote annotations are prohibited for attributes";
}
generateClient(_component.getTree());
generateService(_component.getTree());
}
// GetFileNode
//------------------------------------------------------------------------------
bool Function::GetFileNode( NodeGraph & nodeGraph,
const BFFIterator & iter,
const AString & file,
const char * inputVarName,
Dependencies & nodes ) const
{
// get node for the dir we depend on
Node * node = nodeGraph.FindNode( file );
if ( node == nullptr )
{
node = nodeGraph.CreateFileNode( file );
}
else if ( node->IsAFile() == false )
{
Error::Error_1005_UnsupportedNodeType( iter, this, inputVarName, node->GetName(), node->GetType() );
return false;
}
nodes.Append( Dependency( node ) );
return true;
}
// GetDirectoryNodeList
//------------------------------------------------------------------------------
bool Function::GetDirectoryListNodeList( const BFFIterator & iter,
const Array< AString > & paths,
const Array< AString > & excludePaths,
const Array< AString > & filesToExclude,
bool recurse,
const AString & pattern,
const char * inputVarName,
Dependencies & nodes ) const
{
NodeGraph & ng = FBuild::Get().GetDependencyGraph();
const AString * const end = paths.End();
for ( const AString * it = paths.Begin(); it != end; ++it )
{
const AString & path = *it;
// get node for the dir we depend on
AStackString<> name;
DirectoryListNode::FormatName( path, pattern, recurse, excludePaths, filesToExclude, name );
Node * node = ng.FindNode( name );
if ( node == nullptr )
{
node = ng.CreateDirectoryListNode( name,
path,
pattern,
recurse,
excludePaths,
filesToExclude );
}
else if ( node->GetType() != Node::DIRECTORY_LIST_NODE )
{
Error::Error_1102_UnexpectedType( iter, this, inputVarName, node->GetName(), node->GetType(), Node::DIRECTORY_LIST_NODE );
return false;
}
nodes.Append( Dependency( node ) );
}
return true;
}
void FeedParser::parse_depends(XmlReader& xml, Dependencies& depends)
{
while (xml.start_element())
{
std::string name = xml.name();
if (name == "if")
{
depends.start_if(xml.attribute("test", project_ns));
parse_depends(xml, depends);
depends.end_if();
}
else if (name == "elseif")
{
depends.start_elseif(xml.attribute("test", project_ns));
parse_depends(xml, depends);
depends.end_if();
}
else if (name == "else")
{
depends.start_else();
parse_depends(xml, depends);
depends.end_if();
}
else if (name == "depends")
{
std::string dep = resolve_uri(spec.id, xml.attribute("href", project_ns));
depends.depends(Spec(dep.c_str()));
}
else if (name == "conflicts")
{
std::string dep = resolve_uri(spec.id, xml.attribute("href", project_ns));
depends.conflicts(Spec(dep.c_str()));
}
xml.skip();
}
}
// Commit
//------------------------------------------------------------------------------
/*virtual*/ bool FunctionLibrary::Commit( NodeGraph & nodeGraph, const BFFIterator & funcStartIter ) const
{
// make sure all required variables are defined
const BFFVariable * outputLib;
const BFFVariable * compiler;
const BFFVariable * compilerOptions;
AStackString<> compilerOptionsDeoptimized;
AStackString<> compilerOutputPath;
AStackString<> compilerOutputPrefix;
const BFFVariable * compilerOutputExtension;
const BFFVariable * librarian;
const BFFVariable * librarianOptions;
if ( !GetString( funcStartIter, outputLib, ".LibrarianOutput", true ) ||
!GetString( funcStartIter, compiler, ".Compiler", true ) ||
!GetString( funcStartIter, compilerOptions, ".CompilerOptions", true ) ||
!GetString( funcStartIter, compilerOptionsDeoptimized, ".CompilerOptionsDeoptimized", false ) ||
!GetString( funcStartIter, compilerOutputPath, ".CompilerOutputPath", true ) ||
!GetString( funcStartIter, compilerOutputPrefix, ".CompilerOutputPrefix", false ) ||
!GetString( funcStartIter, compilerOutputExtension, ".CompilerOutputExtension", false ) ||
!GetString( funcStartIter, librarian, ".Librarian", true ) ||
!GetString( funcStartIter, librarianOptions, ".LibrarianOptions", true ) )
{
return false;
}
PathUtils::FixupFolderPath( compilerOutputPath );
// find or create the compiler node
CompilerNode * compilerNode = nullptr;
if ( !FunctionObjectList::GetCompilerNode( nodeGraph, funcStartIter, compiler->GetString(), compilerNode ) )
{
return false; // GetCompilerNode will have emitted error
}
// Compiler Force Using
Dependencies compilerForceUsing;
if ( !GetNodeList( nodeGraph, funcStartIter, ".CompilerForceUsing", compilerForceUsing, false ) )
{
return false; // GetNodeList will have emitted an error
}
// de-optimization setting
bool deoptimizeWritableFiles = false;
bool deoptimizeWritableFilesWithToken = false;
if ( !GetBool( funcStartIter, deoptimizeWritableFiles, ".DeoptimizeWritableFiles", false, false ) )
{
return false; // GetBool will have emitted error
}
if ( !GetBool( funcStartIter, deoptimizeWritableFilesWithToken, ".DeoptimizeWritableFilesWithToken", false, false ) )
{
return false; // GetBool will have emitted error
}
if ( ( deoptimizeWritableFiles || deoptimizeWritableFilesWithToken ) && compilerOptionsDeoptimized.IsEmpty() )
{
Error::Error_1101_MissingProperty( funcStartIter, this, AStackString<>( ".CompilerOptionsDeoptimized" ) );
return false;
}
// cache & distribution control
bool allowDistribution( true );
bool allowCaching( true );
if ( !GetBool( funcStartIter, allowDistribution, ".AllowDistribution", true ) ||
!GetBool( funcStartIter, allowCaching, ".AllowCaching", true ) )
{
return false; // GetBool will have emitted error
}
// Precompiled Header support
ObjectNode * precompiledHeaderNode = nullptr;
AStackString<> compilerOutputExtensionStr( compilerOutputExtension ? compilerOutputExtension->GetString().Get() : ".obj" );
if ( !GetPrecompiledHeaderNode( nodeGraph, funcStartIter, compilerNode, compilerOptions, compilerForceUsing, precompiledHeaderNode, deoptimizeWritableFiles, deoptimizeWritableFilesWithToken, allowDistribution, allowCaching, compilerOutputExtensionStr ) )
{
return false; // GetPrecompiledHeaderNode will have emitted error
}
// Sanity check compile flags
const bool usingPCH = ( precompiledHeaderNode != nullptr );
uint32_t objFlags = ObjectNode::DetermineFlags( compilerNode, compilerOptions->GetString(), false, usingPCH );
if ( ( objFlags & ObjectNode::FLAG_MSVC ) && ( objFlags & ObjectNode::FLAG_CREATING_PCH ) )
{
// must not specify use of precompiled header (must use the PCH specific options)
Error::Error_1303_PCHCreateOptionOnlyAllowedOnPCH( funcStartIter, this, "Yc", "CompilerOptions" );
return false;
}
// Check input/output for Compiler
{
bool hasInputToken = false;
bool hasOutputToken = false;
bool hasCompileToken = false;
const AString & args = compilerOptions->GetString();
Array< AString > tokens;
args.Tokenize( tokens );
for ( const AString & token : tokens )
{
if ( token.Find( "%1" ) )
{
hasInputToken = true;
}
else if ( token.Find( "%2" ) )
{
hasOutputToken = true;
}
else
{
if ( objFlags & ObjectNode::FLAG_MSVC )
{
if ( ( token == "/c" ) || ( token == "-c" ) )
{
hasCompileToken = true;
}
}
else
{
if ( token == "-c" )
{
hasCompileToken = true;
}
}
}
}
if ( hasInputToken == false )
{
Error::Error_1106_MissingRequiredToken( funcStartIter, this, ".CompilerOptions", "%1" );
return false;
}
if ( hasOutputToken == false )
{
Error::Error_1106_MissingRequiredToken( funcStartIter, this, ".CompilerOptions", "%2" );
return false;
}
// check /c or -c
if ( objFlags & ObjectNode::FLAG_MSVC )
{
if ( hasCompileToken == false )
{
Error::Error_1106_MissingRequiredToken( funcStartIter, this, ".CompilerOptions", "/c or -c" );
return false;
}
}
else if ( objFlags & ( ObjectNode::FLAG_SNC | ObjectNode::FLAG_GCC | ObjectNode::FLAG_CLANG ) )
{
if ( hasCompileToken == false )
{
Error::Error_1106_MissingRequiredToken( funcStartIter, this, ".CompilerOptions", "-c" );
return false;
}
}
}
// Check input/output for Librarian
{
const AString & args = librarianOptions->GetString();
bool hasInputToken = ( args.Find( "%1" ) || args.Find( "\"%1\"" ) );
if ( hasInputToken == false )
{
Error::Error_1106_MissingRequiredToken( funcStartIter, this, ".LibrarianOptions", "%1" );
return false;
}
bool hasOutputToken = ( args.Find( "%2" ) || args.Find( "\"%2\"" ) );
if ( hasOutputToken == false )
{
Error::Error_1106_MissingRequiredToken( funcStartIter, this, ".LibrarianOptions", "%2" );
return false;
}
}
// Get the (optional) Preprocessor & PreprocessorOptions
const BFFVariable * preprocessor = nullptr;
const BFFVariable * preprocessorOptions = nullptr;
CompilerNode * preprocessorNode = nullptr;
if ( !GetString( funcStartIter, preprocessor, ".Preprocessor", false ) )
{
return false; // GetString will have emitted an error
}
if ( preprocessor )
{
// get the preprocessor executable
if ( !FunctionObjectList::GetCompilerNode( nodeGraph, funcStartIter, preprocessor->GetString(), preprocessorNode ) )
{
return false; // GetCompilerNode will have emitted an error
}
// get the command line args for the preprocessor
if ( !GetString( funcStartIter, preprocessorOptions, ".PreprocessorOptions", true ) ) // required
{
return false; // GetString will have emitted an error
}
}
// Pre-build dependencies
Dependencies preBuildDependencies;
if ( !GetNodeList( nodeGraph, funcStartIter, ".PreBuildDependencies", preBuildDependencies, false ) )
{
return false; // GetNodeList will have emitted an error
}
Dependencies staticDeps( 32, true );
if ( !GetInputs( nodeGraph, funcStartIter, staticDeps ) )
{
return false; // GetStaticDeps will gave emitted error
}
// are the additional inputs to merge into the libaray?
Dependencies additionalInputs;
if ( !GetNodeList( nodeGraph, funcStartIter, ".LibrarianAdditionalInputs", additionalInputs, false ) )
{
return false;// helper will emit error
}
if ( staticDeps.IsEmpty() && additionalInputs.IsEmpty() )
{
Error::Error_1006_NothingToBuild( funcStartIter, this );
return false;
}
uint32_t flags = LibraryNode::DetermineFlags( librarian->GetString() );
// Create library node which depends on the single file or list
if ( nodeGraph.FindNode( outputLib->GetString() ) )
{
Error::Error_1100_AlreadyDefined( funcStartIter, this, outputLib->GetString() );
return false;
}
AStackString<> baseDirectory;
if ( !GetBaseDirectory( funcStartIter, baseDirectory ) )
{
return false; // GetBaseDirectory will have emitted error
}
AStackString<> extraPDBPath, extraASMPath;
GetExtraOutputPaths( compilerOptions->GetString(), extraPDBPath, extraASMPath );
LibraryNode * libNode = nodeGraph.CreateLibraryNode( outputLib->GetString(),
staticDeps,
compilerNode,
compilerOptions->GetString(),
compilerOptionsDeoptimized,
compilerOutputPath,
librarian->GetString(),
librarianOptions->GetString(),
flags,
precompiledHeaderNode,
compilerForceUsing,
preBuildDependencies,
additionalInputs,
deoptimizeWritableFiles,
deoptimizeWritableFilesWithToken,
allowDistribution,
allowCaching,
preprocessorNode,
preprocessorOptions ? preprocessorOptions->GetString() : AString::GetEmpty(),
baseDirectory );
if ( compilerOutputExtension )
{
libNode->m_ObjExtensionOverride = compilerOutputExtension->GetString();
}
libNode->m_CompilerOutputPrefix = compilerOutputPrefix;
libNode->m_ExtraPDBPath = extraPDBPath;
libNode->m_ExtraASMPath = extraASMPath;
return ProcessAlias( nodeGraph, funcStartIter, libNode );
}
FilterResultPtr
Task::process(TaskStatus const& status, FilterData const& data)
{
status.throwIfCancelled();
Dependencies const deps(data.xform().resultingPreCropArea());
std::auto_ptr<Params> params(m_ptrSettings->getPageParams(m_pageId));
if (params.get() && !params->dependencies().matches(deps) && (params->mode() == MODE_AUTO)) {
params.reset();
}
OptionsWidget::UiData ui_data;
ui_data.setSizeCalc(PhysSizeCalc(data.xform()));
if (params.get()) {
ui_data.setContentRect(params->contentRect());
ui_data.setDependencies(deps);
ui_data.setMode(params->mode());
if (!params->dependencies().matches(deps)) {
QRectF content_rect = ui_data.contentRect();
QPointF new_center= deps.rotatedPageOutline().boundingRect().center();
QPointF old_center = params->dependencies().rotatedPageOutline().boundingRect().center();
content_rect.translate(new_center - old_center);
ui_data.setContentRect(content_rect);
}
if ((params->contentSizeMM().isEmpty() && !params->contentRect().isEmpty()) || !params->dependencies().matches(deps)) {
// Backwards compatibilty: put the missing data where it belongs.
Params const new_params(
ui_data.contentRect(), ui_data.contentSizeMM(),
deps, params->mode()
);
m_ptrSettings->setPageParams(m_pageId, new_params);
}
} else {
QRectF const content_rect(
ContentBoxFinder::findContentBox(
status, data, m_ptrDbg.get()
)
);
ui_data.setContentRect(content_rect);
ui_data.setDependencies(deps);
ui_data.setMode(MODE_AUTO);
Params const new_params(
ui_data.contentRect(), ui_data.contentSizeMM(), deps, MODE_AUTO
);
m_ptrSettings->setPageParams(m_pageId, new_params);
}
status.throwIfCancelled();
if (m_ptrNextTask) {
return m_ptrNextTask->process(
status, FilterData(data, data.xform()),
ui_data.contentRect()
);
} else {
return FilterResultPtr(
new UiUpdater(
m_ptrFilter, m_pageId, m_ptrDbg, data.origImage(),
data.xform(), ui_data, m_batchProcessing
)
);
}
}
// Commit
//------------------------------------------------------------------------------
/*virtual*/ bool FunctionExec::Commit( NodeGraph & nodeGraph, const BFFIterator & funcStartIter ) const
{
// make sure all required variables are defined
const BFFVariable * outputV;
const BFFVariable * executableV;
const BFFVariable * argsV;
const BFFVariable * workingDirV;
int32_t expectedReturnCode;
bool useStdOutAsOutput;
if ( !GetString( funcStartIter, outputV, ".ExecOutput", true ) ||
!GetString( funcStartIter, executableV, ".ExecExecutable", true ) ||
!GetString( funcStartIter, argsV, ".ExecArguments" ) ||
!GetString( funcStartIter, workingDirV, ".ExecWorkingDir" ) ||
!GetInt( funcStartIter, expectedReturnCode, ".ExecReturnCode", 0, false ) ||
!GetBool( funcStartIter, useStdOutAsOutput, ".ExecUseStdOutAsOutput", false, false))
{
return false;
}
// check for duplicates
if ( nodeGraph.FindNode( outputV->GetString() ) != nullptr )
{
Error::Error_1100_AlreadyDefined( funcStartIter, this, outputV->GetString() );
return false;
}
// Pre-build dependencies
Dependencies preBuildDependencies;
if ( !GetNodeList( nodeGraph, funcStartIter, ".PreBuildDependencies", preBuildDependencies, false ) )
{
return false; // GetNodeList will have emitted an error
}
// get executable node
Node * exeNode = nodeGraph.FindNode( executableV->GetString() );
if ( exeNode == nullptr )
{
exeNode = nodeGraph.CreateFileNode( executableV->GetString() );
}
else if ( exeNode->IsAFile() == false )
{
Error::Error_1103_NotAFile( funcStartIter, this, "ExecExecutable", exeNode->GetName(), exeNode->GetType() );
return false;
}
// source node
Dependencies inputNodes;
if ( !GetNodeList( nodeGraph, funcStartIter, ".ExecInput", inputNodes, false ) )
{
return false; // GetNodeList will have emitted an error
}
else
{
// Make sure all nodes are files
const Dependency * const end = inputNodes.End();
for (const Dependency * it = inputNodes.Begin();
it != end;
++it)
{
Node * node = it->GetNode();
if (node->IsAFile() == false)
{
Error::Error_1103_NotAFile(funcStartIter, this, "ExecInput", node->GetName(), node->GetType());
return false;
}
}
}
// optional args
const AString & arguments( argsV ? argsV->GetString() : AString::GetEmpty() );
const AString & workingDir( workingDirV ? workingDirV->GetString(): AString::GetEmpty() );
// create the TestNode
Node * outputNode = nodeGraph.CreateExecNode( outputV->GetString(),
inputNodes,
(FileNode *)exeNode,
arguments,
workingDir,
expectedReturnCode,
preBuildDependencies,
useStdOutAsOutput);
return ProcessAlias( nodeGraph, funcStartIter, outputNode );
}
// DependOnNode
//------------------------------------------------------------------------------
/*static*/ bool LinkerNode::DependOnNode( const BFFIterator & iter,
const Function * function,
Node * node,
Dependencies & nodes )
{
ASSERT( node );
// a previously declared library?
if ( node->GetType() == Node::LIBRARY_NODE )
{
// can link directly to it
nodes.Append( Dependency( node ) );
return true;
}
// a previously declared object list?
if ( node->GetType() == Node::OBJECT_LIST_NODE )
{
// can link directly to it
nodes.Append( Dependency( node ) );
return true;
}
// a dll?
if ( node->GetType() == Node::DLL_NODE )
{
// TODO:B Depend on import lib
nodes.Append( Dependency( node, true ) ); // NOTE: Weak dependency
return true;
}
// a previously declared external file?
if ( node->GetType() == Node::FILE_NODE )
{
// can link directy against it
nodes.Append( Dependency( node ) );
return true;
}
// a file copy?
if ( node->GetType() == Node::COPY_FILE_NODE )
{
// depend on copy - will use input at build time
nodes.Append( Dependency( node ) );
return true;
}
// an external executable?
if ( node->GetType() == Node::EXEC_NODE )
{
// depend on ndoe - will use exe output at build time
nodes.Append( Dependency( node ) );
return true;
}
// a group (alias)?
if ( node->GetType() == Node::ALIAS_NODE )
{
// handle all targets in alias
AliasNode * an = node->CastTo< AliasNode >();
const Dependencies & aliasNodeList = an->GetAliasedNodes();
const Dependencies::Iter end = aliasNodeList.End();
for ( Dependencies::Iter it = aliasNodeList.Begin();
it != end;
++it )
{
if ( DependOnNode( iter, function, it->GetNode(), nodes ) == false )
{
return false; // something went wrong lower down
}
}
return true; // all nodes in group handled ok
}
// don't know how to handle this type of node
Error::Error_1005_UnsupportedNodeType( iter, function, "Libraries", node->GetName(), node->GetType() );
return false;
}
// Commit
//------------------------------------------------------------------------------
/*virtual*/ bool FunctionCopy::Commit( NodeGraph & nodeGraph, const BFFIterator & funcStartIter ) const
{
// make sure all required variables are defined
Array< AString > sources( 16, true );
const BFFVariable * dstFileV;
if ( !GetStrings( funcStartIter, sources, ".Source", true ) ||
!GetString( funcStartIter, dstFileV, ".Dest", true ) )
{
return false; // GetString will have emitted errors
}
// Optional
AStackString<> sourceBasePath;
if ( !GetString( funcStartIter, sourceBasePath, ".SourceBasePath", false ) )
{
return false; // GetString will have emitted errors
}
// Canonicalize the SourceBasePath
if ( !sourceBasePath.IsEmpty() )
{
AStackString<> cleanValue;
NodeGraph::CleanPath( sourceBasePath, cleanValue );
PathUtils::EnsureTrailingSlash( cleanValue );
sourceBasePath = cleanValue;
}
// check sources are not paths
{
const AString * const end = sources.End();
for ( const AString * it = sources.Begin(); it != end; ++it )
{
const AString & srcFile( *it );
// source must be a file, not a path
if ( PathUtils::IsFolderPath( srcFile ) )
{
Error::Error_1105_PathNotAllowed( funcStartIter, this, ".Source", srcFile );
return false;
}
}
}
// Pre-build dependencies
Dependencies preBuildDependencies;
if ( !GetNodeList( nodeGraph, funcStartIter, ".PreBuildDependencies", preBuildDependencies, false ) )
{
return false; // GetNodeList will have emitted an error
}
Array< AString > preBuildDependencyNames( preBuildDependencies.GetSize(), false );
for ( const auto & dep : preBuildDependencies )
{
preBuildDependencyNames.Append( dep.GetNode()->GetName() );
}
// get source node
Array< Node * > srcNodes;
{
const AString * const end = sources.End();
for ( const AString * it = sources.Begin(); it != end; ++it )
{
Node * srcNode = nodeGraph.FindNode( *it );
if ( srcNode )
{
if ( GetSourceNodes( funcStartIter, srcNode, srcNodes ) == false )
{
return false;
}
}
else
{
// source file not defined by use - assume an external file
srcNodes.Append( nodeGraph.CreateFileNode( *it ) );
}
}
}
AStackString<> dstFile;
NodeGraph::CleanPath( dstFileV->GetString(), dstFile );
const bool dstIsFolderPath = PathUtils::IsFolderPath( dstFile );
// make all the nodes for copies
Dependencies copyNodes( srcNodes.GetSize(), false );
for ( const Node * srcNode : srcNodes )
{
AStackString<> dst( dstFile );
// dest can be a file OR a path. If it's a path, use the source filename part
if ( dstIsFolderPath )
{
// find filename part of source
const AString & srcName = srcNode->GetName();
// If the sourceBasePath is specified (and valid) use the name relative to that
if ( !sourceBasePath.IsEmpty() && PathUtils::PathBeginsWith( srcName, sourceBasePath ) )
{
// Use everything relative to the SourceBasePath
dst += srcName.Get() + sourceBasePath.GetLength();
}
else
{
// Use just the file name
const char * lastSlash = srcName.FindLast( NATIVE_SLASH );
dst += lastSlash ? ( lastSlash + 1 ) // append filename part if found
: srcName.Get(); // otherwise append whole thing
}
}
// check node doesn't already exist
if ( nodeGraph.FindNode( dst ) )
{
// TODO:C could have a specific error for multiple sources with only 1 output
// to differentiate from two rules creating the same dst target
Error::Error_1100_AlreadyDefined( funcStartIter, this, dst );
return false;
}
// create our node
CopyFileNode * copyFileNode = nodeGraph.CreateCopyFileNode( dst );
copyFileNode->m_Source = srcNode->GetName();
copyFileNode->m_PreBuildDependencyNames = preBuildDependencyNames;
if ( !copyFileNode->Initialize( nodeGraph, funcStartIter, this ) )
{
return false; // Initialize will have emitted an error
}
copyNodes.Append( Dependency( copyFileNode ) );
}
// handle alias creation
return ProcessAlias( nodeGraph, funcStartIter, copyNodes );
}
// GetInputs
//------------------------------------------------------------------------------
bool FunctionObjectList::GetInputs( const BFFIterator & iter, Dependencies & inputs ) const
{
NodeGraph & ng = FBuild::Get().GetDependencyGraph();
// do we want to build files via a unity blob?
Array< AString > inputUnities;
if ( !GetStrings( iter, inputUnities, ".CompilerInputUnity", false ) ) // not required
{
return false;
}
for ( const auto& unity : inputUnities )
{
Node * n = ng.FindNode( unity );
if ( n == nullptr )
{
Error::Error_1104_TargetNotDefined( iter, this, "CompilerInputUnity", unity );
return false;
}
if ( n->GetType() != Node::UNITY_NODE )
{
Error::Error_1102_UnexpectedType( iter, this, "CompilerInputUnity", unity, n->GetType(), Node::UNITY_NODE );
return false;
}
inputs.Append( Dependency( n ) );
}
// do we want to build a files in a directory?
const BFFVariable * inputPath = BFFStackFrame::GetVar( ".CompilerInputPath" );
if ( inputPath )
{
// get the optional pattern and recurse options related to InputPath
Array< AString > patterns;
if ( !GetStrings( iter, patterns, ".CompilerInputPattern", false ) )
{
return false; // GetString will have emitted an error
}
if ( patterns.IsEmpty() )
{
patterns.Append( AStackString<>( "*.cpp" ) );
}
// recursive? default to true
bool recurse = true;
if ( !GetBool( iter, recurse, ".CompilerInputPathRecurse", true, false ) )
{
return false; // GetBool will have emitted an error
}
// Support an exclusion path
Array< AString > excludePaths;
if ( !GetFolderPaths( iter, excludePaths, ".CompilerInputExcludePath", false ) )
{
return false; // GetFolderPaths will have emitted an error
}
Array< AString > filesToExclude;
if ( !GetStrings( iter, filesToExclude, ".CompilerInputExcludedFiles", false ) ) // not required
{
return false; // GetStrings will have emitted an error
}
CleanFileNames( filesToExclude );
// Input paths
Array< AString > inputPaths;
if ( !GetFolderPaths( iter, inputPaths, ".CompilerInputPath", false ) )
{
return false; // GetFolderPaths will have emitted an error
}
Dependencies dirNodes( inputPaths.GetSize() );
if ( !GetDirectoryListNodeList( iter, inputPaths, excludePaths, filesToExclude, recurse, &patterns, "CompilerInputPath", dirNodes ) )
{
return false; // GetDirectoryListNodeList will have emitted an error
}
inputs.Append( dirNodes );
}
// do we want to build a specific list of files?
if ( !GetNodeList( iter, ".CompilerInputFiles", inputs, false ) )
{
// helper will emit error
return false;
}
return true;
}
// GetNodeListRecurse
//------------------------------------------------------------------------------
bool Function::GetNodeListRecurse( const BFFIterator & iter, const char * name, Dependencies & nodes, const AString & nodeName,
bool allowCopyDirNodes, bool allowUnityNodes, bool allowRemoveDirNodes ) const
{
NodeGraph & ng = FBuild::Get().GetDependencyGraph();
// get node
Node * n = ng.FindNode( nodeName );
if ( n == nullptr )
{
// not found - create a new file node
n = ng.CreateFileNode( nodeName );
nodes.Append( Dependency( n ) );
return true;
}
// found - is it a file?
if ( n->IsAFile() )
{
// found file - just use as is
nodes.Append( Dependency( n ) );
return true;
}
// found - is it an ObjectList?
if ( n->GetType() == Node::OBJECT_LIST_NODE )
{
// use as-is
nodes.Append( Dependency( n ) );
return true;
}
// extra types
if ( allowCopyDirNodes )
{
// found - is it an ObjectList?
if ( n->GetType() == Node::COPY_DIR_NODE )
{
// use as-is
nodes.Append( Dependency( n ) );
return true;
}
}
if ( allowRemoveDirNodes )
{
// found - is it a RemoveDirNode?
if ( n->GetType() == Node::REMOVE_DIR_NODE )
{
// use as-is
nodes.Append( Dependency( n ) );
return true;
}
}
if ( allowUnityNodes )
{
// found - is it an ObjectList?
if ( n->GetType() == Node::UNITY_NODE )
{
// use as-is
nodes.Append( Dependency( n ) );
return true;
}
}
// found - is it a group?
if ( n->GetType() == Node::ALIAS_NODE )
{
AliasNode * an = n->CastTo< AliasNode >();
const Dependencies & aNodes = an->GetAliasedNodes();
for ( const Dependency * it = aNodes.Begin(); it != aNodes.End(); ++it )
{
// TODO:C by passing as string we'll be looking up again for no reason
const AString & subName = it->GetNode()->GetName();
if ( !GetNodeListRecurse( iter, name, nodes, subName, allowCopyDirNodes, allowUnityNodes, allowRemoveDirNodes ) )
{
return false;
}
}
return true;
}
// don't know how to handle this type of node
Error::Error_1005_UnsupportedNodeType( iter, this, name, n->GetName(), n->GetType() );
return false;
}
void
MMO_Expression_::_addAlgebriacDeps (Index algIndex, MMO_Equation equation,
Index equationIndex, Index derivativeIndex,
Dependencies derivativeDeps,
map<Index, Index> *states,
map<Index, Index> *discretes,
Index variableChange, int value)
{
stringstream buffer;
string indent;
string variableString = equation->lhs ().variable (algIndex, "i");
Dependencies deps = equation->exp ()->deps ();
map<Index, Index> &stateVariables = *states;
Index eqIndex = equationIndex;
for (Index *idx = deps->begin (DEP_STATE); !deps->end (DEP_STATE);
idx = deps->next (DEP_STATE))
{
if (stateVariables.find (*idx) == stateVariables.end ()
|| equation->lhs ().variableChange (algIndex))
{
Index stateIndex = Index (
idx->applyVariableChange (
equation->lhs ().variableIndex (algIndex)));
stateVariables[*idx] = *idx;
eqIndex.setOffset (_equationIndex++);
if (idx->hasRange () && eqIndex.hasRange ())
{
// X[i] = B[i];
derivativeDeps->insert (stateIndex, eqIndex, DEP_ALGEBRAIC_STATE);
}
else if (!idx->hasRange () && eqIndex.hasRange ())
{
// X[i] = B[N];
derivativeDeps->insert (stateIndex, eqIndex, DEP_ALGEBRAIC_STATE);
}
else if (idx->hasRange () && !eqIndex.hasRange ())
{
// X[N] = B[i];
if (derivativeIndex.hasRange ())
{
Index newEqIndex = eqIndex;
newEqIndex.setRange ();
newEqIndex.setLow (derivativeIndex.low ());
newEqIndex.setHi (derivativeIndex.hi ());
derivativeDeps->insert (
stateIndex.indexValue (
stateIndex.value (algIndex.constant ())),
newEqIndex, DEP_ALGEBRAIC_STATE);
}
else
{
derivativeDeps->insert (
stateIndex.indexValue (
stateIndex.value (algIndex.constant ())),
eqIndex, DEP_ALGEBRAIC_STATE);
}
}
else if (!idx->hasRange () && !eqIndex.hasRange ())
{
// X[N] = B[N];
if (derivativeIndex.hasRange () && !algIndex.isArray())
{
Index newEqIndex = eqIndex;
newEqIndex.setRange ();
newEqIndex.setLow (derivativeIndex.low ());
newEqIndex.setHi (derivativeIndex.hi ());
derivativeDeps->insert (stateIndex,
newEqIndex, DEP_ALGEBRAIC_STATE);
}
else
{
derivativeDeps->insert (stateIndex, eqIndex, DEP_ALGEBRAIC_STATE);
}
}
}
}
map<Index, Index> &discreteVariables = *discretes;
for (Index *idx = deps->begin (DEP_DISCRETE); !deps->end (DEP_DISCRETE); idx =
deps->next (DEP_DISCRETE))
{
if (discreteVariables.find (*idx) == discreteVariables.end ()
|| equation->lhs ().variableChange (algIndex))
{
Index discreteIndex = Index (
idx->applyVariableChange (
equation->lhs ().variableIndex (algIndex)));
discreteVariables[*idx] = *idx;
eqIndex.setOffset (_equationIndex++);
if (idx->hasRange () && eqIndex.hasRange ())
{
// X[i] = B[i];
derivativeDeps->insert (discreteIndex, eqIndex,
DEP_ALGEBRAIC_DISCRETE);
}
else if (!idx->hasRange () && eqIndex.hasRange ())
{
// X[i] = B[N];
derivativeDeps->insert (discreteIndex, eqIndex,
DEP_ALGEBRAIC_DISCRETE);
}
else if (idx->hasRange () && !eqIndex.hasRange ())
{
// X[N] = B[i];
derivativeDeps->insert (
discreteIndex.indexValue (
discreteIndex.value (discreteIndex.constant ())),
eqIndex, DEP_ALGEBRAIC_DISCRETE);
}
else if (!idx->hasRange () && !eqIndex.hasRange ())
{
// X[N] = B[N];
derivativeDeps->insert (discreteIndex, eqIndex,
DEP_ALGEBRAIC_DISCRETE);
}
}
}
for (Index *idx = deps->begin (DEP_STATE_VECTOR);
!deps->end (DEP_STATE_VECTOR); idx = deps->next (DEP_STATE_VECTOR))
{
derivativeDeps->insert (*idx, DEP_STATE_VECTOR);
}
for (Index *idx = deps->begin (DEP_DISCRETE_VECTOR);
!deps->end (DEP_DISCRETE_VECTOR); idx = deps->next (DEP_DISCRETE_VECTOR))
{
derivativeDeps->insert (*idx, DEP_DISCRETE_VECTOR);
}
_traverseAlgebraics (deps, derivativeIndex, derivativeDeps, states, discretes,
variableChange, DEP_ALGEBRAIC_DEF, value);
_traverseAlgebraics (deps, derivativeIndex, derivativeDeps, states, discretes,
variableChange, DEP_ALGEBRAIC_VECTOR_DEF, value);
}
void
MMO_Expression_::_traverseAlgebraics (Dependencies deps, Index derivativeIndex,
Dependencies derivativeDeps,
map<Index, Index> *states,
map<Index, Index> *discretes,
Index variableChange, DEP_Type type,
int value)
{
for (Index *idx = deps->begin (type); !deps->end (type);
idx = deps->next (type))
{
list<MMO_Equation> algEqs = _data->algebraics ()->equation (*idx);
list<MMO_Equation>::iterator algEq;
if (type == DEP_ALGEBRAIC_VECTOR_DEF)
{
derivativeDeps->insert (*idx, DEP_ALGEBRAIC_VECTOR);
}
int algValue = -1;
for (algEq = algEqs.begin (); algEq != algEqs.end (); algEq++)
{
Index algebraicIdx = *idx;
if (value >= 0 && idx->hasRange ())
{
algebraicIdx = idx->indexValue (value);
}
if (!(*algEq)->exp()->deps()->autonomous())
{
_deps->setAutonomous(false);
}
Index variableCh;
int f = (*algEq)->lhs ().factor ();
int c = (*algEq)->lhs ().operConstant ();
if (f != 0 && type == DEP_ALGEBRAIC_DEF)
{
if (f != 1 || c != 0)
{
variableCh.setFactor (f);
variableCh.setConstant (-c);
variableCh.setLow ((*algEq)->lhs ().low () * f + c);
variableCh.setHi ((*algEq)->lhs ().hi () * f + c);
}
}
Index algebraicIndex = (*algEq)->lhs ();
if (variableChange.isSet ())
{
algebraicIndex = (*algEq)->lhs ().applyVariableChange (
variableChange);
algebraicIdx = idx->applyVariableChange (variableChange);
algebraicIdx.setLow (variableChange.low ());
algebraicIdx.setHi (variableChange.hi ());
}
Intersection is = algebraicIndex.intersection (algebraicIdx);
if (is.type () != IDX_DISJOINT)
{
Index algKey = algebraicIdx;
Index equationIndex;
equationIndex.setOffset (_equationIndex++);
if (is.hasRange ())
{
equationIndex.setRange ();
equationIndex.setLow (is.low ());
equationIndex.setHi (is.hi ());
algKey.setRange ();
algKey.setHi (equationIndex.hi ());
algKey.setLow (equationIndex.low ());
}
else
{
equationIndex.setConstant (is.modelicaValue ());
if (is.type () == IDX_CONSTANT_BA)
{
algKey.setConstant (is.modelicaValue () + is.begin ());
algValue = is.modelicaValue ();
}
else if (is.type () == IDX_CONSTANT_AB)
{
algKey.setConstant (is.modelicaValue () + is.begin ());
algValue = is.modelicaValue ();
}
else
{
algKey.setConstant (is.modelicaValue ());
}
algKey.setLow (1);
algKey.setHi (1);
algKey.setFactor (0);
}
if (type == DEP_ALGEBRAIC_DEF)
{
derivativeDeps->insert (algKey, DEP_ALGEBRAIC);
}
_addAlgebriacDeps (algKey, (*algEq), equationIndex,
derivativeIndex, derivativeDeps, states,
discretes, variableCh, algValue);
}
}
}
}
