void QObjectHolder::takeOwner(QObject* obj){ lock(); Present* p=getFromMap(objects,obj); if (p!=NULL){ p->p=false; p->thread=QThread::currentThread(); notifyAll(); p=getFromMap(objects,obj); while (p!=NULL){ wait(); p=getFromMap(objects,obj); } } unlock(); }
JObjectInformation* JObjectInformations::getObjectInformation(JObject* object){ JObjectInformation* oi; lock(); oi=getFromMap(objectMap,object); unlock(); return oi; }
JObjectInformation* JObjectInformations::getObjectInformation(JString* id){ JObjectInformation* oi; lock(); oi=getFromMap(idMap,id); unlock(); return oi; }
JObject* JHashMap::get(JObject* key){ if (key==NULL){ key=NULL_KEY; } JObject* value=getFromMap(table,key); return value; }
JObjectInformation* JObjectInformations::unexport(JObject* object){ JObjectInformation* objInfo; lock(); objInfo = getFromMap(objectMap,object); unlock(); if (objInfo != NULL) { return unexport(objInfo->getId()); } return NULL; }
void JTransportRouter::addRoute(JString localSite,JString remoteSite, JRoute* route) { lock(); map<JString,JRoute*>* internalMap=getFromMap(routes,localSite); if (internalMap==NULL) { internalMap=new map<JString,JRoute*>(); routes->insert(pair<JString,map<JString,JRoute*>*>(localSite,internalMap)); } internalMap->insert(pair<JString,JRoute*>(remoteSite,route)); unlock(); }
void JObject::link(JObject* o){ if (o!=NULL){ memoryMutex->lock(); JINT* i=getFromMap(toObject,o); if (i==NULL){ i=new JINT(0); toObject->insert(pair<JObject*,JINT*>(o,i)); } i->increment(); JINT* j=getFromMap(o->fromObject,this); if (j==NULL){ j=new JINT(0); o->fromObject->insert(pair<JObject*,JINT*>(this,j)); } j->increment(); memoryMutex->unlock(); } }
void JObjectInformations::doExport(JString* id, JObject* object, vector<JClass*>* interfaces){ JObjectInformation* objInfo; lock(); objInfo=getFromMap(idMap,id); if (objInfo != NULL) { throw new JConnectionException("Object[" + object->toString() + "] with ID[" + id->toString() + "] already exists in ObjectInformations idMap"); } objInfo=getFromMap(objectMap,object); if ( objInfo!= NULL) { throw new JConnectionException("Object[" + object->toString() + "] with ID[" + id->toString() + "] already exists in ObjectInformations objectMap"); } objInfo = new JObjectInformation(id, object, interfaces, this, lifecycle, gc); idMap->insert(pair<JString*,JObjectInformation*>(id, objInfo)); objectMap->insert(pair<JObject*,JObjectInformation*>(object, objInfo)); if (idMap->size() == 1) { transport->startExport(); } unlock(); objInfo->exported(); }
JConnections* JTransport::getConnections(JEndPoint* remoteEndPoint){ JConnections* connections=NULL; lock(); connections=getFromMap(remoteConnectionsMap,remoteEndPoint); if (connections==NULL){ connections=new JConnections(remoteEndPoint,this); remoteConnectionsMap->insert(pair<JEndPoint*,JConnections*>(remoteEndPoint,connections)); } unlock(); return connections; }
JRoute* JTransportRouter::findRoute(JString localSite, JEndPoint* remoteEndpoint) { JRoute* route=NULL; lock(); if (remoteEndpoint!=NULL) { if (localSite==remoteEndpoint->getSite()) { route=new JRoute(); route->addAddress(new JAddress(remoteEndpoint->getAddress())); } else { map<JString,JRoute*>* internalMap=getFromMap(routes,localSite); if (internalMap!=NULL) { route=getFromMap(internalMap,remoteEndpoint->getSite()); if (route!=NULL) { route=route->clone(); route->addAddress(new JAddress(remoteEndpoint->getAddress())); } } } } unlock(); return route; }
JClass* JPrimitiveArray::getClazz(JClass* componentType){ getLockObject()->lock(); if (jPrimitiveArrayClasses==NULL){ jPrimitiveArrayClasses=new map<JString,JPrimitiveArrayClass*>(); } JPrimitiveArrayClass* jPrimitiveArrayClass=getFromMap(jPrimitiveArrayClasses,componentType->getName()); if (jPrimitiveArrayClass==NULL){ jPrimitiveArrayClass=new JPrimitiveArrayClass(componentType); jPrimitiveArrayClasses->insert(pair<JString,JPrimitiveArrayClass*>(componentType->getName(),jPrimitiveArrayClass)); } getLockObject()->unlock(); return jPrimitiveArrayClass; }
JObjectInformation* JObjectInformations::remove(JString* id){ JObjectInformation* objInfo; lock(); objInfo = getFromMap(idMap,id); if (objInfo != NULL) { idMap->erase(id); objectMap->erase(objInfo->getObject()); if (idMap->size() == 0) { transport->stopExport(); } } unlock(); return objInfo; }
void JGCClient::add(map<JObjectPointer*, JObject*,JObjectPointer::POINTER_COMPARATOR>* objectPointers){ lock(); map<JObjectPointer*,JObject*,JObjectPointer::POINTER_COMPARATOR>::iterator it=objectPointers->begin(); for (;it!=objectPointers->end();it++){ JEndPoint* remoteEndPoint = (*it).first->getEndPoint(); JGCClientEndPointInfo* endPointInfo = getFromMap(endPointInfos,remoteEndPoint); if (endPointInfo == NULL) { endPointInfo = new JGCClientEndPointInfo(this,localServer,remoteEndPoint); endPointInfos->insert(pair<JEndPoint*,JGCClientEndPointInfo*>(remoteEndPoint, endPointInfo)); } endPointInfo->doExport((*it).first->getId(), (*it).second); } unlock(); }
void JObject::unlink(JObject* o){ if (o!=NULL){ memoryMutex->lock(); JINT* i=getFromMap(toObject,o); if (i!=NULL){ i->decrement(); if (i->getValue()==0){ toObject->erase(o); delete i; } } JINT* j=getFromMap(o->fromObject,this); if (j!=NULL){ j->decrement(); if (j->getValue()==0){ o->fromObject->erase(this); delete j; o->finalize(); } } memoryMutex->unlock(); } }
ConstCacheObjectPtr get( const CacheId& cacheId ) const { return getFromMap( cacheId ); }
void Semantic::traverse(Exp * cur) { if (cur->v == Exp::ICONST_T || cur->v == Exp::STRLIT_T || cur->v == Exp::CHRLIT_T || cur->v == Exp::BOLLIT_T || cur->v == Exp::NULL_T) { //we're dealing with a constant here, ensure int constant in 0 2^31 if (cur->v == Exp::ICONST_T) if (cur->id.length() == std::string("2147483647").length() && cur->id > "2147483647") error("integer literal constants must be < 2^31"); } else if (cur->v == Exp::ID_T) { //variable getSym(cur->id); } else if (cur->v == Exp::UNOP_T) { //ensure subexp type is char or int Type l = expType(cur->l); if (!(sameType(l, Type(Type::INT_T)) || sameType(l, Type(Type::CHAR_T)) || sameType(l, Type(Type::BOOL_T)))) error("unop must be applied to expression of type int or char"); traverse(cur->l); } else if (cur->v == Exp::BINOP_T) { //if <=, <, >, >= ensure int or char //if != or == ensure int bool char t[] or t* Type l = expType(cur->l), r = expType(cur->r); if (cur->id == "==" || cur->id == "!="); if (!(sameType(l, Type(Type::INT_T)) || sameType(l, Type(Type::CHAR_T)) || sameType(l, Type(Type::BOOL_T)))) error("binop must be applied to expression of type int or char or bool"); else if (!(sameType(r, Type(Type::INT_T)) || sameType(r, Type(Type::CHAR_T)) || sameType(r, Type(Type::BOOL_T)))) error("binop must be applied to expression of type int or char or bool"); traverse(cur->l); traverse(cur->r); } else if (cur->v == Exp::IFLINE_T) { Type l = expType(cur->l); if (!(sameType(l, Type(Type::INT_T)) || sameType(l, Type(Type::CHAR_T)) || sameType(l, Type(Type::BOOL_T)))) error("Condition must be of type bool"); traverse(cur->l); traverse(cur->m); traverse(cur->r); } else if (cur->v == Exp::FCALL_T) { if (cur->id == "print" || cur->id == "read_int") return; Symbol func = getSym(cur->id); if (func.decl == NULL && func.defn == NULL) { error("call to undeclared function " + cur->id); return; } ArgItem * ptr = (func.decl != NULL) ? func.decl->list : func.defn->args; ExpItem * old = cur->args; while (ptr != NULL) { if (old == NULL) { error("bad argument passed to function " + cur->id); break; } if (!sameType(*(ptr->arg->type), expType(old->exp))) { error("bad argument passed to function " + cur->id); break; } traverse(old->exp); ptr = ptr->next; old = old->next; } if (old != NULL) error("bad argument passed to function " + cur->id); } else if (cur->v == Exp::DOT_T) { //see if type has that field Type t = expType(cur->l); if (t.v != Type::STRUCT_T) error("accessing field in a non-struct type"); Symbol s = getFromMap(sid, t.str); bool hasField = false; ArgItem * ptr = s.defn->args; while (ptr != NULL) { if (ptr->arg->ID == cur->id) { hasField = true; break; } ptr = ptr->next; } if (!hasField) error("accessing non existing struct field " + cur->id); } else if (cur->v == Exp::ACC_T) { //see if type has that field Type t = expType(cur->l); if (t.v != Type::POINTER_T || t.type->v != Type::STRUCT_T) error("referencing field in a pointer to struct type"); Symbol s = getFromMap(sid, t.type->str); bool hasField = false; ArgItem * ptr = s.defn->args; while (ptr != NULL) { if (ptr->arg->ID == cur->id) { hasField = true; break; } ptr = ptr->next; } if (!hasField) error("referencing non existing struct field " + cur->id); } else if (cur->v == Exp::SUBSC_T) { //see if subst is char or int and other type is vector Type l = expType(cur->l); Type r = expType(cur->r); if (l.v != Type::VECTOR_T) error("accessing index in non-vector type"); if (!(sameType(r, Type(Type::INT_T)) || sameType(r, Type(Type::CHAR_T)) || sameType(r, Type(Type::BOOL_T)))) error("index type must be int or char"); traverse(cur->l); traverse(cur->r); } else if (cur->v == Exp::ALLOC_T) { //return the little thing allocated in memory (heap?) if (cur->t->v != Type::STRUCT_T) error("cannot alloc non-struct type"); } else if (cur->v == Exp::ALLOCARRAY_T) { //return the little thing[] allocated in memory (heap?) Type r = expType(cur->l); if (!(sameType(r, Type(Type::INT_T)) || sameType(r, Type(Type::CHAR_T)) || sameType(r, Type(Type::BOOL_T)))) error("alloc_array size must be type int"); traverse(cur->l); } }