const SEM::Type* getBuiltInType(Context& context, const String& typeName, SEM::TypeArray templateArgs) { const auto& scopeStack = context.scopeStack(); const auto rootElement = scopeStack[0]; assert(rootElement.isNamespace()); const auto iterator = rootElement.nameSpace()->items().find(typeName); assert(iterator != rootElement.nameSpace()->items().end() && "Failed to find built-in type!"); const auto& value = iterator->second; assert(value.isTypeInstance() || value.isAlias()); SEM::ValueArray templateArgValues; templateArgValues.reserve(templateArgs.size()); const auto& templateVariables = (value.isTypeInstance() ? value.typeInstance().templateVariables() : value.alias().templateVariables()); for (size_t i = 0; i < templateArgs.size(); i++) { const auto& argVar = templateVariables[i]; const auto& argType = templateArgs[i]; templateArgValues.push_back(SEM::Value::TypeRef(argType, argVar->type()->createStaticRefType(argType))); } if (value.isTypeInstance()) { assert(templateArgs.size() == value.typeInstance().templateVariables().size()); return SEM::Type::Object(&(value.typeInstance()), std::move(templateArgValues)); } else { assert(templateArgs.size() == value.alias().templateVariables().size()); return SEM::Type::Alias(value.alias(), std::move(templateArgValues)); } }
const AST::Namespace& GlobalStructure::nextNamespace() const { auto next = this; while (!next->isNamespace()) { next = &(next->parent()); } return next->nameSpace(); }
int main(int argc, char* argv[]) { Object* ns = 0; esInit(&ns); Iso9660FileSystem::initializeConstructor(); Handle<es::Context> nameSpace(ns); #ifdef __es__ Handle<es::Stream> disk = nameSpace->lookup("device/ata/channel1/device0"); #else es::Stream* disk = new VDisk(static_cast<char*>("isotest.iso")); #endif TEST(disk); long long diskSize; diskSize = disk->getSize(); esReport("diskSize: %lld\n", diskSize); TEST(0 < diskSize); Handle<es::FileSystem> isoFileSystem; isoFileSystem = es::Iso9660FileSystem::createInstance(); TEST(isoFileSystem); isoFileSystem->mount(disk); { Handle<es::Context> root; root = isoFileSystem->getRoot(); TEST(root); test(root); } isoFileSystem->dismount(); esReport("done.\n"); }
int main(void) { Object* ns = 0; esInit(&ns); FatFileSystem::initializeConstructor(); Handle<es::Context> nameSpace(ns); #ifdef __es__ Handle<es::Stream> disk = nameSpace->lookup("device/ata/channel0/device0"); #else Handle<es::Stream> disk = new VDisk(static_cast<char*>("fat32.img")); #endif long long diskSize; diskSize = disk->getSize(); esReport("diskSize: %lld\n", diskSize); Handle<es::FileSystem> fatFileSystem; long long freeSpace; long long totalSpace; fatFileSystem = es::FatFileSystem::createInstance(); fatFileSystem->mount(disk); fatFileSystem->format(); freeSpace = fatFileSystem->getFreeSpace(); totalSpace = fatFileSystem->getTotalSpace(); esReport("Free space %lld, Total space %lld\n", freeSpace, totalSpace); { Handle<es::Context> root; root = fatFileSystem->getRoot(); long ret = TestFileSystem(root); TEST (ret == 0); freeSpace = fatFileSystem->getFreeSpace(); totalSpace = fatFileSystem->getTotalSpace(); esReport("Free space %lld, Total space %lld\n", freeSpace, totalSpace); esReport("\nChecking the file system...\n"); TEST(fatFileSystem->checkDisk(false)); } fatFileSystem->dismount(); fatFileSystem = 0; fatFileSystem = es::FatFileSystem::createInstance(); fatFileSystem->mount(disk); freeSpace = fatFileSystem->getFreeSpace(); totalSpace = fatFileSystem->getTotalSpace(); esReport("Free space %lld, Total space %lld\n", freeSpace, totalSpace); esReport("\nChecking the file system...\n"); TEST(fatFileSystem->checkDisk(false)); fatFileSystem->dismount(); fatFileSystem = 0; esReport("done.\n\n"); }
const SEM::Type* getBuiltInTypeWithValueArgs(Context& context, const String& typeName, SEM::ValueArray templateArgValues) { const auto& scopeStack = context.scopeStack(); const auto rootElement = scopeStack[0]; assert(rootElement.isNamespace()); const auto iterator = rootElement.nameSpace()->items().find(typeName); if (iterator == rootElement.nameSpace()->items().end()) { throw std::runtime_error(makeString("Failed to find built-in type '%s'.", typeName.c_str())); } const auto& value = iterator->second; assert(value.isTypeInstance() || value.isAlias()); if (value.isTypeInstance()) { assert(templateArgValues.size() == value.typeInstance().templateVariables().size()); return SEM::Type::Object(&(value.typeInstance()), std::move(templateArgValues)); } else { assert(templateArgValues.size() == value.alias().templateVariables().size()); return SEM::Type::Alias(value.alias(), std::move(templateArgValues)); } }
bool QQmlMetaType::namespaceContainsRegistrations(const QString &uri) { QQmlMetaTypeData *data = metaTypeData(); // Has any type previously been installed to this namespace? QHashedString nameSpace(uri); foreach (const QQmlType *type, data->types) if (type->module() == nameSpace) return true; return false; }
const GlobalStructure& GlobalStructure::parent() const { switch (kind()) { case ALIAS: return alias().parent(); case NAMESPACE: return nameSpace().parent(); case TYPEINSTANCE: return typeInstance().parent(); } locic_unreachable("Unknown GlobalStructure kind."); }
int main(int argc, char* argv[]) { Object* ns = 0; esInit(&ns); Iso9660FileSystem::initializeConstructor(); Handle<es::Context> nameSpace(ns); #ifdef __es__ Handle<es::Stream> disk = nameSpace->lookup("device/ata/channel1/device0"); #else es::Stream* disk = new VDisk(static_cast<char*>("isotest.iso")); #endif TEST(disk); long long diskSize; diskSize = disk->getSize(); esReport("diskSize: %lld\n", diskSize); TEST(0 < diskSize); Handle<es::FileSystem> isoFileSystem; isoFileSystem = es::Iso9660FileSystem::createInstance(); TEST(isoFileSystem); isoFileSystem->mount(disk); { Handle<es::Context> root; root = isoFileSystem->getRoot(); TEST(root); Handle<es::Binding> binding = root; TEST(binding); Handle<Object> interface = binding->getObject(); TEST(interface); Handle<es::Context> object = interface; TEST(object); TEST(object == root); // setObject() must return an exception. try { binding->setObject(interface); TEST(false); } catch (Exception& error) { } } isoFileSystem->dismount(); esReport("done.\n"); }
bool Function::isVirtual() const { if (_flags & FN_VIRTUAL) { return true; } else if (isDestructor()) { Struct* pClass = dynamic_cast<Struct*>(nameSpace()); return pClass && pClass->hasVirtualDestructor(); } else return getOverridden() != 0; return false; }
void UNIX_ApplicationSystemDirectoryFixture::Run() { CIMName className("UNIX_ApplicationSystemDirectory"); CIMNamespaceName nameSpace("root/cimv2"); UNIX_ApplicationSystemDirectory _p; UNIX_ApplicationSystemDirectoryProvider _provider; Uint32 propertyCount; CIMOMHandle omHandle; _provider.initialize(omHandle); _p.initialize(); for(int pIndex = 0; _p.load(pIndex); pIndex++) { CIMInstance instance = _provider.constructInstance(className, nameSpace, _p); CIMObjectPath path = instance.getPath(); cout << path.toString() << endl; propertyCount = instance.getPropertyCount(); for(Uint32 i = 0; i < propertyCount; i++) { CIMProperty propertyItem = instance.getProperty(i); if (propertyItem.getType() == CIMTYPE_REFERENCE) { CIMValue subValue = propertyItem.getValue(); CIMInstance subInstance; subValue.get(subInstance); CIMObjectPath subPath = subInstance.getPath(); cout << " Name: " << propertyItem.getName().getString() << ": " << subPath.toString() << endl; Uint32 subPropertyCount = subInstance.getPropertyCount(); for(Uint32 j = 0; j < subPropertyCount; j++) { CIMProperty subPropertyItem = subInstance.getProperty(j); cout << " Name: " << subPropertyItem.getName().getString() << " - Value: " << subPropertyItem.getValue().toString() << endl; } } else { cout << " Name: " << propertyItem.getName().getString() << " - Value: " << propertyItem.getValue().toString() << endl; } } cout << "------------------------------------" << endl; cout << endl; } _p.finalize(); }
Function* Function::getOverridden() const { if (isMethod() && !(_flags & FN_STATIC)) { Struct* pClass = dynamic_cast<Struct*>(nameSpace()); if (pClass) { for (Struct::BaseIterator it = pClass->baseBegin(); it != pClass->baseEnd(); ++it) { if (it->pClass) { Function* pOverridden = it->pClass->findFunction(signature()); if (pOverridden && pOverridden->isVirtual()) return pOverridden; } } } } return 0; }
int main(int argc, char* argv[]) { Object* ns = 0; esInit(&ns); Handle<es::Context> nameSpace(ns); Handle<es::Context> classStore(nameSpace->lookup("class")); Handle<es::Stream> disk = nameSpace->lookup("device/ata/channel0/device0"); long long diskSize; diskSize = disk->getSize(); esReport("diskSize: %lld\n", diskSize); Handle<es::FileSystem> fatFileSystem; long long freeSpace; long long totalSpace; fatFileSystem = es::FatFileSystem::createInstance(); fatFileSystem->mount(disk); { Handle<es::Context> root; root = fatFileSystem->getRoot(); nameSpace->bind("file", root); test(nameSpace); freeSpace = fatFileSystem->getFreeSpace(); totalSpace = fatFileSystem->getTotalSpace(); esReport("Free space %lld, Total space %lld\n", freeSpace, totalSpace); nameSpace->unbind("file"); } fatFileSystem->dismount(); fatFileSystem = 0; esSleep(10000000); esReport("done.\n"); }
int CXslTransform::setExternalFunction(const char* pszNameSpace, IXslFunction* pXslFunction, bool set) { CXslFunction* pFn = (CXslFunction*) pXslFunction; if (pFn == NULL || pFn->get() == NULL) throw MakeStringException(-1, "Null pointer violation in CXslTransform::setExternalFunction."); XalanDOMString nameSpace(pszNameSpace); XalanDOMString functionName(pFn->getName()); bool bAssigned = pFn->isAssigned(); if (set && !bAssigned) m_XalanTransformer.installExternalFunction(nameSpace, functionName, *pFn->get()); else { if (!set && bAssigned) m_XalanTransformer.uninstallExternalFunction(nameSpace, functionName); else throw MakeStringException(-1, "XSLT external function assignment error!"); } pFn->setAssigned(set); return 0; }
Symbol* NameSpace::lookup(const std::string& name, std::set<const NameSpace*>& alreadyVisited) const { Symbol* pSymbol = 0; if (name.empty()) return pSymbol; if (alreadyVisited.find(this) != alreadyVisited.end()) return pSymbol; std::string head; std::string tail; splitName(name, head, tail); alreadyVisited.insert(this); bool currentNSInserted = true; if (head.empty()) { alreadyVisited.insert(this); return root()->lookup(tail, alreadyVisited); } SymbolTable::const_iterator it = _symbols.find(head); if (it != _symbols.end()) { pSymbol = it->second; if (!tail.empty()) { alreadyVisited.insert(this); NameSpace* pNS = dynamic_cast<NameSpace*>(pSymbol); if (pNS) pSymbol = static_cast<NameSpace*>(pSymbol)->lookup(tail, alreadyVisited); else pSymbol = 0; } } else if (tail.empty()) { AliasMap::const_iterator itAlias = _importedSymbols.find(head); if (itAlias != _importedSymbols.end()) pSymbol = lookup(itAlias->second, alreadyVisited); else { for (NameSpaceVec::const_iterator it = _importedNameSpaces.begin(); !pSymbol && it != _importedNameSpaces.end(); ++it) { Symbol* pNS = lookup(*it, alreadyVisited); if (pNS && pNS->kind() == Symbol::SYM_NAMESPACE) { pSymbol = static_cast<NameSpace*>(pNS)->lookup(name, alreadyVisited); } } } } NameSpace* pNS = nameSpace(); if (!pSymbol && pNS && (alreadyVisited.find(pNS) == alreadyVisited.end())) { // if we have to go up, never push the NS! if (currentNSInserted) alreadyVisited.erase(this); pSymbol = nameSpace()->lookup(name, alreadyVisited); } return pSymbol; }
int main(void) { Object* ns = 0; esInit(&ns); FatFileSystem::initializeConstructor(); Handle<es::Context> nameSpace(ns); #ifdef __es__ Handle<es::Stream> disk = nameSpace->lookup("device/ata/channel0/device0"); #else Handle<es::Stream> disk = new VDisk(static_cast<char*>("fat16_5MB.img")); #endif long long diskSize; diskSize = disk->getSize(); esReport("diskSize: %lld\n", diskSize); Handle<es::FileSystem> fatFileSystem; long long freeSpace; long long totalSpace; fatFileSystem = es::FatFileSystem::createInstance(); fatFileSystem->mount(disk); fatFileSystem->format(); freeSpace = fatFileSystem->getFreeSpace(); totalSpace = fatFileSystem->getTotalSpace(); esReport("Free space %lld, Total space %lld\n", freeSpace, totalSpace); { Handle<es::Context> root; root = fatFileSystem->getRoot(); Handle<es::Binding> binding = root; TEST(binding); Handle<Object> interface = binding->getObject(); TEST(interface); Handle<es::Context> object = interface; TEST(object); TEST(object == root); long ret = TestFileSystem(object); TEST(ret == 0); // setObject() must return an exception. try { binding->setObject(interface); TEST(false); } catch (Exception& error) { } } fatFileSystem->dismount(); fatFileSystem = 0; fatFileSystem = es::FatFileSystem::createInstance(); fatFileSystem->mount(disk); freeSpace = fatFileSystem->getFreeSpace(); totalSpace = fatFileSystem->getTotalSpace(); esReport("Free space %lld, Total space %lld\n", freeSpace, totalSpace); esReport("\nChecking the file system...\n"); TEST(fatFileSystem->checkDisk(false)); fatFileSystem->dismount(); fatFileSystem = 0; esReport("done.\n\n"); }
void emulInit(int32_t argc, char **argv, char **envp){ FileSys::Node::insert("/dev/null",new FileSys::NullNode()); FileSys::Node::insert("/dev/tty",0); FileSys::Description *inDescription=0; FileSys::Description *outDescription=0; FileSys::Description *errDescription=0; extern char *optarg; int32_t opt; while((opt=getopt(argc, argv, "+hi:o:e:"))!=-1){ switch(opt){ case 'i': inDescription=FileSys::Description::open(optarg,O_RDONLY,S_IRUSR); if(!inDescription) fail("Could not open `%s' as simulated stdin file\n",optarg); break; case 'o': outDescription=FileSys::Description::open(optarg,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR); if(!outDescription) fail("Could not open `%s' as simulated stdout file\n",optarg); break; case 'e': errDescription=FileSys::Description::open(optarg,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR); if(!errDescription) fail("Could not open `%s' as simulated stderr file %s\n",optarg); break; case 'h': default: fail("\n" "Usage: %s [EmulOpts] [-- SimOpts] AppExec [AppOpts]\n" " EmulOpts:\n" " [-i FName] Use file FName as stdin for AppExec\n" " [-o FName] Use file FName as stdout for AppExec\n" " [-e FName] Use file FName as stderr for AppExec\n", argv[0]); } } if(!inDescription){ inDescription=FileSys::TtyDescription::wrap(STDIN_FILENO); if(!inDescription) fail("Could not wrap stdin\n"); } if(!outDescription){ outDescription=FileSys::TtyDescription::wrap(STDOUT_FILENO); if(!outDescription) fail("Could not wrap stdout\n"); } if(!errDescription){ errDescription=FileSys::TtyDescription::wrap(STDERR_FILENO); if(!errDescription) fail("Could not wrap stderr\n"); } int32_t appArgc=argc-optind; char **appArgv=&(argv[optind]); char **appEnvp=envp; // Count environment variables int32_t appEnvc=0; while(appEnvp[appEnvc]) appEnvc++; FileSys::NameSpace::pointer nameSpace(new FileSys::NameSpace(SescConf->getCharPtr("FileSys","mount"))); char hostCwd[PATH_MAX]; if(getcwd(hostCwd,PATH_MAX)==0) fail("emulInit: Failed to get host current directory (getcwd)\n"); const string targetCwd(nameSpace->toTarget(nameSpace->normalize("/",hostCwd))); FileSys::FileSys::pointer fileSys(new FileSys::FileSys(nameSpace,targetCwd)); const string exeLinkName(fileSys->toHost(appArgv[0])); const string exeRealName(FileSys::Node::resolve(exeLinkName)); if(exeRealName.empty()) fail("emulInit: Link loop when executable %s\n",exeLinkName.c_str()); FileSys::Node *node=FileSys::Node::lookup(exeRealName); if(!node) fail("emulInit: Executable %s does not exist\n",exeLinkName.c_str()); FileSys::FileNode *fnode=dynamic_cast<FileSys::FileNode *>(node); if(!fnode) fail("emulInit: Executable %s is not a regular file\n",exeLinkName.c_str()); FileSys::FileDescription *fdesc=new FileSys::FileDescription(fnode,O_RDONLY); FileSys::Description::pointer pdesc(fdesc); ThreadContext *mainThread=new ThreadContext(fileSys); // TODO: Use ELF_ET_DYN_BASE instead of a constant here loadElfObject(mainThread,fdesc,0x200000); mainThread->getSystem()->initSystem(mainThread); mainThread->getSystem()->createStack(mainThread); mainThread->getSystem()->setProgArgs(mainThread,appArgc,appArgv,appEnvc,appEnvp); FileSys::OpenFiles *openFiles=mainThread->getOpenFiles(); openFiles->openDescriptor(STDIN_FILENO,inDescription); openFiles->openDescriptor(STDOUT_FILENO,outDescription); openFiles->openDescriptor(STDERR_FILENO,errDescription); }
bool Function::isConstructor() const { return name() == nameSpace()->name(); }
bool Function::isFunction() const { return nameSpace()->kind() == Symbol::SYM_NAMESPACE; }
bool Function::isMethod() const { return !isConstructor() && !isDestructor() && nameSpace()->kind() == Symbol::SYM_STRUCT; }