Type * TypeCheck::visit(MemberSelect *ast) { FUNCLOG; Type *member = NULL; Type *t = ast->receiver->accept(this); if (t->actual()->is(Type::CLASS_T)) { ClassType *receiver = t->actual()->as<ClassType>(); member = receiver->findMember(Symbol::symbol(ast->member->toSource())); //member = ast->member->accept(this); if (member == NULL) { SEMANTIC_ERROR(SE_ERROR); } DBG("member %s", member->toString().c_str()); } else { assert(0); //TODO } if (member->is(Type::FIELD_T)) { return member->actual(); } else { return member; } }
void Stream::WriteObject(const void* object) { if (object == NULL) { uint32 id = 0; Write(&id, 4); return; } map<const void*, uint32>::iterator it = m_objectmapSave.find(object); PerObject* perobject = GetPerObject(object); if (it != m_objectmapSave.end()) { uint32 id = (*it).second; Write(&id, 4); } else { ClassType* pType = System::GetType(object); uint32 id = ++m_id; Write(&id, 4); m_objectmapSave.insert(map<const void*, uint32>::value_type(object, id)); char classname[256] = {0}; std::memcpy(classname, pType->get_QName().GetData8(), pType->get_QName().GetLength()); Write(classname, 256); WriteClass((uint8*)object, pType); } }
void* Stream::ReadObject() { uint32 id; Read(&id, 4); if (id == 0) { return NULL; } map<uint32, void*>::iterator it = m_objectmapLoad.find(id); if (it != m_objectmapLoad.end()) { return (*it).second; } else { // We don't call any constructors.. hmm. char classname[256] = {0}; Read(classname, 256); ClassType* pType = (ClassType*)pD->LookupNamedType(classname); ASSERT(pType); uint8* object = new /*(pHeap)*/ uint8[pType->get_sizeof()]; ReadClass(object, pType); return object; } return NULL; }
void StrucViewItem::initState() //----------------------------- // if i represent a variable, i must find my type // if the base type is a ClassType, then i am Collapsed // else i am LeafNode { bool do_inherited = false; ClassType * classType; dr_sym_type stype = _info->symtype(); REQUIRE( stype != DR_SYM_NOT_SYM,"strucview::initstate ack"); if( !_initialized ) { if( _classNode != NULL ) { REQUIRE( stype == DR_SYM_CLASS,"strucview::initstate nak"); classType = (ClassType *)_info; _type = _name; } else { classType = flattenTypeDesc( _info, _type ); _name = _info->name(); } if( classType ) { WVList kidInfos; FilterFlags flags = _parent->getFilter(); if( ( flags & FILT_INHERITED ) || ( flags & FILT_ALL_INHERITED )) { do_inherited = true; FILT_RESET_INHERITED( flags ); } classType->dataMembers( kidInfos, flags ); if( kidInfos.count() != 0 ) { _expandState = Collapsed; _parent->addSeen( this ); for( int i = 0; i < kidInfos.count(); i++ ) { _kids.add( new StrucViewItem( _parent, ((Symbol *)kidInfos[i]), _indentLevel + 1 ) ); } } else { _expandState = LeafNode; } if( classType != _info ) { delete classType; } if( do_inherited ) { startInherited(); } } else { _expandState = LeafNode; } _initialized = true; } }
Type * TypeCheck::visit(ClassSpecifier *ast) { FUNCLOG; Symbol *name; if (ast->name->isTemplateId()) { //TODO: assert(0); } else { name = ast->name->name; } ClassType *classType = new ClassType(name, ast->typeSpecId == CLASS); if (!SymbolTable.addType(classType, name)) { //duplicated class specifier SEMANTIC_ERROR(SE_DUPLICATE_TYPE); } ast->name->accept(this); if (ast->base) { //TODO: ast->base->accept(this); } if (ast->members) { SymbolTable.enterScope(SymbolTable::CLASS, name); Type *tl = ast->members->accept(this); assert(tl->is(Type::TYPELIST_T)); TypeList *tlist = tl->as<TypeList>(); List<Type*>::iterator it = tlist->list.begin(); while (it != tlist->list.end()) { Type *t = *it; if (t->is(Type::METHOD_T)) { DBG("add method %s to %s", t->toString().c_str(), name->toString().c_str()); classType->addMethod(t->as<MethodType>()); } else if (t->is(Type::FIELD_T)) { DBG("add field %s to %s", t->toString().c_str(), name->toString().c_str()); classType->addField(t->as<FieldType>()); } ++it; } SymbolTable.leaveScope(); } return classType; }
TEST_F(SymbolTest, testClassSymbol) { DataType* data_type = class_->getDataType(); ASSERT_NE(nullptr, data_type); ASSERT_EQ(DataType::DATA_TYPE_CLASS, data_type->getType()); ClassType* type = dynamic_cast<ClassType*>(data_type); ASSERT_NE(nullptr, type); EXPECT_EQ(class_.get(), type->getClassSymbol()); VariableSymbol* v1 = new VariableSymbol("v1"); v1->setDataType(DataTypeFactory::getInt32Type()); class_->addVariable(v1); VariableSymbol* v2 = new VariableSymbol("v2"); v2->setDataType(DataTypeFactory::getStringType()); class_->addVariable(v2); const auto& actual_vars = class_->getVariables(); std::vector<VariableSymbol*> expected_vars {v1, v2}; EXPECT_EQ(expected_vars, actual_vars); FunctionSymbol* f = new FunctionSymbol("f"); f->setReturnType(DataTypeFactory::getCharType()); class_->addFunction(f); const auto& actual_funcs = class_->getFunctions(); std::vector<FunctionSymbol*> expected_funcs {f}; EXPECT_EQ(expected_funcs, actual_funcs); Scope* scope = class_->getScope(); ASSERT_NE(nullptr, scope); EXPECT_FALSE(scope->isOwnedBySymbolTable()); EXPECT_EQ(class_->getName(), scope->getName()); EXPECT_EQ(4, scope->getSize()); EXPECT_EQ(v1, scope->lookup(v1->getName())); EXPECT_EQ(v2, scope->lookup(v2->getName())); EXPECT_EQ(f, scope->lookup(f->getName())); EXPECT_EQ(class_.get(), scope->lookup(class_->getName())); ClassSymbol super_class("super"); class_->setSuperClass(&super_class); EXPECT_EQ(super_class.getScope(), scope->getParent()); EXPECT_EQ(&super_class, scope->lookup(super_class.getName())); }
void DTViewClass::load() //---------------------- { WVList dataMembers; WVList methods; WVList friends; int i; WString str; ClassType * cls = (ClassType *) _symbol; Symbol * s; _members->clearAndDestroy(); cls->dataMembers( dataMembers ); cls->memberFunctions( methods ); cls->friendFunctions( friends ); for( i = 0; i < friends.count(); i += 1 ) { s = (Symbol *) friends[ i ]; str.printf( " friend %s;", s->scopedName( FALSE ) ); _members->insert( new ClassMember( s, str.gets() ) ); } for( i = 0; i < dataMembers.count(); i += 1 ) { s = (Symbol *) dataMembers[ i ]; str.printf( " %s;", s->scopedName( FALSE ) ); _members->insert( new ClassMember( s, str.gets() ) ); } for( i = 0; i < methods.count(); i += 1 ) { s = (Symbol *) methods[ i ]; str.printf( " %s;", s->scopedName( FALSE ) ); _members->insert( new ClassMember( s, str.gets() ) ); } addDescriptions(); fillBox(); }
// метод характеризует класс 'base' по отношению к 'derived' void DerivationManager::Characterize( const ClassType &base, const ClassType &curCls, bool ac ) { register const BaseClassList &bcl = curCls.GetBaseClassList(); for( int i = 0; i<bcl.GetBaseClassCount(); i++ ) { const BaseClassCharacteristic &clh = *bcl.GetBaseClassCharacteristic(i); const ClassType &bcls = clh.GetPointerToClass(); // ac учитываем доступность как предыдущих классов так и текущих ac = ac && clh.GetAccessSpecifier() == ClassMember::AS_PUBLIC; // если полученный класс является 'base', выполним операции и // выйдем из цикла, т.к. класс не может наследовать сам себя if( &base == &bcls ) { baseCount++; // если первый класс, проверяем его на виртуальность и на доступность if( baseCount == 1 ) { virtualDerivation = clh.IsVirtualDerivation(); accessible = ac; } else { virtualDerivation = virtualDerivation && clh.IsVirtualDerivation(); // из нескольких базовых классов можно выбрать самый доступный, // если он виртуален accessible = accessible || ac; } } // иначе вызываем рекурсию двигаясь вверх по иерархии else Characterize( base, bcls, ac ); } }
RefPtr<DebugSymbol> lookup_child(DebugSymbol& obj, const char* name, SymSet& symset) { if (!symset.insert(make_pair(obj.name(), obj.addr())).second) { return NULL; } InfiniteRecursivityGuard guard(symset, &obj); if (!obj.value()) { obj.read(NULL); } DebugSymbolList objects; ClassType* klass = interface_cast<ClassType*>(obj.type()); const size_t count = obj.enum_children(NULL); for (size_t n = 0; n != count; ++n) { RefPtr<DebugSymbol> child = obj.nth_child(n); if (!child->name()) { continue; } if (child->name()->is_equal(name)) { return child; } // build a list of anonymous members and base classes // to recurse into if (klass) { if (child->name()->is_equal2(unnamed_type())) { assert (interface_cast<ClassType*>(child->type())); objects.push_back(child); } else if (child->type() && klass->lookup_base(child->type()->name(), NULL, true)) { objects.push_back(child); } } else if (interface_cast<ClassType*>(child->type())) { objects.push_back(child); } } // now dive into base classes for (DebugSymbolList::const_iterator i = objects.begin(); i != objects.end(); ++i) { if (RefPtr<DebugSymbol> child = lookup_child(**i, name, symset)) { return child; } } return NULL; }
// virtual void Properties::PropertyListener::handleEvent(System::Event* evt) { #if WIN32 if (evt->get_eventPhase() != System::CAPTURING_PHASE) { if (*evt->get_type() == L"contextmenu") { evt->stopPropagation(); UI::MouseEvent* mouseEvt = static_cast<UI::MouseEvent*>(evt); UI::CLXUIMenuElement* menu = new UI::CLXUIMenuElement(); // menu->SetRParent(m_ctledit); menu->SetOwnerWindow(mouseEvt->GetOwnerWindow()); menu->addEventListener(WSTR("command"), this, false); if (false) { menu->AddItem(new UI::TextString(WSTR("Display As Table")), 100); } else { Type* pType = m_pProperty->get_method->m_decl->m_pType->GetFunction()->m_pReturnType; if (pType->get_Kind() == type_pointer && pType->GetPointerTo()->get_Kind() == type_class) { vector<ClassType*> list; GetDerived(pType->GetPointerTo()->GetClass(), list); for (int i = 0; i < list.GetSize(); i++) { ClassType* pDerived = list[i]; if (pDerived->m_derived.GetSize() == 0) { menu->AddItem(new UI::TextString(pDerived->get_Name()->ToStringW()), (long)pDerived); } } } } menu->GetMenuPopup()->Popup(menu, LDraw::PointI(mouseEvt->get_ScreenX(), mouseEvt->get_ScreenY())); } else if (*evt->get_type() == L"command") { if (false) { m_bDisplayAsTable = !m_bDisplayAsTable; } else { evt->stopPropagation(); UI::CommandInvokeEvent* cmdEvt = dynamic_cast<UI::CommandInvokeEvent*>(evt); long param = cmdEvt->get_Command(); ClassType* pDerivedType = (ClassType*)param; void* p = newobj(pDerivedType); if (p) { Type* pType = m_pProperty->set_method->m_decl->m_pType->GetFunction()->m_parameters.m_parameters[0].m_pType; pType = pType->GetStripped(); void* value = DynamicCast(p, pDerivedType, pType->GetPointerTo()->GetClass()); ASSERT(0); void *_this = NULL;//__RTDynamicCast(m_itemVisual, 0, (void*)&typeid(m_itemVisual), (void*)m_pProperty->set_method->GetTypeInfo(), 0); // StringA str_type = pType->ToString(); ULONG_PTR func; if (m_pProperty->set_method->m_decl->m_offset != -1) { void* vtable = *(void**)_this; func = *(ULONG_PTR*)((uint8*)vtable + m_pProperty->set_method->m_decl->m_offset); } else { func = m_pProperty->set_method->m_func; } __asm { push ecx mov ecx,_this push value call func pop ecx } } } } #if 0 void *_this = __RTDynamicCast(m_itemVisual, 0, (void*)&typeid(m_itemVisual), (void*)put_type_info(), 0); cpp::Type* pType = put_decl->m_pType->m_pFunction->m_parameters[0]->m_pType; StringA str_type = pType->toString(); pType = pType->GetType(); DWORD func; if (put_decl->m_offset != -1) { void* vtable = *(void**)_this; func = *(DWORD*)((uint8*)vtable + put_decl->m_offset); } else { func = put_func; } if (*evt->get_type() == L"contextmenu") { evt->stopPropagation(); UI::MouseEvent* mouseEvt = dynamic_cast<MouseEvent*>(evt); if (pType->m_type == cpp::type_pointer && pType->m_pPointerTo->m_type == cpp::type_class) { CLXUIMenuElement* menu = new CLXUIMenuElement(); menu->SetRParent(m_ctledit); menu->SetOwnerWindow(m_ctledit->get_OwnerWindow()); std::map<StringA, cpp::Type*>::iterator it = pD->m_namedTypes.begin(); while (it != pD->m_namedTypes.end()) { cpp::Type* pType2 = (*it).second; ASSERT(pType2); it++; if (pType2->m_type == cpp::type_class) { if (pType2->m_pClass->IsOfType(pType->m_pPointerTo->m_pClass)) { // pType2->m_pClass->IsOfType(pType->m_pPointerTo->m_pClass); menu->AddItem(new TextString(ConvertA2S(pType2->m_pClass->m_name)), (long)pType2); } } } menu->GetMenuPopup()->Popup(menu, LDraw::PointI(mouseEvt->get_ScreenX(), mouseEvt->get_ScreenY())); } } else if (*evt->get_type() == L"command") { evt->stopPropagation(); CommandInvokeEvent* cmdEvt = dynamic_cast<CommandInvokeEvent*>(evt); long param = cmdEvt->get_Command(); if (pType->m_type == cpp::type_enum) { __asm { push ecx mov ecx,_this push param call func pop ecx } } else { cpp::Type* pType2 = (cpp::Type*)param; void* object = newobj(pType2->m_pClass); Type_Info* src = (Type_Info*)pD->LookupSymbol(DecorateName(pType2->m_pClass->m_name)); Type_Info* dst = (Type_Info*)pD->LookupSymbol(DecorateName(pType->m_pPointerTo->m_pClass->m_name)); void* param = __RTDynamicCast(object, 0, src, dst, 0); __asm { push ecx mov ecx,_this push param call func pop ecx } } } else if (*evt->get_type() == L"ValueChange")
#include <catch/catch.hpp> #include "BlueprintReflection/Type/ClassType.hpp" TEST_CASE("TestClassType") { using namespace blueprint::reflection; ClassType classType; SECTION("Default State") { CHECK(classType.GetBaseClasses().empty()); CHECK(classType.GetNestedTypes().empty()); CHECK(classType.GetMethods().empty()); CHECK(classType.GetFields().empty()); } SECTION("Base Classes") { ClassType parentA; classType.AddBaseClass(&parentA); REQUIRE(classType.GetBaseClasses().size() == 1); CHECK(classType.GetBaseClasses()[0] == &parentA); ClassType parentB; classType.AddBaseClass(&parentB); REQUIRE(classType.GetBaseClasses().size() == 2); CHECK(classType.GetBaseClasses()[1] == &parentB);
void OSSSIP::initTransportFromConfig(const boost::filesystem::path& cfgFile) { ClassType config; config.load(OSS::boost_path(cfgFile)); DataType root = config.self(); DataType listeners = root["listeners"]; DataType interfaces = listeners["interfaces"]; int ifaceCount = interfaces.getElementCount(); bool hasFoundDefault = false; for (int i = 0; i < ifaceCount; i++) { DataType iface = interfaces[i]; std::string ip = iface["ip-address"]; std::string external; if (iface.exists("external-address")) { external = (const char*)iface["external-address"]; } bool tlsEnabled = iface.exists("tls-enabled") && (bool)iface["tls-enabled"]; bool tcpEnabled = iface.exists("tcp-enabled") && (bool)iface["tcp-enabled"]; bool wsEnabled = iface.exists("ws-enabled") && (bool)iface["ws-enabled"]; bool udpEnabled = true; if (iface.exists("udp-enabled")) udpEnabled = (bool)iface["udp-enabled"]; int sipPort = iface.exists("sip-port") ? (int)iface["sip-port"] : 5060; int tlsPort = iface.exists("tls-port") ? (int)iface["tls-port"] : 5061; if (!hasFoundDefault) { if (iface.exists("default")) { hasFoundDefault = ((bool)iface["default"]); bool transportEnabled = udpEnabled || tcpEnabled || wsEnabled || tlsEnabled; if (hasFoundDefault && transportEnabled) { OSS::IPAddress listener; listener = ip; listener.externalAddress() = external; listener.setPort(sipPort); _fsmDispatch.transport().defaultListenerAddress() = listener; } } } if (udpEnabled) { OSS::IPAddress listener; listener = ip; listener.externalAddress() = external; listener.setPort(sipPort); _udpListeners.push_back(listener); } if (tcpEnabled) { OSS::IPAddress listener; listener = ip; listener.externalAddress() = external; listener.setPort(sipPort); _tcpListeners.push_back(listener); } if (wsEnabled) { OSS::IPAddress listener; listener = ip; listener.externalAddress() = external; listener.setPort(sipPort); _wsListeners.push_back(listener); } if (tlsEnabled) { OSS::IPAddress listener; listener = ip; listener.externalAddress() = external; listener.setPort(tlsPort); _tlsListeners.push_back(listener); } } if (!hasFoundDefault) { // // Set the default interface for the transport service the old fashioned way // if (listeners.exists("default-interface-address") && listeners.exists("default-interface-port")) { hasFoundDefault = true; DataType defaultIface = listeners["default-interface-address"]; DataType defaultPort = listeners["default-interface-port"]; OSS::IPAddress defaultInterface((const char*)defaultIface); defaultInterface.setPort((int)defaultPort); _fsmDispatch.transport().defaultListenerAddress() = defaultInterface; } } if (!hasFoundDefault && ifaceCount > 0) { // // We don't have the defualt interface yet. Lets use the first configured listener // DataType iface = interfaces[0]; std::string ip = iface["ip-address"]; if (iface.exists("udp-enabled") && (bool)iface["udp-enabled"]) { int port = iface.exists("sip-port") ? (int)iface["sip-port"] : 5060; OSS::IPAddress listener; listener = ip; listener.setPort(port); _fsmDispatch.transport().defaultListenerAddress() = listener; } else if (iface.exists("tcp-enabled") && (bool)iface["tcp-enabled"]) { int port = iface.exists("sip-port") ? (int)iface["sip-port"] : 5060; OSS::IPAddress listener; listener = ip; listener.setPort(port); _fsmDispatch.transport().defaultListenerAddress() = listener; } else if (iface.exists("ws-enabled") && (bool)iface["ws-enabled"]) { int port = iface.exists("sip-port") ? (int)iface["sip-port"] : 5060; OSS::IPAddress listener; listener = ip; listener.setPort(port); _fsmDispatch.transport().defaultListenerAddress() = listener; } else if (iface.exists("tls-enabled") && (bool)iface["tls-enabled"]) { int port = iface.exists("tls-port") ? (int)iface["tsl-port"] : 5061; OSS::IPAddress listener; listener = ip; listener.setPort(port); _fsmDispatch.transport().defaultListenerAddress() = listener; } } // // Set the TCP port range // if (listeners.exists("sip-tcp-port-base") && listeners.exists("sip-tcp-port-max")) { unsigned int tcpPortBase = listeners["sip-tcp-port-base"]; unsigned int tcpPortMax = listeners["sip-tcp-port-max"]; if (tcpPortBase < tcpPortMax && tcpPortBase > 0) { OSS_LOG_INFO("Setting TCP port range to " << tcpPortBase << "-" << tcpPortMax); transport().setTCPPortRange((unsigned short)tcpPortBase, (unsigned short)tcpPortMax); } else { OSS_LOG_ERROR("Unable to set TCP port base " << tcpPortBase << "-" << tcpPortMax << " Using default values."); } } // // Set the TCP port range // if (listeners.exists("sip-ws-port-base") && listeners.exists("sip-ws-port-max")) { unsigned int wsPortBase = listeners["sip-ws-port-base"]; unsigned int wsPortMax = listeners["sip-ws-port-max"]; if (wsPortBase < wsPortMax && wsPortBase > 0) { OSS_LOG_INFO("Setting WebSocket port range to " << wsPortBase << "-" << wsPortMax); transport().setWSPortRange((unsigned short)wsPortBase, (unsigned short)wsPortMax); } else { OSS_LOG_ERROR("Unable to set WebSocket port base " << wsPortBase << "-" << wsPortMax << " Using default values."); } } if (listeners.exists("packet-rate-ratio")) { std::string packetRateRatio = (const char*)listeners["packet-rate-ratio"]; std::vector<std::string> tokens = OSS::string_tokenize(packetRateRatio, "/"); if (tokens.size() == 3) { unsigned long packetsPerSecondThreshold; unsigned long thresholdViolationRate; int banLifeTime; thresholdViolationRate = OSS::string_to_number<unsigned long>(tokens[0].c_str()); packetsPerSecondThreshold = OSS::string_to_number<unsigned long>(tokens[1].c_str()); banLifeTime = OSS::string_to_number<int>(tokens[2].c_str()); if (packetsPerSecondThreshold > thresholdViolationRate) { SIPTransportSession::rateLimit().enabled() = true; SIPTransportSession::rateLimit().autoBanThresholdViolators() = true; SIPTransportSession::rateLimit().setPacketsPerSecondThreshold(packetsPerSecondThreshold); SIPTransportSession::rateLimit().setThresholdViolationRate(thresholdViolationRate); SIPTransportSession::rateLimit().setBanLifeTime(banLifeTime); OSS_LOG_INFO("Enforcing packet rate limit = " << packetRateRatio); } if (listeners.exists("packet-rate-white-list")) { DataType whiteList = listeners["packet-rate-white-list"]; int count = whiteList.getElementCount(); for (int i = 0; i < count; i++) { DataType wl = whiteList[i]; std::string entry; if (wl.exists("source-ip")) { entry = (const char*)wl["source-ip"]; if (!entry.empty()) { boost::system::error_code ec; boost::asio::ip::address ip = boost::asio::ip::address::from_string(entry, ec); if (!ec) SIPTransportSession::rateLimit().whiteListAddress(ip); } } else if (wl.exists("source-network")) { entry = (const char*)wl["source-network"]; if (!entry.empty()) SIPTransportSession::rateLimit().whiteListNetwork(entry); } } } } } transportInit(); }
ClassType * StrucViewItem::flattenTypeDesc( Symbol * sym, WString & desc ) //------------------------------------------------------------------------ { ClassType * classType = NULL; char * str = NULL; WVList typeParts; Description * entry; int i; REQUIRE( sym != NULL, "strucview::flatten passed null symbol!" ); dr_sym_type stype = sym->symtype(); REQUIRE( stype != DR_SYM_NOT_SYM,"strucview::flatten bad set"); switch( stype ) { case DR_SYM_VARIABLE: // need to find out the type of the data member ((VariableSym *) sym)->loadTypeInfo( typeParts ); for( i = 0; i < typeParts.count(); i++ ) { entry = (Description *) typeParts[i]; if( entry->_nameGoesHere ) { desc.concat( entry->u.text ); } else { if( !sym->isEqual( entry->u.sym ) ){ if( classType == NULL ) { classType = flattenTypeDesc( entry->u.sym, desc ); } else { desc.concat( entry->u.sym->name() ); } } } } break; case DR_SYM_TYPEDEF: case DR_SYM_ENUM: sym->description( typeParts ); for( i = 0; i < typeParts.count(); i++ ) { entry = (Description *) typeParts[ i ]; if( entry->_isUserDefined ) { if( entry->u.sym->symtype() == DR_SYM_CLASS && classType == NULL ) { classType = (ClassType *) entry->u.sym; } } } desc.concat( sym->name() ); break; case DR_SYM_CLASS: if( _parent->isSeen( sym ) ) { desc.concat( sym->name() ); classType = NULL; } else { classType = (ClassType *) sym; desc.concat( classType->name() ); } break; default: {} } for( i=0; i < typeParts.count(); i++ ) { entry = (Description *) typeParts[ i ]; if( entry->_isUserDefined && entry->u.sym != classType && entry->u.sym != sym ) { delete entry->u.sym; } } typeParts.deleteContents(); return classType; }