static bool test_find_no_subheaders(void)
{
bool success = true;
/* Init */
struct ipv6hdr *hdr6;
unsigned char *payload;
hdr6 = kmalloc_packet(4, NEXTHDR_UDP);
if (!hdr6)
return false;
payload = add_payload(hdr6, HDR6_LEN);
/* Test */
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_FRAGMENT),
"Frag hdr");
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_HOP),
"Hop-by-hop hdr");
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_ESP),
"ESP hdr");
success &= ASSERT_PTR(hdr6 + 1, hdr_iterator_find(hdr6, NEXTHDR_UDP),
"Payload");
/* End */
kfree(hdr6);
return success;
}
static bool test_next_subheaders(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_hop;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_HOP);
hdr_hop = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, NEXTHDR_ROUTING);
hdr_route = add_route_hdr(hdr_hop, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
success &= ASSERT_PTR(hdr_frag, iterator.data, "Frag:data");
success &= ASSERT_UINT(NEXTHDR_FRAGMENT, iterator.hdr_type,
"Frag:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 1");
success &= ASSERT_PTR(hdr_hop, iterator.data, "Hop:data");
success &= ASSERT_UINT(NEXTHDR_HOP, iterator.hdr_type, "Hop:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 2");
success &= ASSERT_PTR(hdr_route, iterator.data, "Routing:data");
success &= ASSERT_UINT(NEXTHDR_ROUTING, iterator.hdr_type,
"Routing:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 3");
success &= ASSERT_PTR(payload, iterator.data, "Payload1:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload1:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Next 4");
success &= ASSERT_PTR(payload, iterator.data, "Payload2:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload2:type");
/* Fall through. */
end:
kfree(hdr6);
return success;
}
void SymbolCheckVisitor::visit(ASTSuper& ast)
{
ASSERT_PTR(mpClass);
ASSERT_PTR(mpFunction);
if ( mpClass->hasBaseType() && mpClass->getBaseType().isUnknown() )
{
// skip calls to the unknown super class
return;
}
if ( mpFunction->getModifiers().isStatic() )
{
// statics do not have a this (thus also not a super)
String str = ast.getKind() == ASTSuper::eThis ? UTEXT("this") : UTEXT("super");
error(E0031, UTEXT("Can not access ") + str + UTEXT(" from a static function."), ast);
return;
}
ASTClass* pclass = ast.isThis() ? mpClass : &mpClass->getBaseClass();
if ( ast.isCall() )
{
ASTSignature signature;
ASTNodes& arguments = ast.getArguments();
for ( int index = 0; index < arguments.size(); index++ )
{
ASTExpression& expr = dynamic_cast<ASTExpression&>(arguments[index]);
expr.accept(*this);
signature.append(mCurrentType.clone());
}
ASTTypeList types;
ASTFunction* pconstructor = pclass->findBestMatch(pclass->getName(), signature, types);
if ( pconstructor != NULL )
{
ast.setConstructor(pconstructor);
}
else
{
String arguments = String("(") + signature.toString() + ')';
error(E0032, UTEXT("No constructor ") + pclass->getFullName() + arguments + UTEXT(" defined."), ast);
}
// calls to this and super return nothing (void)
mCurrentType = ASTType::SVoidType;
}
else
{
// note: pclass already is correct class for this or super
mCurrentType.setKind(ASTType::eObject);
mCurrentType.setObjectName(pclass->getFullName());
mCurrentType.setObjectClass(*pclass);
}
}
static bool test_add_and_remove(void)
{
struct rb_root root = RB_ROOT;
struct node_thing nodes[4];
bool expecteds[4];
int i;
struct node_thing *exists;
bool success = true;
for (i = 0; i < ARRAY_SIZE(nodes); i++) {
nodes[i].i = i;
RB_CLEAR_NODE(&nodes[i].hook);
expecteds[i] = false;
}
exists = add(&root, &nodes[1]);
success &= ASSERT_PTR(NULL, exists, "exists 1");
expecteds[1] = true;
success &= check_nodes(&root, expecteds);
if (!success)
return false;
exists = add(&root, &nodes[3]);
success &= ASSERT_PTR(NULL, exists, "exists 2");
expecteds[3] = true;
success &= check_nodes(&root, expecteds);
if (!success)
return false;
exists = add(&root, &nodes[0]);
success &= ASSERT_PTR(NULL, exists, "exists 3");
expecteds[0] = true;
success &= check_nodes(&root, expecteds);
if (!success)
return false;
exists = add(&root, &nodes[2]);
success &= ASSERT_PTR(NULL, exists, "exists 4");
expecteds[2] = true;
success &= check_nodes(&root, expecteds);
rb_erase(&nodes[2].hook, &root);
expecteds[2] = false;
success &= check_nodes(&root, expecteds);
if (!success)
return false;
return success;
}
static bool test_last_unsupported(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_esp;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP);
hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN);
hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
hdr_iterator_last(&iterator);
success &= ASSERT_PTR(hdr_esp, iterator.data, "Last:data");
success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "Last:type");
/* End */
kfree(hdr6);
return success;
}
void SymbolCheckVisitor::visit(ASTFunction& ast)
{
ScopedScope scope(mScopeStack);
ScopedValue<ASTFunction*> scopedfunction(&mpFunction, &ast, mpFunction);
ASSERT_PTR(mpFunction);
visitChildren(ast); // <-- arguments
if ( ast.isConstructor() && ast.getName() != mpClass->getName() )
{
error(E0005, UTEXT("Function ") + ast.getName() + UTEXT(" must have a return type (or equal class name as constructor)."), ast);
}
if ( ast.hasBody() )
{
if ( ast.getModifiers().isAbstract() )
{
error(E0006, UTEXT("Abstract function ") + ast.getName() + UTEXT(" should not have a body."), ast);
}
else
{
checkReturn(ast);
ast.getBody().accept(*this);
}
}
else if ( !ast.getModifiers().isAbstract() && !ast.getModifiers().isPureNative() )
{
error(E0007, UTEXT("Function ") + ast.getName() + UTEXT(" requires a body."), ast);
}
mCurrentType.clear();
}
/// \fn ResourceManager::loadTexture (const std::string& file)
/// \brief Returns a texture from a the given file.
TexturePtr ResourceManager::getTexture(const String& file)
{
ResourceHandle<Graphics::Texture>* phandle = NULL;
if ( !mResources.contains(file) )
{
String path = sPath + file;
std::unique_ptr<Graphics::Texture> texture(mContentManager.loadContent<Graphics::Texture>(path));
if ( !(texture) )
return TexturePtr();
phandle = new ResourceHandle<Graphics::Texture>(*this, texture.release());
phandle->setName(file);
ResourceHandleBase* pbasehandle = phandle; // needed for *& in container, perhaps time to change that..
mResources.insert(file, pbasehandle);
}
else
{
phandle = static_cast<ResourceHandle<Graphics::Texture>*>(*mResources.get(file));
}
ASSERT_PTR(phandle);
return TexturePtr(phandle);
}
VirtualArray* CPU::instantiateArray()
{
ASSERT_PTR(mpArrayClass);
VirtualArray* parray = new VirtualArray();
mGC.collect(parray);
return parray;
}
void VirtualObject::setMember(int index, const VirtualValue& value)
{
ASSERT_PTR(mpMembers);
ASSERT(index < mMemberCount);
mpMembers[index] = value;
}
void IRGenerator::buildTableBlocks(VirtualLookupTable& table)
{
Block& block_end = createBlock(table.getEnd());
block_end.plookup = &table;
block_end.lookup_type = Block::eEnd;
if ( table.hasDefault() )
{
Block& block_default = createBlock(table.getDefault());
block_default.plookup = &table;
block_default.lookup_type = Block::eDefault;
}
std::vector<int> values = table.getPositions();
for ( std::size_t index = 0; index < values.size(); ++index )
{
int pos = values[index];
const VirtualValue* pvalue = table.lookup(pos);
ASSERT_PTR(pvalue);
Block& block_case = createBlock(pos);
block_case.plookup = &table;
block_case.lookup_type = Block::eValue;
block_case.lookup_value = *pvalue;
}
}
void
session_delete(struct session *session)
{
/* Tell the other side */
ASSERT_PTR(session);
ASSERT_PTR(session->server);
ASSERT_PTR(session->server->owner);
assert(is_thread(session->server));
pd_release_clist(session->server->owner, session->clist);
session_p_list_delete(session->owner_node);
session_p_list_delete(session->server_node);
session_p_list_delete(session->client_node);
/* Then nuke everything */
session->magic = 0;
free(session);
}
static bool test_next_unsupported(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_esp;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP);
hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN);
hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
success &= ASSERT_PTR(hdr_frag, iterator.data, "Frag:pointer");
success &= ASSERT_UINT(NEXTHDR_FRAGMENT, iterator.hdr_type,
"Frag:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 1");
success &= ASSERT_PTR(hdr_esp, iterator.data, "ESP1:pointer");
success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "ESP1:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Next 2");
success &= ASSERT_PTR(hdr_esp, iterator.data, "ESP2:pointer");
success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "ESP2:type");
/* Fall through. */
end:
kfree(hdr6);
return success;
}
Module& Module::lookupModule(const Uuid& uuid)
{
ASSERT_PTR(mpManager);
Module* pmodule = mpManager->lookup(uuid);
if ( pmodule == NULL )
{
throw new std::exception();
}
return *pmodule;
}
/**
* Same as above, the only difference is that we set NULL the mtu_plateaus from
* the local translate config.
*/
static bool translate_nulls_mtu(void)
{
int error;
unsigned char *buffer;
size_t buffer_len;
bool success = true;
struct global_config config = { .mtu_plateaus = NULL };
struct global_config response = { .mtu_plateaus = NULL };
error = config_clone(&config);
if (error)
return false;
/*
* lets modify our local config manually, jool's update functions wont
* update to null
*/
config.mtu_plateaus = NULL;
config.mtu_plateau_count = 0;
error = serialize_global_config(&config, true, &buffer, &buffer_len);
if (error)
return false;
error = deserialize_global_config(buffer, buffer_len, &response);
if (error)
return false;
success &= compare_global_configs(&config, &response);
/* the "compare_global_configs" will not evaluate the mtu_plateaus
* because of the plateau_count = 0
*/
success &= ASSERT_PTR(NULL, config.mtu_plateaus,
"local config mtu_plateaus");
success &= ASSERT_PTR(NULL, response.mtu_plateaus,
"deserialized config mtu_plateaus");
kfree(buffer);
return success;
}
void SymbolCheckVisitor::visit(ASTNative& ast)
{
if ( ast.hasArguments() )
{
ASSERT_PTR(mpFunction);
const ASTSignature& signature = mpFunction->getSignature();
ASTNodes& arguments = ast.getArguments();
for ( int index = 0; index < arguments.size(); index++ )
{
ASTExpression& expr = dynamic_cast<ASTExpression&>(arguments[index]);
expr.accept(*this);
const ASTType& sigtype = signature[index];
if ( !mCurrentType.greater(sigtype) )
{
String sidx;
NumberConverter::getInstance().format(sidx, index);
String func = mpClass->getFullName() + '.' + mpFunction->getName();
error(E0033, UTEXT("While calling native implementation of function ")
+ func
+ UTEXT("; argument ")
+ sidx
+ UTEXT(" of can not be mapped from ")
+ mCurrentType.toString()
+ UTEXT(" to ")
+ sigtype.toString(), ast);
}
}
ASTTypeList types;
if ( !mpFunction->getSignature().bestMatch(signature, types) )
{
String arguments = signature.toString();
error(E0034, UTEXT("Arguments to native do not match ") + arguments, ast);
}
}
ASSERT_PTR(mpFunction);
mCurrentType = mpFunction->getType();
}
const String& IniFile::get(const String& section, const String& name)
{
auto it = mSections.find(section);
if ( it == mSections.end() )
{
throw new IniFileException(UTEXT("Section ") + name + UTEXT(" could not be found."));
}
IniFileSection* psection = it->second;
ASSERT_PTR(psection);
return psection->get(name);
}
bool
ElementExecutor::execute(const Data& data)
{
ASSERT_PTR(data.element.get());
const std::string elem_type = data.element->elementType();
if (elem_type == "SimpleTextElement") {
return executeSimpleText(data);
}
LOG_ERROR("Unknown element type, cannot be executed: %s", elem_type.c_str());
return false;
}
static bool test_find_subheaders(void)
{
bool success = true;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_hop;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_HOP);
hdr_hop = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, NEXTHDR_ROUTING);
hdr_route = add_route_hdr(hdr_hop, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
success &= ASSERT_PTR(hdr_frag,
hdr_iterator_find(hdr6, NEXTHDR_FRAGMENT),
"Frag hdr");
success &= ASSERT_PTR(hdr_hop, hdr_iterator_find(hdr6, NEXTHDR_HOP),
"Hop-by-hop hdr");
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_ESP),
"ESP hdr");
success &= ASSERT_PTR(hdr_route,
hdr_iterator_find(hdr6, NEXTHDR_ROUTING),
"Routing hdr");
success &= ASSERT_PTR(payload, hdr_iterator_find(hdr6, NEXTHDR_UDP),
"Payload");
/* End */
kfree(hdr6);
return success;
}
static bool test_next_no_subheaders(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
unsigned char *payload;
hdr6 = kmalloc_packet(4, NEXTHDR_UDP);
if (!hdr6)
return false;
payload = add_payload(hdr6, HDR6_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
success &= ASSERT_PTR(payload, iterator.data, "Payload1:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload1:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result1");
success &= ASSERT_PTR(payload, iterator.data, "Payload2:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload2:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result2");
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result3");
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result4");
success &= ASSERT_PTR(payload, iterator.data, "Payload3:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload3:type");
/* Fall through. */
end:
kfree(hdr6);
return success;
}
/// \fn NetConnection::findOrCreate(const NetAddress& client)
/// \brief Finds or creates an address based on the given client info
/// \return the clientid of the client or INVALID_CLIENTID when not found (e.g. when not accepting)
NetAddress& NetConnection::findOrCreate(const NetAddress& client)
{
NetAddress* pclient = mClients.find(client);
if ( pclient == NULL )
{
if ( IS_SET(mFlags, eAccept) )
{
pclient = &addNewClient(client);
}
}
ASSERT_PTR(pclient);
return *pclient;
}
static bool test_find_unsupported(void)
{
bool success = true;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_esp;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP);
hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN);
hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
success &= ASSERT_PTR(hdr_frag,
hdr_iterator_find(hdr6, NEXTHDR_FRAGMENT),
"Frag hdr");
success &= ASSERT_PTR(hdr_esp, hdr_iterator_find(hdr6, NEXTHDR_ESP),
"ESP header");
/* The ESP header is in the way. */
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_ROUTING),
"Routing header");
/* Same, but that isn't an extension header anyway. */
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_UDP),
"Payload");
/* End */
kfree(hdr6);
return success;
}
/*----------------------------------------------------------------------
* Routine silo_Read
*
* Purpose
*
* Read the requested variable from the specified DB.
*
*--------------------------------------------------------------------*/
INTERNAL int
silo_Read (int dbid, char *varname, void *ptr)
{
ASSERT_NAME(varname, 0);
ASSERT_PTR(ptr, 0);
ASSERT_DBID(dbid, 0);
if (lite_PD_read(silo_table[dbid].pdbfile, varname, ptr) == 0) {
silo_Error("Cannot read requested variable.", SILO_DEBUG);
return (OOPS);
}
return (OKAY);
}
EntityDefinitionProto* EntityLoader::loadDefinition(const TiXmlElement& entity)
{
EntityDefinitionProto* pentitydef = new EntityDefinitionProto();
const char* pname = entity.Attribute("name");
pentitydef->mName = String::fromUtf8(pname);
const char* pclasstype = entity.Attribute("class");
pentitydef->mClassName = (pclasstype != NULL ? String::fromUtf8(pclasstype) : UTEXT("engine.game.Entity"));
for ( const TiXmlElement* pelement = entity.FirstChildElement(); pelement != NULL; pelement = pelement->NextSiblingElement() )
{
String name = String::fromUtf8(pelement->Value());
if ( name == sChild )
{
loadChildDefinition(*pentitydef, *pelement);
}
else if ( name == sLink )
{
loadLinkDefinition(*pentitydef, *pelement);
}
else if ( name == sEntity )
{
EntityDefinitionProto* pentity = loadDefinition(*pelement);
pentitydef->mEntities.push_back(pentity);
}
else
{
Loaders::iterator it = mLoaders.find(name);
if ( it != mLoaders.end() )
{
ComponentLoader* ploader = it->second;
ASSERT_PTR(ploader);
ComponentDefinitionProto* pdefinition = ploader->load(*pelement);
if ( pdefinition == NULL )
{
// throw and error!
}
pentitydef->mComponents.push_back(pdefinition);
}
}
}
return pentitydef;
}
void Console::warning(const char* msg, ...)
{
//ASSERT_MSG(lines, "ERROR - the console has not been created yet.");
ASSERT_PTR(msg);
char text[256];
va_list ap;
va_start(ap, msg);
vsprintf(text, msg, ap);
va_end(ap);
std::string errormsg = "WARNING - ";
errormsg += text;
//lines->addString(errormsg.c_str());
Log::getInstance() << errormsg.c_str() << '\n';
}
void CollisionContact::prepare(float timestep)
{
if ( mpLeft == NULL )
mpLeft = mpRight;
ASSERT_PTR(mpLeft);
mpLeft->prepare(mPoint);
if ( mpRight != NULL )
mpRight->prepare(mPoint);
calculateContactBasis();
mContactVelocity = calculateLocalVelocity(*mpLeft, timestep);
if ( mpRight != NULL )
mContactVelocity -= calculateLocalVelocity(*mpRight, timestep);
calculateDesiredDeltaVelocity(timestep);
}
void OOCheckVisitor::visit(ASTClass& ast)
{
mpClass = *
ASSERT_PTR(mpClass);
if ( mpClass->isClass() )
{
if ( mpClass->hasAbstractFunction() )
{
if ( !ast.getModifiers().isAbstract() )
{
error(E0052, UTEXT("Class ") + mpClass->getName() + UTEXT(" must be defined as abstract."), ast);
}
}
if ( ast.hasBaseClass() && ast.getBaseClass().getModifiers().isFinal() )
{
error(E0053, UTEXT("Class ") + ast.getName() + UTEXT(" can not extend final class ") + ast.getBaseClass().getName(), ast);
}
if ( ast.getModifiers().isAbstract() && !mpClass->hasAbstractFunction() )
{
warning(W0004, UTEXT("Class ") + ast.getName() + UTEXT(" is marked abstract without abstract functions."), ast);
}
}
else
{
ASSERT(mpClass->isInterface());
}
if ( ast.isNative() )
{
// a class is native if its either marked native or has one or native functions
ast.getModifiers().setNative();
}
validateClass(ast);
visitChildren(ast);
}
Glyph* D3DGlyphProvider::getGlyph(UChar ch, float emsize)
{
HRESULT hr = S_OK;
IDWriteTextLayout* ptextlayout = NULL;
ASSERT_PTR(mpTextFormat);
hr = mpDWriteFactory->CreateTextLayout(&ch, 1, mpTextFormat, 512, 512, &ptextlayout);
if ( SUCCEEDED(hr) )
{
DWRITE_TEXT_RANGE range = { 0, 0 };
ptextlayout->SetFontSize(emsize, range);
AutoPtr<Glyph> glyph = new Glyph();
hr = ptextlayout->Draw(glyph.getPointer(), mpTextRenderer, 0, 0);
if ( SUCCEEDED(hr) )
{
return glyph.release();
}
}
return NULL;
}
static bool test_last_no_subheaders(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
unsigned char *payload;
hdr6 = kmalloc_packet(4, NEXTHDR_UDP);
if (!hdr6)
return false;
payload = add_payload(hdr6, HDR6_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
hdr_iterator_last(&iterator);
success &= ASSERT_PTR(payload, iterator.data, "Last:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Last:type");
/* End */
kfree(hdr6);
return success;
}
const VirtualClass& VirtualFunction::getClass() const
{
ASSERT_PTR(mpClass);
return *mpClass;
}
ASTType& ASTType::getArrayType()
{
ASSERT(isArray());
ASSERT_PTR(mpArrayType);
return *mpArrayType;
}
