enum CXChildVisitResult parentedDeclAndRefListBuilder(CXCursor cursor, CXCursor parent, CXClientData clientData) { ParentedCursorListPair* declsAndRefs = (ParentedCursorListPair*) clientData; if (clang_isDeclaration(clang_getCursorKind(cursor))) { ParentedCursor newEntry = { parent, cursor }; ParentedCursorList* decls = &declsAndRefs->decls; LIST_APPEND(ParentedCursor, decls, newEntry); } if (clang_isReference(clang_getCursorKind(cursor))) { ParentedCursor newEntry = { parent, cursor }; ParentedCursorList* refs = &declsAndRefs->refs; LIST_APPEND(ParentedCursor, refs, newEntry); } return CXChildVisit_Recurse; }
enum CXChildVisitResult childListBuilder(CXCursor cursor, CXCursor parent, CXClientData clientData) { CursorList* childList = (CursorList*) clientData; LIST_APPEND(CXCursor, childList, cursor); return CXChildVisit_Continue; }
enum CXChildVisitResult descendantListBuilder(CXCursor cursor, CXCursor parent, CXClientData clientData) { CursorList* childList = (CursorList*) clientData; LIST_APPEND(CXCursor, childList, cursor); return CXChildVisit_Recurse; }
struct list * get_rib_routes() { sisis_dump_kernel_routes(); struct listnode * node; struct listnode * appnd_node; struct list * addr_list = calloc(1, sizeof(struct list)); LIST_FOREACH(ipv4_rib_routes, node) { struct route_ipv4 * route = (struct route_ipv4 *)node->data; struct addr * cur_addr; // Set up prefix char prefix_str[INET_ADDRSTRLEN]; if (inet_ntop(AF_INET, &(route->p->prefix.s_addr), prefix_str, INET_ADDRSTRLEN) != 1) { cur_addr = parse_ip_address(prefix_str); if(strcmp(cur_addr->pre, "26") == 0) { appnd_node = calloc(1, sizeof(struct listnode)); appnd_node->data = (void *) cur_addr; LIST_APPEND(addr_list, appnd_node); } else { free(cur_addr); cur_addr = NULL; } } } return addr_list; }
inline static void* _win32_allocMem( size_t memSize ) { const size_t pageRegionRequestSize = _win32_getRealPageSize( memSize ); _memIntro *mem = (_memIntro*)_win32_allocMemPage( pageRegionRequestSize ); _memOutro *outro = (_memOutro*)( (unsigned char*)( mem + 1 ) + memSize ); #ifdef PAGE_HEAP_ERROR_ON_LOWMEM MEM_INTERRUPT( mem == NULL ); #else if ( mem == NULL ) return NULL; #endif //PAGE_HEAP_ERROR_ON_LOWMEM // Fill memory with debug pattern { size_t metaSize = _getMetaSize( memSize ); memset( mem, PAGE_MEM_ACTIVE_DEBUG_PATTERN, metaSize ); memset( outro + 1, PAGE_MEM_DEBUG_PATTERN, pageRegionRequestSize - metaSize ); } mem->checksum = 0xCAFEBABE; mem->objSize = memSize; LIST_APPEND( g_privateMemory.root, mem->memList ); outro->checksum = 0xBABECAFE; return mem + 1; }
int ffsox_source_append(source_t *si, packet_consumer_t *pc) { packet_consumer_list_t consumer; #if defined (PBU_DEBUG) // [ ffsox_packet_consumer_list_t *n; packet_consumer_t *consumer_cur; #endif // ] consumer.consumer=pc; //DVWRITELN("pc->vmt->name: \"%s\"",pc->vmt->name); if (LIST_APPEND(si->consumer.h,consumer)<0) { DMESSAGE("appending chain"); goto append; } pc->prev=si; #if defined (PBU_DEBUG) // [ for (n=si->consumer.h;n;LIST_NEXT(&n,si->consumer.h)) { consumer_cur=n->consumer; //DVWRITELN("consumer_cur->vmt->name: \"%s\", consumer_cur->si.stream_index: %d",consumer_cur->vmt->name,consumer_cur->si.stream_index); (void)consumer_cur; } #endif // ] return 0; append: return -1; }
int address_new_static(Network *network, unsigned section, Address **ret) { _cleanup_address_free_ Address *address = NULL; if (section) { address = hashmap_get(network->addresses_by_section, UINT_TO_PTR(section)); if (address) { *ret = address; address = NULL; return 0; } } address = new0(Address, 1); if (!address) return -ENOMEM; address_init(address); address->network = network; LIST_APPEND(addresses, network->static_addresses, address); if (section) { address->section = section; hashmap_put(network->addresses_by_section, UINT_TO_PTR(address->section), address); } *ret = address; address = NULL; return 0; }
/* Either of the permitted or excluded subtree pointers may be NULL, to be considered undefined. */ void ssh_x509_cert_set_name_constraints(SshX509Certificate c, SshX509GeneralSubtree permitted, SshX509GeneralSubtree excluded, Boolean critical) { if (permitted) LIST_APPEND(SshX509GeneralSubtreeStruct, c->extensions.name_const_permitted, permitted); if (excluded) LIST_APPEND(SshX509GeneralSubtreeStruct, c->extensions.name_const_excluded, excluded); if (permitted || excluded) ssh_x509_ext_info_set(&c->extensions.ext_available, &c->extensions.ext_critical, SSH_X509_EXT_NAME_CNST, critical); }
enum CXChildVisitResult referenceListBuilder(CXCursor cursor, CXCursor parent, CXClientData clientData) { if (clang_isReference(clang_getCursorKind(cursor))) { CursorList* childList = (CursorList*) clientData; LIST_APPEND(CXCursor, childList, cursor); } return CXChildVisit_Recurse; }
void ssh_x509_cert_set_crl_dist_points(SshX509Certificate c, SshX509ExtCRLDistPoints dps, Boolean critical) { LIST_APPEND(SshX509ExtCRLDistPointsStruct, c->extensions.crl_dp, dps); ssh_x509_ext_info_set(&c->extensions.ext_available, &c->extensions.ext_critical, SSH_X509_EXT_CRL_DIST_POINTS, critical); }
void ssh_x509_cert_set_policy_info(SshX509Certificate c, SshX509ExtPolicyInfo pinfo, Boolean critical) { LIST_APPEND(SshX509ExtPolicyInfoStruct, c->extensions.policy_info, pinfo); ssh_x509_ext_info_set(&c->extensions.ext_available, &c->extensions.ext_critical, SSH_X509_EXT_CERT_POLICIES, critical); }
void ssh_x509_cert_set_subject_info_access(SshX509Certificate c, SshX509ExtInfoAccess access, Boolean critical) { LIST_APPEND(SshX509ExtInfoAccessStruct, c->extensions.subject_info_access, access); ssh_x509_ext_info_set(&c->extensions.ext_available, &c->extensions.ext_critical, SSH_X509_EXT_SUBJECT_INFO_ACCESS, critical); }
void ssh_x509_cert_set_policy_mappings(SshX509Certificate c, SshX509ExtPolicyMappings pmappings, Boolean critical) { LIST_APPEND(SshX509ExtPolicyMappingsStruct, c->extensions.policy_mappings, pmappings); ssh_x509_ext_info_set(&c->extensions.ext_available, &c->extensions.ext_critical, SSH_X509_EXT_POLICY_MAPPINGS, critical); }
void ssh_x509_cert_set_freshest_crl(SshX509Certificate c, SshX509ExtCRLDistPoints fresh, Boolean critical) { LIST_APPEND(SshX509ExtCRLDistPointsStruct, c->extensions.freshest_crl, fresh); ssh_x509_ext_info_set(&c->extensions.ext_available, &c->extensions.ext_critical, SSH_X509_EXT_FRESHEST_CRL, critical); }
void chunk_append_free(struct malloc_infos *list, struct chunk *chunk) { int i; i = free_bucket(chunk->size); LIST_APPEND(list->lfree[i], chunk, free); list->lfree_cnt[i]++; chunk->type = MALLOC_CHUNK_FREE; chunk->asked_size = 0; }
void ssh_x509_cert_set_ext_key_usage(SshX509Certificate c, SshX509OidList ext_key_usage, Boolean critical) { LIST_APPEND(SshX509OidListStruct, c->extensions.ext_key_usage, ext_key_usage); ssh_x509_ext_info_set(&c->extensions.ext_available, &c->extensions.ext_critical, SSH_X509_EXT_EXT_KEY_USAGE, critical); }
void ssh_x509_cert_set_subject_directory_attr(SshX509Certificate c, SshX509ExtDirAttribute subject_dattr, Boolean critical) { LIST_APPEND(SshX509ExtDirAttributeStruct, c->extensions.subject_directory_attr, subject_dattr); ssh_x509_ext_info_set(&c->extensions.ext_available, &c->extensions.ext_critical, SSH_X509_EXT_SUBJECT_DIR_ATTR, critical); }
void TextureBase::AddToDictionary( TexDictionary *dict ) { this->RemoveFromDictionary(); // Note: original RenderWare performs an insert, not an append. // I switched this around, so that textures stay in the correct order. LIST_APPEND( dict->textures.root, texDictNode ); dict->numTextures++; this->texDict = dict; }
void display_windows(struct list * addr_list, int argc, char * argv[]) { struct listnode * addr_node; struct listnode * local_addr_node; LIST_FOREACH(addr_list, addr_node) { struct addr * cur_addr = (struct addr *)addr_node->data; if(strcmp(cur_addr->type, "1") == 0) { char * host = cur_addr->host; struct list * addr_list_procs = calloc(1, sizeof(struct list)); LIST_FOREACH(addr_list, local_addr_node) { struct addr * local_cur_addr = (struct addr *)local_addr_node->data; if((strcmp(local_cur_addr->type, "1") != 0) && (strcmp(local_cur_addr->host, host) == 0)) { printf("%s\n", local_cur_addr->prefix_str); struct listnode * node_to_be_added = calloc(1, sizeof(struct listnode)); struct addr * addr_to_be_added = calloc(1, sizeof(struct addr)); node_to_be_added->data = (void *)addr_to_be_added; memcpy(addr_to_be_added, local_cur_addr, sizeof(struct addr)); printf("memcpied %s\n", addr_to_be_added->prefix_str); LIST_APPEND(addr_list_procs, node_to_be_added); } } LIST_FOREACH(addr_list_procs, local_addr_node) { struct addr * local_cur_addr = (struct addr *)local_addr_node->data; printf("address copied: %s\n", local_cur_addr->prefix_str); } // create new child for each window pid_t pid = fork(); if(pid == 0) { if (!g_thread_supported ()){ g_thread_init(NULL); } gdk_threads_init(); gdk_threads_enter(); gtk_init(&argc, &argv); display_window(cur_addr, addr_list_procs); gdk_threads_leave(); // make sure child doesn't fork again _exit(0); } } }
enum CXChildVisitResult parentedDescendantListBuilder(CXCursor cursor, CXCursor parent, CXClientData clientData) { ParentedCursorList* descendantList = (ParentedCursorList*) clientData; ParentedCursor newEntry = { parent, cursor }; LIST_APPEND(ParentedCursor, descendantList, newEntry); return CXChildVisit_Recurse; }
int prefix_new_static(Network *network, const char *filename, unsigned section_line, Prefix **ret) { _cleanup_network_config_section_free_ NetworkConfigSection *n = NULL; _cleanup_prefix_free_ Prefix *prefix = NULL; int r; assert(network); assert(ret); assert(!!filename == (section_line > 0)); if (filename) { r = network_config_section_new(filename, section_line, &n); if (r < 0) return r; if (section_line) { prefix = hashmap_get(network->prefixes_by_section, n); if (prefix) { *ret = prefix; prefix = NULL; return 0; } } } r = prefix_new(&prefix); if (r < 0) return r; if (filename) { prefix->section = n; n = NULL; r = hashmap_put(network->prefixes_by_section, prefix->section, prefix); if (r < 0) return r; } prefix->network = network; LIST_APPEND(prefixes, network->static_prefixes, prefix); network->n_static_prefixes++; *ret = prefix; prefix = NULL; return 0; }
static int prefix_new_static(Network *network, const char *filename, unsigned section_line, Prefix **ret) { _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL; _cleanup_(prefix_freep) Prefix *prefix = NULL; int r; assert(network); assert(ret); assert(!!filename == (section_line > 0)); if (filename) { r = network_config_section_new(filename, section_line, &n); if (r < 0) return r; if (section_line) { prefix = hashmap_get(network->prefixes_by_section, n); if (prefix) { *ret = TAKE_PTR(prefix); return 0; } } } r = prefix_new(&prefix); if (r < 0) return r; prefix->network = network; LIST_APPEND(prefixes, network->static_prefixes, prefix); network->n_static_prefixes++; if (filename) { prefix->section = TAKE_PTR(n); r = hashmap_ensure_allocated(&network->prefixes_by_section, &network_config_hash_ops); if (r < 0) return r; r = hashmap_put(network->prefixes_by_section, prefix->section, prefix); if (r < 0) return r; } *ret = TAKE_PTR(prefix); return 0; }
static Snapshot * _SnapCreate(const char *name) { Snapshot *sn; sn = ECALLOC(Snapshot, 1); if (!sn) return NULL; LIST_APPEND(Snapshot, &ss_list, sn); sn->name = Estrdup(name); return sn; }
void ssh_x509_cert_set_unknown_extension(SshX509Certificate c, SshX509ExtUnknown unknown) { Boolean critical; LIST_APPEND(SshX509ExtUnknownStruct, c->extensions.unknown, unknown); /* Get existing criticality bit and 'or' it with criticality bit from this extension. */ if (!ssh_x509_cert_ext_available(c, SSH_X509_EXT_UNKNOWN, &critical)) critical = FALSE; ssh_x509_ext_info_set(&c->extensions.ext_available, &c->extensions.ext_critical, SSH_X509_EXT_UNKNOWN, critical ? TRUE : unknown->critical); }
enum CXChildVisitResult parentedReferenceListBuilder(CXCursor cursor, CXCursor parent, CXClientData clientData) { ParentedCursorList* referenceList = (ParentedCursorList*) clientData; if (clang_isReference(clang_getCursorKind(cursor))) { ParentedCursor newEntry = { parent, cursor }; LIST_APPEND(ParentedCursor, referenceList, newEntry); } return CXChildVisit_Recurse; }
void inclusionListBuilder(CXFile includedFile, CXSourceLocation* inclusionStack, unsigned stackLen, CXClientData clientData) { // Skip the initial file. if (stackLen == 0) return; InclusionList* inclusionList = (InclusionList*) clientData; Inclusion newEntry = { includedFile, inclusionStack[0], stackLen == 1 // It's a direct inclusion if there's only one stack entry. }; LIST_APPEND(Inclusion, inclusionList, newEntry); }
/*========================================================= CPlaceableSAInterface::AllocateMatrix Purpose: Allocates a static matrix to this entity. Static matrices are not automatically deallocated when there is a matrix shortage. If the entity already had a transform matrix, the engine ensures that it is a static matrix. Binary offsets: (1.0 US and 1.0 EU): 0x0054F4C0 =========================================================*/ void CPlaceableSAInterface::AllocateMatrix( void ) { if ( Placeable.matrix ) { // We already have a matrix, make sure its in the active list LIST_REMOVE( *Placeable.matrix ); LIST_APPEND( pTransform->m_activeList, *Placeable.matrix ); return; } // Extend the matrix list if ( !pTransform->IsFreeMatrixAvailable() && !pTransform->FreeUnimportantMatrix() ) pTransform->NewMatrix(); // Allocate it Placeable.matrix = pTransform->AllocateStatic(); Placeable.matrix->m_entity = this; }
static int parse_drhd_u(struct acpi_ent_drhd *ent) { struct acpi_ent_drhd *drhd = ent; struct acpi_drhd_u *drhd_u; static int include_pci_all; void *sp, *ep; int ret = 0; drhd_u = alloc(sizeof(struct acpi_drhd_u)); if (!drhd_u) return -ENOMEM; memset(drhd_u, 0, sizeof(struct acpi_drhd_u)); drhd_u->address = drhd->address; #ifdef VTD_DEBUG printf("(DMAR) Register base address = %llx\n", drhd_u->address); #endif // of VTD_DEBUG if (drhd->flags & 1) { drhd_u->include_pci_all = 1 ; #ifdef VTD_DEBUG printf("(DMAR) Including ALL the other PCI devices.\n"); #endif // of VTD_DEBUG if (include_pci_all) { printf("(DMAR) There should be only one INCLUDE_PCI_ALL DRHD!!\n"); ret = -EINVAL; } include_pci_all = 1; } else { drhd_u->include_pci_all = 0 ; sp = (void *)(drhd + 1); ep = ((void *)drhd) + ent->length; ret = parse_dev_scope(sp, ep, drhd_u); } if (ret) free(drhd_u); else LIST_APPEND(drhd_list, drhd_u); return ret; }
/*========================================================= CPlaceableSAInterface::FreeMatrix Purpose: Stores the matrix as z-rotation heading and position members while adding it to the free-list of the transformation matrix cache. Binary offsets: (1.0 US and 1.0 EU): 0x0054F3B0 =========================================================*/ void CPlaceableSAInterface::FreeMatrix( void ) { CTransformSAInterface *trans = Placeable.matrix; // Crashfix: do nothing if we have no transformation. if ( !trans ) return; // Transform the entity Placeable.m_transform.m_translate = trans->vPos; Placeable.m_transform.m_heading = trans->ToHeading(); // Free the matrix Placeable.matrix = NULL; trans->m_entity = NULL; LIST_REMOVE( *trans ); LIST_APPEND( pTransform->m_freeList, *trans ); }
static int address_label_new_static(Network *network, const char *filename, unsigned section_line, AddressLabel **ret) { _cleanup_network_config_section_free_ NetworkConfigSection *n = NULL; _cleanup_address_label_free_ AddressLabel *label = NULL; int r; assert(network); assert(ret); assert(!!filename == (section_line > 0)); r = network_config_section_new(filename, section_line, &n); if (r < 0) return r; label = hashmap_get(network->address_labels_by_section, n); if (label) { *ret = label; label = NULL; return 0; } r = address_label_new(&label); if (r < 0) return r; label->section = n; n = NULL; r = hashmap_put(network->address_labels_by_section, label->section, label); if (r < 0) return r; label->network = network; LIST_APPEND(labels, network->address_labels, label); network->n_address_labels++; *ret = label; label = NULL; return 0; }