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);
}
}
