virtual uint cleanupModules() { std::vector<ModIter> undead; for ( ModIter it = mods.begin(); it != mods.end(); ++it ) { uint n = 0; const char * s = it->first; Dll * d = it->second; ClassInfo *info = d->getClassInfo(); while ( info && info->iname ) { n += info->count(); ++info; } if ( n==0 ) { printf( "undead : %s\n", s ); undead.push_back( it ); } } for ( uint i=0; i<undead.size(); i++ ) { ModIter it = undead[i]; printf( "kill : %s\n", it->first ); Dll * d = it->second; E_DELETE( d ); mods.erase( it ); } return 1; }
virtual ~CEngine() { $X1("del()"); for ( ModIter it = mods.begin(); it != mods.end(); ++it ) { const char * s = it->first; Dll * d = it->second; ClassInfo *info = d->getClassInfo(); char b[300]; char b1[1024]; bool alive=0; b[0] = b1[0] = 0; while ( info->iname ) { if ( info->count() ) { alive=1; sprintf( b, "%s %i instances of %s alive !\n", info->cname, info->count(), info->iname ); strcat( b1, b ); } ++info; } if ( alive ) sys::alert("ref trouble !", b1 ); E_DELETE( d ); } }
virtual uint findInterfaces( const char * interfaceName, InterfaceCallback & finder ) { uint n = 0; for ( ModIter it = mods.begin(); it != mods.end(); ++it ) { const char * s = it->first; Dll * d = it->second; ClassInfo *info = d->getClassInfo(); while ( info && info->iname ) { if ( ! strcmp( interfaceName, "*" ) ) // selected 'All' { uint r = finder.call( info->iname, info->cname, info->count() ); n ++; } else if ( ! strcmp( interfaceName, info->iname ) ) { uint r = finder.call( info->iname, info->cname, info->count() ); n ++; } ++ info; } } return n; }
int HybridBase::class__index(lua_State *L) { SLB_DEBUG_CALL; SLB_DEBUG_CLEAN_STACK(L,+1); SLB_DEBUG_STACK(6, L, "Call class__index"); // trying to traverse the class... create a new InternalHybridSubclass ClassInfo *ci = Manager::getInstance().getClass(L,1); if (ci == 0) luaL_error(L, "Expected a valid class."); luaL_checkstring(L,2); // only valid with strings if (!ci->hasConstructor()) { luaL_error(L, "Hybrid Class(%s) doesn't have constructor." " You can not subclass(%s) from it", ci->getName().c_str(), lua_tostring(L,2)); } ref_ptr<InternalHybridSubclass> subc = new InternalHybridSubclass(ci); subc->push(L); // -- set cache... lua_pushvalue(L,2); // [+1] key lua_pushvalue(L,-2); // [+1] copy of new InternalHybrid... ci->setCache(L); // [-2] keep a copy in the cache // -- set cache done return 1; }
const HybridBase* get_hybrid(lua_State *L, int pos) { SLB_DEBUG_CALL; //TODO: Generalize this to be used in all SLB const HybridBase *obj = get<const HybridBase*>(L,pos); if (!obj) { if (lua_type(L,pos) == LUA_TUSERDATA) { void *dir = lua_touserdata(L,pos); // try to get the class info: ClassInfo *ci = Manager::getInstance().getClass(L,pos); if (ci == 0) { luaL_error(L, "Invalid Hybrid object (index=%d) " "'%s' %p", pos, ci->getName().c_str(), dir); } else { luaL_error(L, "Invalid Hybrid object (index=%d) " "userdata (NOT REGISTERED WITH SLB) %p", pos, dir); } } else { luaL_error(L, "Invalid Hybrid object (index=%d) found %s", pos, luaL_typename(L,pos)); } } return obj; }
bool HybridBase::getMethod(const char *name) const { SLB_DEBUG_CALL; if (_L == 0) throw std::runtime_error("Hybrid instance not attached");\ SLB_DEBUG_STACK(5,_L, "HybridBase(%p)::getMethod '%s' (_L = %p)", this, name, _L); int top = lua_gettop(_L); // first try to find in _subclassMethods if (_subclassMethods.valid()) { //TODO: NEED DEBUG... // ---- why not: // Object *m = obj->_subclassMethods->get(key); // if (m) // { // SLB_DEBUG(5, "Hybrid subclassed instance, looking for '%s' method [OK]", key); // m->push(L); // return 1; // } // else SLB_DEBUG(5, "Hybrid subclassed instance, looking for '%s' method [FAIL!]", key); // ---- instead of: (even though this is quicker) but code above should work lua_pushstring(_L,name); // [+1] _subclassMethods->getCache(_L); // [-1, +1] will pop key's copy and return the cache if (!lua_isnil(_L,-1)) { assert("Invalid Stack" && (lua_gettop(_L) == top+1)); return true; } lua_pop(_L,1); // [-1] remove nil assert("Invalid Stack" && (lua_gettop(_L) == top)); //end TODO------------------------------------------------------------------------------- } ClassInfo *ci = getClassInfo(); ci->push(_L); lua_getmetatable(_L,-1); lua_getfield(_L,-1, "__hybrid"); if (!lua_isnil(_L,-1)) { lua_pushstring(_L,name); lua_rawget(_L,-2); if (!lua_isnil(_L,-1)) { lua_replace(_L,top+1); lua_settop(_L,top+1); SLB_DEBUG(6, "HybridBase(%p-%s)::getMethod '%s' (_L = %p) -> FOUND", this, ci->getName().c_str(),name, _L); assert("Invalid Stack" && (lua_gettop(_L) == top+1)); return true; } else SLB_DEBUG(6, "HybridBase(%p-%s)::getMethod '%s' (_L = %p) -> *NOT* FOUND", this,ci->getName().c_str(), name, _L); } else SLB_DEBUG(4, "HybridBase(%p-%s) do not have any hybrid methods", this, ci->getName().c_str()); // anyway... if not found: lua_settop(_L,top); return false; }
Model::EntityDefinition* DefParser::nextDefinition() { Token token = m_tokenizer.nextToken(); while (token.type() != Eof && token.type() != ODefinition) token = m_tokenizer.nextToken(); if (token.type() == Eof) return NULL; expect(ODefinition, token); StringList baseClasses; ClassInfo classInfo; token = m_tokenizer.nextToken(); expect(Word, token); classInfo.name = token.data(); token = m_tokenizer.peekToken(); expect(OParenthesis | Newline, token); if (token.type() == OParenthesis) { classInfo.setColor(parseColor()); token = m_tokenizer.peekToken(); expect(OParenthesis | Question, token); if (token.type() == OParenthesis) { classInfo.setSize(parseBounds()); } else { m_tokenizer.nextToken(); } token = m_tokenizer.peekToken(); if (token.type() == Word) { Model::FlagsPropertyDefinition::Ptr spawnflags = parseFlags(); classInfo.properties[spawnflags->name()] = spawnflags; } } expect(Newline, token = m_tokenizer.nextToken()); parseProperties(classInfo.properties, classInfo.models, baseClasses); classInfo.setDescription(parseDescription()); expect(CDefinition, token = m_tokenizer.nextToken()); Model::EntityDefinition* definition = NULL; if (classInfo.hasColor) { ClassInfo::resolveBaseClasses(m_baseClasses, baseClasses, classInfo); if (classInfo.hasSize) { // point definition definition = new Model::PointEntityDefinition(classInfo.name, classInfo.color, classInfo.size, classInfo.description, classInfo.propertyList(), classInfo.models); } else { definition = new Model::BrushEntityDefinition(classInfo.name, classInfo.color, classInfo.description, classInfo.propertyList()); } } else { // base definition m_baseClasses[classInfo.name] = classInfo; definition = nextDefinition(); } return definition; }
QString SqlDbBackend::expandDotsString( const QString& string ) { QString className; QString relationName; QString expanded; QStringList tables; assert( string.contains( "." ) ); Tokenizer tokenizer( string, "." ); className = tokenizer.nextToken(); relationName = tokenizer.nextToken(); tables << className; do { if ( ! Classes::contains( className ) ) { kdDebug() << k_funcinfo << "Class '" << className << "' not found." << endl; return string; } ClassInfo *classInfo = Classes::classInfo( className ); if ( classInfo->containsObject( relationName ) ) { RelationInfo *rel = classInfo->object( relationName ); if ( rel->isOneToOne() ) { expanded += className + "." + relationName + "="; expanded += rel->relatedClassInfo()->name() + "." + oidFieldName() + " AND "; className=rel->relatedClassInfo()->name(); } else { expanded += className + "." + relationName + "="; expanded += rel->relatedClassInfo()->name() + "." + oidFieldName() + " AND "; className=rel->relatedClassInfo()->name(); } } else if ( classInfo->containsCollection( relationName ) ) { CollectionInfo *rel = classInfo->collection( relationName ); if ( rel->isNToOne() ) { expanded += className + "." + oidFieldName() + "="; expanded += rel->childrenClassInfo()->name() + "." + relationName + " AND "; className=rel->childrenClassInfo()->name(); } else { expanded += className + "." + oidFieldName() + "="; expanded += relationName + "." + className + " AND "; expanded += relationName + "." + rel->childrenClassInfo()->name() + "="; expanded += rel->childrenClassInfo()->name() + "." + oidFieldName() + " AND "; className = rel->childrenClassInfo()->name(); } } else { kdDebug() << k_funcinfo << "Class '" << className << "' doesn't contain any relation named '" << relationName << "'" << endl; expanded += className + "." + tokenizer.tail(); kdDebug() << k_funcinfo << "Expanded string: " << expanded << endl; return expanded; } relationName = tokenizer.nextToken(); tables << className; } while ( ! relationName.isNull() ); expanded += className + "." + tokenizer.tail() + " "; kdDebug() << k_funcinfo << "Expanded string: " << expanded << endl; kdDebug() << k_funcinfo << "Tables: " << tables << endl; return expanded; }
static folly::Optional<ClassInfo> commonAncestor(ClassInfo a, ClassInfo b) { if (!isNormalClass(a.get()) || !isNormalClass(b.get())) return folly::none; if (auto result = a.get()->commonAncestor(b.get())) { return ClassInfo(result, ClassTag::Sub); } return folly::none; }
ref_t ModuleScope :: loadClassInfo(ClassInfo& info, ident_t vmtName, bool headerOnly) { _Module* argModule = NULL; if (emptystr(vmtName)) return 0; if (isTemplateWeakReference(vmtName)) { // COMPILER MAGIC : try to find a template ref_t ref = loadClassInfo(info, resolveWeakTemplateReference(vmtName + TEMPLATE_PREFIX_NS_LEN), headerOnly); if (ref != 0 && info.header.classRef != 0) { if (module->resolveReference(info.header.classRef).endsWith(CLASSCLASS_POSTFIX)) { // HOTFIX : class class ref should be template weak reference as well IdentifierString classClassName(vmtName, CLASSCLASS_POSTFIX); info.header.classRef = module->mapReference(classClassName); } } return ref; } else { // load class meta data ref_t moduleRef = 0; if (isWeakReference(vmtName)) { // if it is a weak reference - do not need to resolve the module argModule = module; moduleRef = module->mapReference(vmtName); } else argModule = project->resolveModule(vmtName, moduleRef, true); if (argModule == NULL || moduleRef == 0) return 0; // load argument VMT meta data _Memory* metaData = argModule->mapSection(moduleRef | mskMetaRDataRef, true); if (metaData == NULL || metaData->Length() == sizeof(SymbolExpressionInfo)) return 0; MemoryReader reader(metaData); if (argModule != module) { ClassInfo copy; copy.load(&reader, headerOnly); importClassInfo(copy, info, argModule, headerOnly, false, false); } else info.load(&reader, headerOnly); if (argModule != module) { // import reference importReference(argModule, moduleRef, module); } return moduleRef; } }
virtual void * createInterface( const char * moduleName, const char * interfaceName ) { E_ASSERT(moduleName); E_ASSERT(interfaceName); // std::cerr << __FUNCTION__ << " (" << moduleName << ", " << interfaceName << ")\n"; ModIter it = mods.find( moduleName ); bool found = 0; do // once { if ( it != mods.end() ) { found = true; break; } if ( ! loadDll ( moduleName ) ) { // sys::alert( __FUNCTION__, "mod not found %s :: %s", moduleName, interfaceName ); break; } it = mods.find( moduleName ); if ( it == mods.end() ) { sys::alert( __FUNCTION__, "mod not inserted %s :: %s", moduleName, interfaceName ); break; } found = true; } while(0); // do once if ( ! found ) { return 0; } Dll* h = it->second; ClassInfo * info = h->getClassInfo( ); if ( ! info ) { sys::alert( __FUNCTION__, "ClassInfo not found %s :: %s", moduleName, interfaceName ); return 0; } while ( info && info->cname ) { if ( ! strcmp( info->iname, interfaceName ) ) { return info->create(); } ++ info; } sys::alert( __FUNCTION__, "could not create %s :: %s", moduleName, interfaceName ); return 0; }
void showDll(Dll * d, const char * s) { const ModVersion *mv = d->getVersion(); std::cerr << "< " << mv->modVersion << " : " << mv->e6Version << " >\n"; ClassInfo *info = d->getClassInfo(); while ( info && info->iname ) { std::cerr << "\t" << info->cname << (strlen(info->cname)<8?"\t\t":"") ; std::cerr << "\t" << info->iname << (strlen(info->iname)<8?"\t\t":"") ; std::cerr << "\t" << info->count() << "\n"; ++ info; } }
void ScriptSystem::registerClass(const String& self, const String& base) { ClassInfoDict::iterator it = m_classInfoReg.find(self); if (it != m_classInfoReg.end()) { Errorf("Class already registered"); } ClassInfo* classInfo = new ClassInfo; classInfo->m_className = self; classInfo->m_baseClassName = base; classInfo->m_typeInfo = 0; m_classInfoReg[self] = classInfo; classInfo->initScriptProps(); }
void VarDef::globalGen() { ClassInfo *classInfo = typeDecl->getClassInfo(); Constant *initial = classInfo->getInitial(); for (unsigned i = 0; i < varInitList.size(); i++) { VarInit *varInit = varInitList[i]; Value *llvmVar = new GlobalVariable(module, classInfo->llvmType, false, GlobalValue::ExternalLinkage, initial); AstContext astContext; if (varInit->expr != NULL) { varInit->expr->expectedType = classInfo; AValue v = varInit->expr->codeGen(astContext); builder.CreateStore(v.llvmValue, llvmVar); } globalContext.addVar(varInit->varName, AValue(llvmVar, classInfo)); } }
AValue DynamicCast::gen(AstContext &astContext) { ClassInfo *destClass = typeDecl->getClassInfo(); AValue v = expr->codeGen(astContext); if (v.castTo(destClass)) { return v; } else if (v.isObject() && destClass->isObjectType()) { v.llvmValue = builder.CreateCall2(sysDynamicCast, v.llvmValue, destClass->info); v.clazz = destClass; return v; } else { errorMsg = "no viable conversion from '" + v.clazz->name + "' to '" + destClass->name + "'"; throwError(expr); } return v; }
AValue InstanceOf::gen(AstContext &astContext) { AValue v = expr->codeGen(astContext); ClassInfo *destClass = typeDecl->getClassInfo(); if (v.clazz == nilClass && (destClass->isObjectType() || destClass->isArrayType())) { return AValue(bool_true, boolClass); } else if (v.clazz->isSubClassOf(destClass)) { return AValue(bool_true, boolClass); } else if (destClass->isObjectType() && v.isObject()) { Value *res = builder.CreateCall2(sysInstanceOf, v.llvmValue, destClass->info); res = builder.CreateTrunc(res, boolType); return AValue(res, boolClass); } else { return AValue(bool_false, boolClass); } }
Object *ClassDB::instance(const StringName &p_class) { ClassInfo *ti; { OBJTYPE_RLOCK; ti = classes.getptr(p_class); if (!ti || ti->disabled || !ti->creation_func) { if (compat_classes.has(p_class)) { ti = classes.getptr(compat_classes[p_class]); } } ERR_FAIL_COND_V(!ti, NULL); ERR_FAIL_COND_V(ti->disabled, NULL); ERR_FAIL_COND_V(!ti->creation_func, NULL); } return ti->creation_func(); }
bool STDCALL OBS::ConfigGlobalSource(XElement *element, bool bCreating) { XElement *data = element->GetElement(TEXT("data")); CTSTR lpGlobalSourceName = data->GetString(TEXT("name")); XElement *globalSources = App->scenesConfig.GetElement(TEXT("global sources")); if(!globalSources) //shouldn't happen return false; XElement *globalSourceElement = globalSources->GetElement(lpGlobalSourceName); if(!globalSourceElement) //shouldn't happen return false; CTSTR lpClass = globalSourceElement->GetString(TEXT("class")); ClassInfo *classInfo = App->GetImageSourceClass(lpClass); if(!classInfo) //shouldn't happen return false; if(classInfo->configProc) { if(!classInfo->configProc(globalSourceElement, bCreating)) return false; element->SetInt(TEXT("cx"), globalSourceElement->GetInt(TEXT("cx"))); element->SetInt(TEXT("cy"), globalSourceElement->GetInt(TEXT("cy"))); if(App->bRunning) { for(UINT i=0; i<App->globalSources.Num(); i++) { GlobalSourceInfo &info = App->globalSources[i]; if(info.strName.CompareI(lpGlobalSourceName) && info.source) { info.source->UpdateSettings(); break; } } } } return true; }
void DataSourceInterface::assignId(DataSourceEntityMapping& dsemp, ClassInfo& clas, void* entity) { GenericObject idv; next(dsemp, idv); if(!idv.isNull()) { Field fld = clas.getField(dsemp.getIdPropertyName()); vector<void *> valus; if(GenericObject::isNumber32(idv.getTypeName()) && GenericObject::isNumber(fld.getType())) { long* id; idv.get(id); valus.push_back(id); } else if(GenericObject::isNumber64(idv.getTypeName()) && GenericObject::isNumber(fld.getType())) { long long* id; idv.get(id); valus.push_back(id); } else if(GenericObject::isFPN(idv.getTypeName()) && GenericObject::isFPN(fld.getType())) { long double* id; idv.get(id); valus.push_back(id); } else if(GenericObject::isString(idv.getTypeName()) && GenericObject::isString(fld.getType())) { string* id; idv.set(id); valus.push_back(id); } else { throw "Data-Source-Object/Entity types do not match for id property" + dsemp.getClassName() + ":" + dsemp.getIdPropertyName(); } args argus; argus.push_back(fld.getType()); string methname = "set"+StringUtil::capitalizedCopy(fld.getFieldName()); Method meth = clas.getMethod(methname,argus); reflector->invokeMethodGVP(entity,meth,valus); } }
void VarDef::codeGen(AstContext &astContext) { ClassInfo *classInfo = typeDecl->getClassInfo(); for (unsigned i = 0; i < varInitList.size(); i++) { VarInit *varInit = varInitList[i]; Value *value = NULL; if (varInit->expr != NULL) { varInit->expr->expectedType = classInfo; AValue v = varInit->expr->codeGen(astContext); value = v.llvmValue; } else { value = classInfo->getInitial(); } Value *var = createAlloca(classInfo->llvmType, astContext.allocBB); if (!astContext.addVar(varInit->varName, AValue(var, classInfo))) { throwError(varInit); } builder.CreateStore(value, var); } }
/*--- Invalid Method (exception) ----------------------------------------------*/ InvalidMethod::InvalidMethod(const HybridBase *obj, const char *c) { SLB_DEBUG_CALL; lua_State *L = obj->getLuaState(); const ClassInfo *CI = obj->getClassInfo(); std::ostringstream out; lua_Debug debug; out << "Invalid Method '" << CI->getName() << "::" << c << "' NOT FOUND!" << std::endl; out << "TraceBack:" << std::endl; for ( int level = 0; lua_getstack(L, level, &debug ); level++) { if (lua_getinfo(L, "Sln", &debug) ) { //TODO use debug.name and debug.namewhat //make this more friendly out << "\t [ " << level << " (" << debug.what << ") ] "; if (debug.currentline > 0 ) { out << debug.short_src << ":" << debug.currentline; if (debug.name) out << " @ " << debug.name << "(" << debug.namewhat << ")"; } out << std::endl; } else { out << "[ERROR using Lua DEBUG INTERFACE]" << std::endl; } } out << "Current Stack:" << std::endl; for(int i = 1; i < lua_gettop(L); ++i) { out << "\t ["<<i<<"] " << lua_typename(L, lua_type(L,i)) << " : "<< lua_tostring(L,i) ; ClassInfo *ci = Manager::getInstance().getClass(L,i); if (ci) out << "->" << ci->getName(); out << std::endl; } _what = out.str(); }
void FilterHandler::handleIn(HttpRequest* req, HttpResponse& res, map<string, vector<string> > filterMap, void* dlib, string ext) { Logger logger = Logger::getLogger("FilterHandler"); if(filterMap.find(req->getCntxt_name()+"*.*in")!=filterMap.end() || filterMap.find(req->getCntxt_name()+ext+"in")!=filterMap.end()) { vector<string> tempp; if(filterMap.find(req->getCntxt_name()+"*.*in")!=filterMap.end()) tempp = filterMap[req->getCntxt_name()+"*.*in"]; else tempp = filterMap[req->getCntxt_name()+ext+"in"]; for (int var = 0; var < (int)tempp.size(); ++var) { string clasz = tempp.at(var); clasz = "getReflectionCIFor" + clasz; logger << "filter handled by class " << clasz << " " << dlib << endl; if(dlib == NULL) { logger << "error" << endl; cerr << dlerror() << endl; exit(-1); } void *mkr = dlsym(dlib, clasz.c_str()); if(mkr!=NULL) { FunPtr f = (FunPtr)mkr; ClassInfo srv = f(); args argus; Constructor ctor = srv.getConstructor(argus); Reflector ref; void *_temp = ref.newInstanceGVP(ctor); Filter *filter = (Filter*)_temp; filter->doInputFilter(req); logger << "filter called" << endl; delete _temp; } } } }
Var_t Context::searchVar(const char* p, hyu32 len) { Var_t var; LocalVarSymID_t lsym; LocalVar_t* lvp = Context::getMyLocalVar(p, len, &lsym); if (lvp != NULL) { var.type = IT_LOCAL; var.symbol = (SymbolID_t)lsym; return var; } SymbolID_t sym = gSymTable.symbolID(p, p+len); var.symbol = sym; ClassInfo* cinf = m_classInfo; if (cinf->searchClassInfo(sym) != NULL) { var.type = IT_CLASS; var.classInfo = cinf; return var; } ConstVar_t* pv = cinf->searchConstVar(sym); if (pv != NULL) { var.type = IT_CONST; var.constInfo = pv; return var; } MethodCallable_e mt = cinf->searchMethod(sym); if (mt != MT_NONE) { var.type = IT_METHOD; var.methodInfo = mt; return var; } var.type = IT_NONE; return var; }
Object *ClassDB::instance(const StringName &p_class) { ClassInfo *ti; { OBJTYPE_RLOCK; ti = classes.getptr(p_class); if (!ti || ti->disabled || !ti->creation_func) { if (compat_classes.has(p_class)) { ti = classes.getptr(compat_classes[p_class]); } } ERR_FAIL_COND_V(!ti, NULL); ERR_FAIL_COND_V(ti->disabled, NULL); ERR_FAIL_COND_V(!ti->creation_func, NULL); } #ifdef TOOLS_ENABLED if (ti->api == API_EDITOR && !Engine::get_singleton()->is_editor_hint()) { ERR_PRINTS("Class '" + String(p_class) + "' can only be instantiated by editor."); return NULL; } #endif return ti->creation_func(); }
void ClassInfo::resolveBaseClasses(const Map& baseClasses, const StringList& classnames, ClassInfo& classInfo) { StringList::const_reverse_iterator classnameIt, classnameEnd; for (classnameIt = classnames.rbegin(), classnameEnd = classnames.rend(); classnameIt != classnameEnd; ++classnameIt) { const String& classname = *classnameIt; ClassInfo::Map::const_iterator baseClassIt = baseClasses.find(classname); if (baseClassIt != baseClasses.end()) { const ClassInfo& baseClass = baseClassIt->second; if (!classInfo.hasDescription && baseClass.hasDescription) classInfo.setDescription(baseClass.description); if (!classInfo.hasColor && baseClass.hasColor) classInfo.setColor(baseClass.color); if (!classInfo.hasSize && baseClass.hasSize) classInfo.setSize(baseClass.size); Model::PropertyDefinition::Map::const_iterator propertyIt, propertyEnd; for (propertyIt = baseClass.properties.begin(), propertyEnd = baseClass.properties.end(); propertyIt != propertyEnd; ++propertyIt) { const Model::PropertyDefinition::Ptr baseclassProperty = propertyIt->second; Model::PropertyDefinition::Map::iterator classPropertyIt = classInfo.properties.find(baseclassProperty->name()); if (classPropertyIt != classInfo.properties.end()) { // the class already has a definition for this property, attempt merging them mergeProperties(baseclassProperty.get(), classPropertyIt->second.get()); } else { // the class doesn't have a definition for this property, add the base class property classInfo.properties[baseclassProperty->name()] = baseclassProperty; } } Model::ModelDefinition::List::const_iterator modelIt, modelEnd; for (modelIt = baseClass.models.begin(), modelEnd = baseClass.models.end(); modelIt != modelEnd; ++modelIt) { const Model::ModelDefinition::Ptr model = *modelIt; classInfo.models.push_back(model); } } } }
bool loadClassInfo(_Module* module, ident_t reference, ClassInfo& info) { // find class meta data _Memory* data = findClassMetaData(module, reference); if (data == NULL) { printLine("Class not found:", reference); return false; } MemoryReader reader(data); info.load(&reader); return true; }
bool loadClassInfo(_Module* module, const wchar_t* className, ClassInfo& info) { // find class meta data ReferenceNs reference(module->Name(), className); _Memory* data = findClassMetaData(module, reference); if (data == NULL) { wprintf(_T("Class %s not found\n"), (const wchar_t*)reference); return false; } MemoryReader reader(data); info.load(&reader); return true; }
void ClassBuffer::SearchTextBuffer (TextBuffer* tb, const char* path) { int beg = 0; for (;;) { char* className = FindClassDecl(tb, beg); if (className == nil) { break; } ClassInfo* info = _classes->Find(className); if (info == nil) { info = new ClassInfo(className, path, tb->LineNumber(beg)); _classes->Include(info); } else { info->Path(path); info->LineNumber(tb->LineNumber(beg)); } for (;;) { char* parentName = ParentName(tb, beg); if (parentName == nil) { break; } ClassInfo* parentInfo = _classes->Find(parentName); if (parentInfo == nil) { parentInfo = new ClassInfo(parentName); _classes->Include(parentInfo); } info->IncludeParent(parentInfo); parentInfo->IncludeChild(info); delete parentName; } delete className; } }
bool ControllerHandler::handle(HttpRequest* req, HttpResponse& res, map<string, string> urlpattMap, map<string, string> mappattMap, void* dlib, string ext, resFuncMap rstCntMap, map<string, string> mapMap, map<string, string> urlMap, string pthwofile) { Logger logger = Logger::getLogger("ControllerHandler"); string claz; bool isContrl = false; if((urlpattMap[req->getCntxt_name()+"*.*"]!="" || urlMap[req->getCntxt_name()+ext]!="")) { //logger << "Controller requested for " << req->getCntxt_name() << " name " << urlMap[req->getCntxt_name()+ext] << endl; if(urlpattMap[req->getCntxt_name()+"*.*"]!="") claz = "getReflectionCIFor" + urlpattMap[req->getCntxt_name()+"*.*"]; else claz = "getReflectionCIFor" + urlMap[req->getCntxt_name()+ext]; string libName = Constants::INTER_LIB_FILE; if(dlib == NULL) { cerr << dlerror() << endl; exit(-1); } void *mkr = dlsym(dlib, claz.c_str()); if(mkr!=NULL) { FunPtr f = (FunPtr)mkr; ClassInfo srv = f(); args argus; Constructor ctor = srv.getConstructor(argus); Reflector ref; void *_temp = ref.newInstanceGVP(ctor); Controller *thrd = (Controller *)_temp; try{ logger << "Controller called" << endl; res = thrd->service(*req); logger << res.getStatusCode() << endl; logger << res.getContent_type() << endl; logger << res.getContent_len() << endl; if(res.getStatusCode()!="") isContrl = true; ext = AuthHandler::getFileExtension(req->getUrl()); //delete mkr; }catch(...){ logger << "Controller exception" << endl;} logger << "Controller called\n" << flush; } } else if((mappattMap[req->getCntxt_name()+"*.*"]!="" || mapMap[req->getCntxt_name()+ext]!="")) { string file = req->getFile(); string fili = file.substr(0,file.find_last_of(".")); if(mappattMap[req->getCntxt_name()+"*.*"]!="") { req->setFile(fili+mappattMap[req->getCntxt_name()+"*.*"]); logger << "URL mapped from * to " << mappattMap[req->getCntxt_name()+"*.*"] << endl; } else { req->setFile(fili+mapMap[req->getCntxt_name()+ext]); logger << "URL mapped from " << ext << " to " << mapMap[req->getCntxt_name()+ext] << endl; } } else { resFuncMap::iterator it; RestFunction rft; bool flag = false; int prsiz = 0; vector<string> valss; //logger << pthwofile << endl; for (it=rstCntMap.begin();it!=rstCntMap.end();it++) { valss.clear(); //logger << it->first << endl; //if(pthwofile.find(it->first)!=string::npos) { RestFunction ft = it->second; prsiz = ft.params.size(); string pthwofiletemp(pthwofile); if(ft.baseUrl=="") { logger << "checking url : " << pthwofiletemp << ",param size: " << prsiz << ", against url: " << it->first << endl; for (int var = 0; var < prsiz; var++) { //logger << "loop - " << pthwofiletemp << endl; string valsvv(pthwofiletemp.substr(pthwofiletemp.find_last_of("/")+1)); pthwofiletemp = pthwofiletemp.substr(0, pthwofiletemp.find_last_of("/")); valss.push_back(valsvv); } reverse(valss.begin(),valss.end()); //logger << "after - " << pthwofiletemp << endl; /*if(pthwofiletemp.at(pthwofiletemp.length()-1)=='/') { pthwofiletemp = pthwofiletemp.substr(0, pthwofiletemp.length()-1); }*/ //logger << "after - " << pthwofiletemp << endl; logger << "checking url : " << pthwofiletemp << ",param size: " << prsiz << ",vals: " << valss.size() << ", against url: " << it->first << endl; if(it->first==pthwofiletemp) { string lhs = StringUtil::toUpperCopy(ft.meth); string rhs = StringUtil::toUpperCopy(req->getMethod()); logger << lhs << " <> " << rhs << endl; if(prsiz==(int)valss.size() && lhs==rhs) { logger << "got correct url -- restcontroller " << endl; rft = ft; flag = true; } else { res.setStatusCode("404"); res.setStatusMsg("Not Found"); //res.setContent_type("text/plain"); /*if(prsiz==valss.size()) res.setContent_str("Invalid number of arguments"); else res.setContent_str("Invalid HTTPMethod used");*/ logger << "Rest Controller Param/Method Error" << endl; } break; } } else { string baseUrl(req->getCntxt_name()+ft.baseUrl); logger << "checking url : " << pthwofiletemp << ",param size: " << prsiz << ", against url: " << baseUrl << endl; for (int var = 1; var <= prsiz; var++) { strVec vemp; stringstream ss; ss << "{"; ss << var; ss << "}"; string param; ss >> param; StringUtil::split(vemp, baseUrl, (param)); if(vemp.size()==2 && pthwofiletemp.find(vemp.at(0))!=string::npos) { string temp = pthwofiletemp; StringUtil::replaceFirst(temp, vemp.at(0), ""); if(temp.find("/")!=string::npos) { pthwofiletemp = temp.substr(temp.find("/")); temp = temp.substr(0, temp.find("/")); } valss.push_back(temp); baseUrl = vemp.at(1); logger << "variable at " << param << " mapped to " << temp << " from URL" << endl; logger << baseUrl << endl; logger << pthwofiletemp << endl; } else { flag = false; break; } } string lhs = StringUtil::toUpperCopy(ft.meth); string rhs = StringUtil::toUpperCopy(req->getMethod()); logger << lhs << " <> " << rhs << endl; if(prsiz==(int)valss.size() && lhs==rhs) { logger << "got correct url -- restcontroller " << endl; rft = ft; flag = true; break; } else { res.setStatusCode("404"); res.setStatusMsg("Not Found"); //res.setContent_type("text/plain"); /*if(prsiz==valss.size()) res.setContent_str("Invalid number of arguments"); else res.setContent_str("Invalid HTTPMethod used");*/ logger << "Rest Controller Param/Method Error" << endl; } } } } if(flag) { //logger << "inside restcontroller logic ..." << endl; string libName = Constants::INTER_LIB_FILE; if(dlib == NULL) { cerr << dlerror() << endl; exit(-1); } string clasnam("getReflectionCIFor"+rft.clas); void *mkr = dlsym(dlib, clasnam.c_str()); logger << mkr << endl; if(mkr!=NULL) { FunPtr f = (FunPtr)mkr; ClassInfo srv = f(); args argus; Constructor ctor = srv.getConstructor(argus); Reflector ref; void *_temp = ref.newInstanceGVP(ctor); RestController* rstcnt = (RestController*)_temp; rstcnt->request = req; rstcnt->response = &res; vals valus; bool invValue = false; for (int var = 0; var < prsiz; var++) { try { argus.push_back(rft.params.at(var).type); if(rft.params.at(var).type=="int") { int* ival = new int(CastUtil::lexical_cast<int>(valss.at(var))); valus.push_back(ival); } else if(rft.params.at(var).type=="long") { long* ival = new long(CastUtil::lexical_cast<long>(valss.at(var))); valus.push_back(ival); } else if(rft.params.at(var).type=="double") { double* ival = new double(CastUtil::lexical_cast<double>(valss.at(var))); valus.push_back(ival); } else if(rft.params.at(var).type=="float") { float* ival = new float(CastUtil::lexical_cast<float>(valss.at(var))); valus.push_back(ival); } else if(rft.params.at(var).type=="bool") { bool* ival = new bool(CastUtil::lexical_cast<bool>(valss.at(var))); valus.push_back(ival); } else if(rft.params.at(var).type=="string") { string* sval = new string(valss.at(var)); valus.push_back(sval); } } catch (...) { invValue= true; break; } } Method meth = srv.getMethod(rft.name, argus); if(meth.getMethodName()!="" && !invValue) { ref.invokeMethodUnknownReturn(_temp,meth,valus); logger << "successfully called restcontroller" << endl; //return; } else { res.setStatusCode("404"); res.setStatusMsg("Not Found"); //res.setContent_type("text/plain"); /*if(invValue) res.setContent_str("Invalid value passed as URL param"); else res.setContent_str("Rest Controller Method Not Found");*/ logger << "Rest Controller Method Not Found" << endl; //return; } } } } return isContrl; }
void* ComponentHandler::service(void* arg) { int fd = *(int*)arg; init(); string methInfo,retValue; _cmp_instance->getServer()->Receive(fd,methInfo,1024); methInfo =methInfo.substr(0,methInfo.find_last_of(">")+1); _cmp_instance->logger << methInfo << flush; try { XmlParser parser("Parser"); _cmp_instance->logger << "\nBean call parsed successfully\n" << flush; if(methInfo.find("lang=\"c++\"")!=string::npos || methInfo.find("lang='c++'")!=string::npos) { Document doc = parser.getDocument(methInfo); Element message = doc.getRootElement(); if(message.getTagName()!="service") { throw new ComponentHandlerException("No service Tag\n",retValue); } if(message.getAttributes().size()<4) { throw new ComponentHandlerException("name,beanName,returnType and lang are mandatory attributes\n",retValue); } else if(message.getAttribute("name")=="") { throw new ComponentHandlerException("name attribute missing\n",retValue); } else if(message.getAttribute("returnType")=="") { throw new ComponentHandlerException("returnType attribute missing\n",retValue); } else if(message.getAttribute("beanName")=="") { throw new ComponentHandlerException("beanName attribute missing\n",retValue); } else if(message.getAttribute("lang")=="") { throw new ComponentHandlerException("lang attribute missing\n",retValue); } if(message.getChildElements().size()!=1) { throw new ComponentHandlerException("message tag should have only one child tag\n",retValue); } else if(message.getChildElements().at(0).getTagName()!="args") { throw new ComponentHandlerException("message tag should have an args child tag\n",retValue); } Serialize ser; Reflector reflector; args argus; vals valus; ElementList argts = message.getChildElements().at(0).getChildElements(); for (unsigned var = 0; var < argts.size(); var++) { void *value = NULL; Element arg = argts.at(var); if(arg.getTagName()!="argument") throw new ComponentHandlerException("Invalid Tag, only argument tag allowed\n",retValue); else if(arg.getAttribute("type")=="") throw new ComponentHandlerException("every argument tag should have a type attribute\n",retValue); if(arg.getText()=="" && arg.getChildElements().size()==0) throw new ComponentHandlerException("argument value missing\n",retValue); if(arg.getAttribute("type")!="") { Element obj = arg.getChildElements().at(0); string objxml = obj.render(); string objClassName = obj.getTagName(); value = ser.unSerializeUnknown(objxml,arg.getAttribute("type")); } argus.push_back(arg.getAttribute("type")); valus.push_back(value); } string className = "Component_"+message.getAttribute("beanName"); _cmp_instance->logger << "\nBean class = " << className << "\n" << flush; string returnType = message.getAttribute("returnType"); string lang = message.getAttribute("lang"); ClassInfo clas = reflector.getClassInfo(className); string methodName = message.getAttribute("name"); _cmp_instance->logger << "\nBean service = " << methodName << "\n" << flush; if(clas.getClassName()=="") { throw new ComponentHandlerException("bean does not exist or is not regsitered\n",retValue); } Method meth = clas.getMethod(methodName,argus); if(meth.getMethodName()=="") { throw new ComponentHandlerException("service does not exist for the bean or the bean does not exist or is not regsitered\n\n",retValue); } else { _cmp_instance->logger << "\nGot Bean service " << methodName << "\n" << flush; args argus; Constructor ctor = clas.getConstructor(argus); void *_temp = reflector.newInstanceGVP(ctor); _cmp_instance->logger << "\nGot Bean " << _temp << "\n" << flush; if(returnType=="void" || returnType=="") { _cmp_instance->logger << "\nVoid return " << "\n" << flush; reflector.invokeMethod<void*>(_temp,meth,valus); retValue = ("<return:void></return:void>"); } else { _cmp_instance->logger << "\nReturn type = "<< returnType << "\n" << flush; if(returnType=="int") { int retv = reflector.invokeMethod<int>(_temp,meth,valus); retValue = ("<return:int>"+CastUtil::lexical_cast<string>(retv)+"</return:int>"); } else if(returnType=="float") { float retv = reflector.invokeMethod<float>(_temp,meth,valus); retValue = ("<return:float>"+CastUtil::lexical_cast<string>(retv)+"</return:float>"); } else if(returnType=="double") { double retv = reflector.invokeMethod<double>(_temp,meth,valus); retValue = ("<return:double>"+CastUtil::lexical_cast<string>(retv)+"</return:double>"); } else if(returnType=="string") { string retv = reflector.invokeMethod<string>(_temp,meth,valus); retValue = ("<return:string>"+retv+"</return:string>"); } else if(returnType!="") { void* retobj = reflector.invokeMethodUnknownReturn(_temp,meth,valus); string oxml = ser.serializeUnknown(retobj,returnType); retValue = ("<return:"+returnType+">"+oxml+"</return:"+returnType+">"); } } } } else { retValue = "<return:exception>This is a C++ daemon</return:exception>"; } _cmp_instance->logger << "\nSending data = "<< retValue << "\n" << flush; if(retValue!="") _cmp_instance->getServer()->Send(fd,retValue); //close(fd); } catch(ComponentHandlerException *e) { _cmp_instance->logger << e->getMessage() << flush; _cmp_instance->getServer()->Send(fd,retValue); close(fd); } catch(...) { _cmp_instance->logger << "exception occurred" << flush; retValue = ("<return:exception>XmlParseException occurred</return:exception>"); _cmp_instance->getServer()->Send(fd,retValue); close(fd); } }