void print_addrinfo(struct addrinfo *aip) { print_flags(aip); putchar('\n'); print_family(aip); putchar('\n'); print_type(aip); putchar('\n'); print_proto(aip); putchar('\n'); printf("host: %s", aip->ai_canonname ? aip->ai_canonname : "-"); putchar('\n'); if (aip->ai_family == AF_INET) { struct sockaddr_in *sinp = (struct sockaddr_in *)aip->ai_addr; char abuf[INET_ADDRSTRLEN]; const char *addr = inet_ntop(AF_INET, &sinp->sin_addr, abuf, INET_ADDRSTRLEN); printf("address: %s\n", addr ? addr : "unknown"); printf("port: %d\n", ntohs(sinp->sin_port)); } putchar('\n'); }
int main(int argc, char *argv[]) { struct addrinfo *ailist, *aip; struct addrinfo hint; struct sockaddr_in *sinp; const char *addr; int err; char abuf[INET_ADDRSTRLEN]; if (argc != 3) { err_quit("usage: %s nodename service", argv[0]); } hint.ai_flags = AI_CANONNAME; hint.ai_family = 0; hint.ai_socktype = 0; hint.ai_protocol = 0; hint.ai_addrlen = 0; hint.ai_canonname = NULL; hint.ai_addr = NULL; hint.ai_next = NULL; if ((err = getaddrinfo(argv[1], argv[2], &hint, &ailist)) != 0) { err_quit("getaddrinfo error: %s", gai_strerror(err)); } for (aip = ailist; aip != NULL; aip = aip->ai_next) { print_flags(aip); print_family(aip); print_type(aip); print_protocol(aip); printf("\n\thost %s", aip->ai_canonname ? aip->ai_canonname: "-"); if (aip->ai_family == AF_INET) { sinp = (struct sockaddr_in *)aip->ai_addr; addr = inet_ntop(AF_INET, &sinp->sin_addr, abuf, INET_ADDRSTRLEN); printf(" address %s", addr ? addr : "unknown"); printf(" port %d", ntohs(sinp->sin_port)); } printf("\n"); } exit(0); }
static void print_type_variable(const type_variable_t *type_variable) { if (type_variable->current_type != NULL) { print_type(type_variable->current_type); return; } fprintf(out, "%s:", type_variable->base.symbol->string); type_constraint_t *constraint = type_variable->constraints; int first = 1; while (constraint != NULL) { if (first) { first = 0; } else { fprintf(out, ", "); } fprintf(out, "%s", constraint->concept_symbol->string); constraint = constraint->next; } }
/* print_header Descr: Affiche à l'ecran la structure header initialisée par read_header Param: - header: Structure Ehdr correspondant au ELF header à afficher */ void print_header(Elf32_Ehdr header) { print_e_ident(header); // Magic print_class(header); // Class print_data(header); // Data print_version(header); // Version print_os_abi(header); // OS_ABI print_abi_version(header); // ABI version print_type(header); // Type print_machine(header); // Machine print_e_version(header); // Version print_entry(header); // Entry print_start_prog_headers(header); // Start of program headers print_start_section_headers(header); // Start of section headers print_flags(header); // Flags print_header_size(header); // Header size print_program_headers_size(header); // Program headers size print_program_headers_number(header); // Program headers number print_section_headers_size(header); // Section headers size print_section_headers_number(header); // Section headers number print_section_header_strtab_ndx(header); // Section header string table index }
/** * Print the second part (the postfix) of a type. * * @param type The type to print. */ static void print_function_type_post(const function_type_t *type, const scope_t *parameters) { print_char('('); separator_t sep = { "", ", " }; if (parameters == NULL) { function_parameter_t *parameter = type->parameters; for ( ; parameter != NULL; parameter = parameter->next) { print_string(sep_next(&sep)); print_type(parameter->type); } } else { for (entity_t const *parameter = parameters->first_entity; parameter != NULL; parameter = parameter->base.next) { if (parameter->kind != ENTITY_PARAMETER) continue; print_string(sep_next(&sep)); const type_t *const param_type = parameter->declaration.type; if (param_type == NULL) { print_string(parameter->base.symbol->string); } else { print_type_ext(param_type, parameter->base.symbol, NULL); } } } if (type->variadic) { print_string(sep_next(&sep)); print_string("..."); } if (sep_at_first(&sep) && !type->unspecified_parameters) { print_string("void"); } print_char(')'); print_modifiers(type->modifiers); intern_print_type_post(type->return_type); }
void print_and_free(node n, int depth){ if(toprint == 1){ for(int i = 0; i < depth; i++) printf(".."); if(n->value != NULL) printf("%s(%s)", n->label,n->value); else printf("%s", n->label); if(n->type_ != NULL){ printf(" - "); print_type(n->type_); } printf("\n"); } if(n && n->child != NULL){ print_and_free(n->child, depth + 1); } if(n && n->brother != NULL){ print_and_free(n->brother, depth); } free(n->label); free(n->value); free(n); }
static void test_enum_type(type_t tau) { uint32_t i, n; value_t x; assert(is_finite_type(&types, tau) && type_card_is_exact(&types, tau)); n = type_card(&types, tau); printf("==== Enumerating elements of type "); print_type(stdout, &types, tau); printf(" ====\n"); printf("cardinality: %"PRIu32"\n", n); for (i=0; i<n; i++) { x = vtbl_gen_object(&vtbl, tau, i); printf("elem[%"PRIu32"] = ", i); vtbl_print_object(stdout, &vtbl, x); printf("\n"); if (vtbl_queue_is_nonempty(&vtbl)) { vtbl_print_queued_functions(stdout, &vtbl, true); printf("\n"); } } printf("\n"); }
/* Print the list param: heap pointer to the list pre: the list is not empty post: The tasks from the list are printed out in priority order. The tasks are not removed from the list. */ void printList(DynArr *heap) { /* FIXME: Write this */ /* unable to effectively print in sorted order w/ tempArray, the following code is w/ help from tutor Dustin Castor */ assert(sizeDynArr(heap) > 0); /* sort and print in reverse in order that priority order is maintained */ sortHeap(heap); int i; int fin = sizeDynArr(heap)-1; /* last element */ for (i = fin; i >= 0; i--) { print_type(getDynArr(heap, i)); } /* rebuild to a heap from sorted array */ _buildHeap(heap); }
// recursive function which prints the formal args given a node of formal arg list void print_formal_args(nodeType* n) { if(n->opr.oper==EMPTY) // base case 1 return; nodeType* lc=get_operand(n,0); nodeType* rc=get_operand(n,1); nodeType* s; if(n->opr.oper==FORMAL_ARG) // base case when list degenerates to single arg { print_type(get_operand(n,1)); s=get_operand(n,0); debugger(" %s ",s->id.symrec->uid); // get the uid and print it fprintf(output," %s ",s->id.symrec->uid); return; } else // else recurse on the formal arg list of lc { print_formal_args(lc); debugger(","); fprintf(output,","); } print_formal_args(rc); // finally print the right child (actually just a formal arg) return; }
static void print_info(const struct iwinfo_ops *iw, const char *ifname) { printf("%-9s ESSID: %s\n", ifname, print_ssid(iw, ifname)); printf(" Access Point: %s\n", print_bssid(iw, ifname)); printf(" Mode: %s Channel: %s (%s)\n", print_mode(iw, ifname), print_channel(iw, ifname), print_frequency(iw, ifname)); printf(" Tx-Power: %s Link Quality: %s/%s\n", print_txpower(iw, ifname), print_quality(iw, ifname), print_quality_max(iw, ifname)); printf(" Signal: %s Noise: %s\n", print_signal(iw, ifname), print_noise(iw, ifname)); printf(" Bit Rate: %s\n", print_rate(iw, ifname)); printf(" Encryption: %s\n", print_encryption(iw, ifname)); printf(" Type: %s HW Mode(s): %s\n", print_type(iw, ifname), print_hwmodes(iw, ifname)); printf(" Hardware: %s [%s]\n", print_hardware_id(iw, ifname), print_hardware_name(iw, ifname)); printf(" TX power offset: %s\n", print_txpower_offset(iw, ifname)); printf(" Frequency offset: %s\n", print_frequency_offset(iw, ifname)); printf(" Supports VAPs: %s PHY name: %s\n", print_mbssid_supp(iw, ifname), print_phyname(iw, ifname)); }
void print_image_hdr(image_header_t *hdr){ #if (CONFIG_COMMANDS & CFG_CMD_DATE) || defined(CONFIG_TIMESTAMP) time_t timestamp = (time_t)ntohl(hdr->ih_time); struct rtc_time tm; #endif printf("\n Image name: %.*s\n", IH_NMLEN, hdr->ih_name); #if (CONFIG_COMMANDS & CFG_CMD_DATE) || defined(CONFIG_TIMESTAMP) to_tm(timestamp, &tm); printf(" Created: %4d-%02d-%02d %2d:%02d:%02d UTC\n", tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); #endif /* CFG_CMD_DATE, CONFIG_TIMESTAMP */ puts(" Image type: "); print_type(hdr); printf("\n Data size: %d Bytes = ", ntohl(hdr->ih_size)); print_size(ntohl(hdr->ih_size), "\n"); printf(" Load address: 0x%08X\n Entry point: 0x%08X\n", ntohl(hdr->ih_load), ntohl(hdr->ih_ep)); if(hdr->ih_type == IH_TYPE_MULTI){ int i; ulong len; ulong *len_ptr = (ulong *)((ulong)hdr + sizeof(image_header_t)); puts(" Contents:\n"); for(i = 0; (len = ntohl(*len_ptr)); ++i, ++len_ptr){ printf(" Image %d: %8ld Bytes = ", i, len); print_size(len, "\n"); } } puts("\n"); }
static pyyerror (YP yp, ...) { char buffer[BUFSIZ]; va_start (ap, yp); _asprintf (buffer, NULLCP, yp, ap); va_end (ap); yyerror_aux (buffer); print_type (yp, 0); if (*sysout) unlink (sysout); if (*sysdef) unlink (sysdef); if (*systbl) unlink (systbl); if (*systub) unlink (systub); exit (1); }
int main(int argc, const char * argv[]) { Task *task1, *task2, *task3, *task4, *task5, *task6, *task7, *task8, *task9, *task10; Task *task11, *task12, *task13, *task14, *task15, *task16, *task17, *task18, *task19, *task20; DynArr *mainList; int i; mainList = createDynArr(10); /* create tasks */ task1 = createTask(9, "task 1"); task2 = createTask(3, "task 2"); task3 = createTask(2, "task 3"); task4 = createTask(4, "task 4"); task5 = createTask(5, "task 5"); task6 = createTask(7, "task 6"); task7 = createTask(8, "task 7"); task8 = createTask(6, "task 8"); task9 = createTask(1, "task 9"); task10 = createTask(10, "task 10"); task11 = createTask(19, "task 11"); task12 = createTask(13, "task 12"); task13 = createTask(12, "task 13"); task14 = createTask(14, "task 14"); task15 = createTask(15, "task 15"); task16 = createTask(17, "task 16"); task17 = createTask(18, "task 17"); task18 = createTask(16, "task 18"); task19 = createTask(3, "task 19"); task20 = createTask(110, "task 20"); /* add tasks to the dynamic array */ addHeap(mainList, task1); addHeap(mainList, task2); addHeap(mainList, task3); addHeap(mainList, task4); addHeap(mainList, task5); addHeap(mainList, task6); addHeap(mainList, task7); addHeap(mainList, task8); addHeap(mainList, task9); addHeap(mainList, task10); addHeap(mainList, task11); addHeap(mainList, task12); addHeap(mainList, task13); addHeap(mainList, task14); addHeap(mainList, task15); addHeap(mainList, task16); addHeap(mainList, task17); addHeap(mainList, task18); addHeap(mainList, task19); addHeap(mainList, task20); #ifdef TESTHEAP printf("Print heap\n"); for(i = 0; i < sizeDynArr(mainList);i++) print_type(getDynArr(mainList,i)); while(!isEmptyDynArr(mainList)) { TYPE v; v = getMinHeap(mainList); printf("Removing: "); print_type(v); removeMinHeap(mainList); for(i = 0; i < sizeDynArr(mainList);i++) print_type(getDynArr(mainList,i)); } #endif #ifdef TESTSORT printf("Before Sort Called \n"); for(i = 0; i < sizeDynArr(mainList);i++) printf("DynArr[%d] = %d\n", i, ((Task*)getDynArr(mainList,i))->priority); /* sort tasks */ sortHeap(mainList); printf("After Sort Called \n"); /* print sorted tasks from the dynamic array */ for(i = 0; i < sizeDynArr(mainList);i++) printf("DynArr[%d] = %d\n", i, ((Task*)getDynArr(mainList,i))->priority); return 0; #endif }
/* * Print definitions of all terms */ void print_egraph_terms(FILE *f, egraph_t *egraph) { composite_t *c; uint32_t i, n; thvar_t x; n = egraph->terms.nterms; for (i=0; i<n; i++) { print_eterm_id(f, i); c = egraph_term_body(egraph, i); if (constant_body(c)) { fputs(" (constant) ", f); } else if (c == VARIABLE_BODY) { fputs(" (variable) ", f); } else if (c == NULL) { fputs(" (deleted) ", f); } else { fputs(" := ", f); print_composite(f, c); } fputs("\t\t", f); print_type(f, egraph->types, egraph_term_real_type(egraph, i)); // fputs("\t\tetype = ", f); // print_etype(f, egraph_class_type(egraph, i)); x = egraph_term_base_thvar(egraph, i); if (x != null_thvar) { fputs("\t\t", f); switch(egraph_term_type(egraph, i)) { case ETYPE_INT: fprintf(f, "arith(i!%"PRId32")\t\t", x); break; case ETYPE_REAL: fprintf(f, "arith(z!%"PRId32")\t\t", x); break; case ETYPE_BV: fprintf(f, "bv(u!%"PRId32")\t\t", x); break; case ETYPE_FUNCTION: fprintf(f, "fun(f!%"PRId32")", x); break; case ETYPE_BOOL: fprintf(f, "lit(p!%"PRId32")\t\t", x); print_bval(f, bvar_value(egraph->core, x)); break; case ETYPE_TUPLE: fprintf(f, "tup(g!%"PRId32")", x); break; default: fprintf(f, "BADTHVAR(%"PRId32")", x); break; } } else { if (egraph_term_is_true(egraph, i)) { fputs("\t\t(true term)", f); } else if (egraph_term_is_false(egraph, i)) { fputs("\t\t(false term)", f); } } fputc('\n', f); } }
/* * This is the main dispatch function * */ struct MethodDefinition* method_dispatch_on(struct object_heap* oh, struct Symbol* name, struct Object* arguments[], word_t arity, struct Object* resendMethod) { struct MethodDefinition *dispatch, *bestDef; struct Object* slotLocation; word_t bestRank, depth, delegationCount, resendRank, restricted, i; #ifdef PRINT_DEBUG_DISPATCH fprintf(stderr, "dispatch to: '"); print_symbol(name); fprintf(stderr, "' (arity: %" PRIdPTR ")\n", arity); for (i = 0; i < arity; i++) { fprintf(stderr, "arguments[%" PRIdPTR "] (%p) = ", i, (void*)arguments[i]); print_type(oh, arguments[i]); } /* fprintf(stderr, "resend: "); print_object(resendMethod);*/ #endif dispatch = NULL; slotLocation = NULL; #ifndef SLATE_DISABLE_METHOD_CACHE if (resendMethod == NULL && arity <= METHOD_CACHE_ARITY) { dispatch = method_check_cache(oh, name, arguments, arity); if (dispatch != NULL) return dispatch; } #endif oh->current_dispatch_id++; bestRank = 0; bestDef = NULL; resendRank = ((resendMethod == NULL) ? WORDT_MAX : 0); for (i = 0; i < arity; i++) { struct Object *obj; struct Map* map; struct Object* arg = arguments[i]; delegationCount = 0; depth = 0; restricted = WORDT_MAX; /*pointer in delegate_stack (with sp of delegateCount) to where we don't trace further*/ do { /* Set up obj to be a pointer to the object, or SmallInteger if it's a direct SmallInt. */ if (object_is_smallint(arg)) { obj = get_special(oh, SPECIAL_OOP_SMALL_INT_PROTO); } else { obj = arg; } /* Identify the map, and update its dispatchID and reset the visited mask if it hasn't been visited during this call already. */ map = obj->map; if (map->dispatchID != oh->current_dispatch_id) { map->dispatchID = oh->current_dispatch_id; map->visitedPositions = 0; } /* we haven't been here before */ if ((map->visitedPositions & (1 << i)) == 0) { struct RoleEntry* role; /* If the map marks an obj-meta transition and the top of the stack is not the original argument, then mark the restriction point at the top of the delegation stack. */ if (((word_t)map->flags & MAP_FLAG_RESTRICT_DELEGATION) && (arg != arguments[i])) { restricted = delegationCount; } map->visitedPositions |= (1 << i); role = role_table_entry_for_name(oh, map->roleTable, name); while (role != NULL) { if ((object_to_smallint(role->rolePositions) & (1 << i)) != 0) { struct MethodDefinition* def = role->methodDefinition; /* If the method hasn't been visited this time, mark it so and clear the other dispatch marks.*/ if (def->dispatchID != oh->current_dispatch_id) { def->dispatchID = oh->current_dispatch_id; def->foundPositions = 0; def->dispatchRank = 0; } /*If the method hasn't been found at this position...*/ if ((def->foundPositions & (1 << i)) == 0) { /*fix*/ def->dispatchRank |= ((31 - depth) << ((5 - i) * 5)); def->foundPositions |= (1 << i); #ifdef PRINT_DEBUG_FOUND_ROLE fprintf(stderr, "found role index %" PRIdPTR " <%p> for '%s' foundPos: %" PRIuPTR "x dispatchPos: %" PRIuPTR "x\n", i, (void*) role, ((struct Symbol*)(role->name))->elements, def->foundPositions, def->dispatchPositions); #endif if (def->method == resendMethod) { struct RoleEntry* rescan = role_table_entry_for_name(oh, map->roleTable, name); resendRank = def->dispatchRank; while (rescan != role) { struct MethodDefinition* redef = rescan->methodDefinition; if (redef->foundPositions == redef->dispatchPositions && (dispatch == NULL || redef->dispatchRank <= resendRank)) { dispatch = redef; slotLocation = obj; if (redef->dispatchRank > bestRank) { bestRank = redef->dispatchRank; bestDef = redef; } } if (rescan->nextRole == oh->cached.nil) { rescan = NULL; } else { rescan = &map->roleTable->roles[object_to_smallint(rescan->nextRole)]; } } } else /*not a resend*/ { if (def->foundPositions == def->dispatchPositions && (dispatch == NULL || def->dispatchRank > dispatch->dispatchRank) && def->dispatchRank <= resendRank) { dispatch = def; slotLocation = obj; if (def->dispatchRank > bestRank) { bestRank = def->dispatchRank; bestDef = def; } } } if (def->dispatchRank >= bestRank && def != bestDef) { bestRank = def->dispatchRank; bestDef = NULL; } } } role = ((role->nextRole == oh->cached.nil) ? NULL : &map->roleTable->roles[object_to_smallint(role->nextRole)]); } /*while role != NULL*/ if (depth > 31) { /*fix wordsize*/ assert(0); } if (dispatch != NULL && bestDef == dispatch) { if (dispatch->slotAccessor != oh->cached.nil) { arguments[0] = slotLocation; /*do we need to try to do a heap_store_into?*/ #ifdef PRINT_DEBUG_DISPATCH_SLOT_CHANGES fprintf(stderr, "arguments[0] changed to slot location: \n"); print_detail(oh, arguments[0]); #endif } if (resendMethod == 0 && arity <= METHOD_CACHE_ARITY) method_save_cache(oh, dispatch, name, arguments, arity); return dispatch; } depth++; /* We add the delegates to the list when we didn't just finish checking a restricted object*/ if (delegationCount <= restricted && array_size(map->delegates) > 0) { struct OopArray* delegates = map->delegates; word_t offset = object_array_offset((struct Object*)delegates); word_t limit = object_total_size((struct Object*)delegates); for (; offset != limit; offset += sizeof(word_t)) { struct Object* delegate = object_slot_value_at_offset((struct Object*)delegates, offset); if (delegate != oh->cached.nil) { oh->delegation_stack[delegationCount++] = delegate; } } } } /*end haven't been here before*/ delegationCount--; if (delegationCount < restricted) restricted = WORDT_MAX; /*everything is unrestricted now*/ if (delegationCount < 0 || delegationCount >= DELEGATION_STACK_SIZE) break; arg = oh->delegation_stack[delegationCount]; } while (1); } if (dispatch != NULL && dispatch->slotAccessor != oh->cached.nil) { /*check heap store into?*/ arguments[0] = slotLocation; #ifdef PRINT_DEBUG_DISPATCH_SLOT_CHANGES fprintf(stderr, "arguments[0] changed to slot location: \n"); print_detail(oh, arguments[0]); #endif } #ifndef SLATE_DISABLE_METHOD_CACHE if (dispatch != NULL && resendMethod == 0 && arity < METHOD_CACHE_ARITY) { method_save_cache(oh, dispatch, name, arguments, arity); } #endif return dispatch; }
wiced_result_t wiced_bt_smart_attribute_print( const wiced_bt_smart_attribute_t* attribute ) { wiced_bt_smart_attribute_t* curr_attr = (wiced_bt_smart_attribute_t*)attribute; if ( attribute == NULL ) { return WICED_BT_BADARG; } WPRINT_LIB_INFO( ( "----------------------------------------------------\n" ) ); print_type( &curr_attr->type ); WPRINT_LIB_INFO( ( "\n" ) ); WPRINT_LIB_INFO( ( "Handle : %d\n", (int)curr_attr->handle ) ); WPRINT_LIB_INFO( ( "Type : " ) ); print_uuid( &curr_attr->type ); WPRINT_LIB_INFO( ( "Permission : %d\n", (int)curr_attr->permission ) ); WPRINT_LIB_INFO( ( "Value Length : %d\n", (int)curr_attr->value_length ) ); if ( curr_attr->type.size == UUID_16BIT ) { switch ( curr_attr->type.value.value_16_bit ) { case 0x2800: { WPRINT_LIB_INFO( ( "Start Handle : %d\n", (int)curr_attr->value.service.start_handle ) ); WPRINT_LIB_INFO( ( "End Handle : %d\n", (int)curr_attr->value.service.end_handle ) ); WPRINT_LIB_INFO( ( "Service UUID : ") ); print_uuid( &curr_attr->value.service.uuid ); break; } case 0x2802: { WPRINT_LIB_INFO( ( "Start Handle : %d\n", (int)curr_attr->value.include.included_service_handle ) ); WPRINT_LIB_INFO( ( "End Handle : %d\n", (int)curr_attr->value.include.end_group_handle ) ); WPRINT_LIB_INFO( ( "Service UUID : ") ); print_uuid( &curr_attr->value.include.uuid ); break; } case 0x2803: { WPRINT_LIB_INFO( ( "Properties : %d\n", (int)curr_attr->value.characteristic.properties ) ); WPRINT_LIB_INFO( ( "Value Handle : %d\n", (int)curr_attr->value.characteristic.value_handle ) ); WPRINT_LIB_INFO( ( "Value UUID : ") ); print_uuid( &curr_attr->value.characteristic.uuid ); break; } case 0x2900: { WPRINT_LIB_INFO( ( "Extended Properties : %d\n", (int)curr_attr->value.extended_properties.properties ) ); break; } case 0x2901: { WPRINT_LIB_INFO( ( "Extended Properties : %s\n", curr_attr->value.user_description.string ) ); break; } case 0x2902: { WPRINT_LIB_INFO( ( "Client Configuration : %d\n", (int)curr_attr->value.client_config.config_bits ) ); break; } case 0x2903: { WPRINT_LIB_INFO( ( "Server Configuration : %d\n", (int)curr_attr->value.server_config.config_bits ) ); break; } case 0x2904: { WPRINT_LIB_INFO( ( "Format : %d\n", (int)curr_attr->value.presentation_format.format ) ); WPRINT_LIB_INFO( ( "Exponent : %d\n", (int)curr_attr->value.presentation_format.exponent ) ); WPRINT_LIB_INFO( ( "Unit : %d\n", (int)curr_attr->value.presentation_format.unit ) ); WPRINT_LIB_INFO( ( "Namespace : %d\n", (int)curr_attr->value.presentation_format.name_space ) ); WPRINT_LIB_INFO( ( "Description : %d\n", (int)curr_attr->value.presentation_format.description ) ); break; } case 0x2905: { uint32_t i; WPRINT_LIB_INFO( ( "List of Handles : \n" ) ); for ( i = 0; i < curr_attr->value_length / 2; i ++ ) { WPRINT_LIB_INFO( ( "%02d ", (int)curr_attr->value.aggregate_format.handle_list[i] ) ); } WPRINT_LIB_INFO( ( "\n" ) ); break; } case 0x2A00: { WPRINT_LIB_INFO( ( "Device Name : %s\n", curr_attr->value.device_name.device_name ) ); break; } case 0x2A01: { WPRINT_LIB_INFO( ( "Appearance : %d\n", (int)curr_attr->value.appearance.appearance ) ); break; } case 0x2A02: { WPRINT_LIB_INFO( ( "Peripheral Privacy Flag : %d\n", (int)curr_attr->value.periph_privacy_flag.periph_privacy_flag ) ); break; } case 0x2A03: { WPRINT_LIB_INFO( ( "Reconnection Address : %02x:%02x:%02x:%02x:%02x:%02x\n", (int)curr_attr->value.reconn_address.reconn_address[0], (int)curr_attr->value.reconn_address.reconn_address[1], (int)curr_attr->value.reconn_address.reconn_address[2], (int)curr_attr->value.reconn_address.reconn_address[3], (int)curr_attr->value.reconn_address.reconn_address[4], (int)curr_attr->value.reconn_address.reconn_address[5] ) ); break; } case 0x2A04: { WPRINT_LIB_INFO( ( "Max Connection Interval : %d\n", (int)curr_attr->value.periph_preferred_conn_params.max_conn_interval ) ); WPRINT_LIB_INFO( ( "Min Connection Interval : %d\n", (int)curr_attr->value.periph_preferred_conn_params.min_conn_interval ) ); WPRINT_LIB_INFO( ( "Slave Latency : %d\n", (int)curr_attr->value.periph_preferred_conn_params.slave_latency ) ); WPRINT_LIB_INFO( ( "Supervision Timeout Multiplier : %d\n", (int)curr_attr->value.periph_preferred_conn_params.conn_supervision_timeout_multiplier ) ); break; } default: { uint32_t i; WPRINT_LIB_INFO( ( "Value : \n" ) ); for ( i = 0; i < curr_attr->value_length; i ++ ) { WPRINT_LIB_INFO( ( "%02x ", (int)curr_attr->value.value[i] ) ); } WPRINT_LIB_INFO( ( "\n" ) ); break; } } } WPRINT_LIB_INFO( ( "----------------------------------------------------\n" ) ); return WICED_BT_SUCCESS; }
void print_PseudoAction( PseudoAction *o ) { PseudoActionEffect *e; int i, m; printf("\n\n----------------Pseudo Action %s--------------\n", o->operator->name); for ( i = 0; i < o->operator->num_vars; i++ ) { printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); print_type( o->operator->var_types[i] ); } printf("\nPreconds:\n"); for ( i = 0; i < o->num_preconds; i++ ) { print_Fact( &(o->preconds[i]) ); printf("\n"); } for ( i = 0; i < o->num_numeric_preconds; i++ ) { switch ( o->numeric_preconds_comp[i] ) { case LE: printf("(< "); break; case LEQ: printf("(<= "); break; case EQ: printf("(= "); break; case GEQ: printf("(>= "); break; case GE: printf("(> "); break; default: printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", o->numeric_preconds_comp[i]); exit( 1 ); } print_ExpNode( o->numeric_preconds_lh[i] ); print_ExpNode( o->numeric_preconds_rh[i] ); printf(")\n"); } m = 0; printf("\n\nEffects:"); for ( e = o->effects; e; e = e->next ) { printf("\n\neffect %d", m++); printf("\n\nConditions\n"); for ( i = 0; i < e->num_conditions; i++ ) { print_Fact( &(e->conditions[i]) ); printf("\n"); } for ( i = 0; i < e->num_numeric_conditions; i++ ) { switch ( e->numeric_conditions_comp[i] ) { case LE: printf("(< "); break; case LEQ: printf("(<= "); break; case EQ: printf("(= "); break; case GEQ: printf("(>= "); break; case GE: printf("(> "); break; default: printf("\nwrong comparator of Expnodes in normeff %d\n\n", e->numeric_conditions_comp[i]); exit( 1 ); } print_ExpNode( e->numeric_conditions_lh[i] ); print_ExpNode( e->numeric_conditions_rh[i] ); printf(")\n"); } printf("\nAdds\n"); for ( i = 0; i < e->num_adds; i++ ) { print_Fact( &(e->adds[i]) ); printf("\n"); } printf("\nDels\n"); for ( i = 0; i < e->num_dels; i++ ) { print_Fact( &(e->dels[i]) ); printf("\n"); } for ( i = 0; i < e->num_numeric_effects; i++ ) { switch ( e->numeric_effects_neft[i] ) { case ASSIGN: printf("\nassign "); break; case SCALE_UP: printf("\nscale-up "); break; case SCALE_DOWN: printf("\nscale-down "); break; case INCREASE: printf("\nincrease "); break; case DECREASE: printf("\ndecrease "); break; default: printf("\n\nprint normop: illegal neft %d\n\n", e->numeric_effects_neft[i]); exit( 1 ); } print_Fluent( &(e->numeric_effects_fluent[i]) ); print_ExpNode( e->numeric_effects_rh[i] ); } } }
static void print_sizeof_expression(const sizeof_expression_t *expr) { fprintf(out, "(sizeof<"); print_type(expr->type); fprintf(out, ">)"); }
void slang_print_tree(const slang_operation *op, int indent) { GLuint i; switch (op->type) { case SLANG_OPER_NONE: spaces(indent); printf("SLANG_OPER_NONE\n"); break; case SLANG_OPER_BLOCK_NO_NEW_SCOPE: spaces(indent); printf("{ locals=%p outer=%p\n", (void*)op->locals, (void*)op->locals->outer_scope); print_generic(op, NULL, indent+3); spaces(indent); printf("}\n"); break; case SLANG_OPER_BLOCK_NEW_SCOPE: spaces(indent); printf("{{ // new scope locals=%p outer=%p: ", (void *) op->locals, (void *) op->locals->outer_scope); for (i = 0; i < op->locals->num_variables; i++) { printf("%s ", (char *) op->locals->variables[i]->a_name); } printf("\n"); print_generic(op, NULL, indent+3); spaces(indent); printf("}}\n"); break; case SLANG_OPER_VARIABLE_DECL: assert(op->num_children == 0 || op->num_children == 1); { slang_variable *v; v = _slang_variable_locate(op->locals, op->a_id, GL_TRUE); if (v) { const slang_variable_scope *scope; spaces(indent); printf("DECL (locals=%p outer=%p) ", (void*)op->locals, (void*) op->locals->outer_scope); print_type(&v->type); printf(" %s (%p)", (char *) op->a_id, (void *) find_var(op->locals, op->a_id)); scope = find_scope(op->locals, op->a_id); printf(" (in scope %p) ", (void *) scope); assert(scope); if (op->num_children == 1) { printf(" :=\n"); slang_print_tree(&op->children[0], indent + 3); } else if (v->initializer) { printf(" := INITIALIZER\n"); slang_print_tree(v->initializer, indent + 3); } else { printf(";\n"); } /* spaces(indent); printf("TYPE: "); print_type(&v->type); spaces(indent); printf("ADDR: %d size: %d\n", v->address, v->size); */ } else { spaces(indent); printf("DECL %s (anonymous variable!!!!)\n", (char *) op->a_id); } } break; case SLANG_OPER_ASM: spaces(indent); printf("ASM: %s at %p locals=%p outer=%p\n", (char *) op->a_id, (void *) op, (void *) op->locals, (void *) op->locals->outer_scope); print_generic(op, "ASM", indent+3); break; case SLANG_OPER_BREAK: spaces(indent); printf("BREAK\n"); break; case SLANG_OPER_CONTINUE: spaces(indent); printf("CONTINUE\n"); break; case SLANG_OPER_DISCARD: spaces(indent); printf("DISCARD\n"); break; case SLANG_OPER_RETURN: spaces(indent); printf("RETURN\n"); if (op->num_children > 0) slang_print_tree(&op->children[0], indent + 3); break; case SLANG_OPER_LABEL: spaces(indent); printf("LABEL %s\n", (char *) op->a_id); break; case SLANG_OPER_EXPRESSION: spaces(indent); printf("EXPR: locals=%p outer=%p\n", (void *) op->locals, (void *) op->locals->outer_scope); /*print_generic(op, "SLANG_OPER_EXPRESSION", indent);*/ slang_print_tree(&op->children[0], indent + 3); break; case SLANG_OPER_IF: spaces(indent); printf("IF\n"); slang_print_tree(&op->children[0], indent + 3); spaces(indent); printf("THEN\n"); slang_print_tree(&op->children[1], indent + 3); spaces(indent); printf("ELSE\n"); slang_print_tree(&op->children[2], indent + 3); spaces(indent); printf("ENDIF\n"); break; case SLANG_OPER_WHILE: assert(op->num_children == 2); spaces(indent); printf("WHILE LOOP: locals = %p\n", (void *) op->locals); indent += 3; spaces(indent); printf("WHILE cond:\n"); slang_print_tree(&op->children[0], indent + 3); spaces(indent); printf("WHILE body:\n"); slang_print_tree(&op->children[1], indent + 3); indent -= 3; spaces(indent); printf("END WHILE LOOP\n"); break; case SLANG_OPER_DO: spaces(indent); printf("DO LOOP: locals = %p\n", (void *) op->locals); indent += 3; spaces(indent); printf("DO body:\n"); slang_print_tree(&op->children[0], indent + 3); spaces(indent); printf("DO cond:\n"); slang_print_tree(&op->children[1], indent + 3); indent -= 3; spaces(indent); printf("END DO LOOP\n"); break; case SLANG_OPER_FOR: spaces(indent); printf("FOR LOOP: locals = %p\n", (void *) op->locals); indent += 3; spaces(indent); printf("FOR init:\n"); slang_print_tree(&op->children[0], indent + 3); spaces(indent); printf("FOR condition:\n"); slang_print_tree(&op->children[1], indent + 3); spaces(indent); printf("FOR step:\n"); slang_print_tree(&op->children[2], indent + 3); spaces(indent); printf("FOR body:\n"); slang_print_tree(&op->children[3], indent + 3); indent -= 3; spaces(indent); printf("ENDFOR\n"); /* print_generic(op, "FOR", indent + 3); */ break; case SLANG_OPER_VOID: spaces(indent); printf("(oper-void)\n"); break; case SLANG_OPER_LITERAL_BOOL: spaces(indent); printf("LITERAL ("); for (i = 0; i < op->literal_size; i++) printf("%s ", op->literal[0] ? "TRUE" : "FALSE"); printf(")\n"); break; case SLANG_OPER_LITERAL_INT: spaces(indent); printf("LITERAL ("); for (i = 0; i < op->literal_size; i++) printf("%d ", (int) op->literal[i]); printf(")\n"); break; case SLANG_OPER_LITERAL_FLOAT: spaces(indent); printf("LITERAL ("); for (i = 0; i < op->literal_size; i++) printf("%f ", op->literal[i]); printf(")\n"); break; case SLANG_OPER_IDENTIFIER: { const slang_variable_scope *scope; spaces(indent); if (op->var && op->var->a_name) { scope = find_scope(op->locals, op->var->a_name); printf("VAR %s (in scope %p)\n", (char *) op->var->a_name, (void *) scope); assert(scope); } else { scope = find_scope(op->locals, op->a_id); printf("VAR' %s (in scope %p) locals=%p outer=%p\n", (char *) op->a_id, (void *) scope, (void *) op->locals, (void *) op->locals->outer_scope); assert(scope); } } break; case SLANG_OPER_SEQUENCE: print_generic(op, "COMMA-SEQ", indent+3); break; case SLANG_OPER_ASSIGN: spaces(indent); printf("ASSIGNMENT locals=%p outer=%p\n", (void *) op->locals, (void *) op->locals->outer_scope); print_binary(op, ":=", indent); break; case SLANG_OPER_ADDASSIGN: spaces(indent); printf("ASSIGN\n"); print_binary(op, "+=", indent); break; case SLANG_OPER_SUBASSIGN: spaces(indent); printf("ASSIGN\n"); print_binary(op, "-=", indent); break; case SLANG_OPER_MULASSIGN: spaces(indent); printf("ASSIGN\n"); print_binary(op, "*=", indent); break; case SLANG_OPER_DIVASSIGN: spaces(indent); printf("ASSIGN\n"); print_binary(op, "/=", indent); break; /*SLANG_OPER_MODASSIGN,*/ /*SLANG_OPER_LSHASSIGN,*/ /*SLANG_OPER_RSHASSIGN,*/ /*SLANG_OPER_ORASSIGN,*/ /*SLANG_OPER_XORASSIGN,*/ /*SLANG_OPER_ANDASSIGN,*/ case SLANG_OPER_SELECT: spaces(indent); printf("SLANG_OPER_SELECT n=%d\n", op->num_children); assert(op->num_children == 3); slang_print_tree(&op->children[0], indent+3); spaces(indent); printf("?\n"); slang_print_tree(&op->children[1], indent+3); spaces(indent); printf(":\n"); slang_print_tree(&op->children[2], indent+3); break; case SLANG_OPER_LOGICALOR: print_binary(op, "||", indent); break; case SLANG_OPER_LOGICALXOR: print_binary(op, "^^", indent); break; case SLANG_OPER_LOGICALAND: print_binary(op, "&&", indent); break; /*SLANG_OPER_BITOR*/ /*SLANG_OPER_BITXOR*/ /*SLANG_OPER_BITAND*/ case SLANG_OPER_EQUAL: print_binary(op, "==", indent); break; case SLANG_OPER_NOTEQUAL: print_binary(op, "!=", indent); break; case SLANG_OPER_LESS: print_binary(op, "<", indent); break; case SLANG_OPER_GREATER: print_binary(op, ">", indent); break; case SLANG_OPER_LESSEQUAL: print_binary(op, "<=", indent); break; case SLANG_OPER_GREATEREQUAL: print_binary(op, ">=", indent); break; /*SLANG_OPER_LSHIFT*/ /*SLANG_OPER_RSHIFT*/ case SLANG_OPER_ADD: print_binary(op, "+", indent); break; case SLANG_OPER_SUBTRACT: print_binary(op, "-", indent); break; case SLANG_OPER_MULTIPLY: print_binary(op, "*", indent); break; case SLANG_OPER_DIVIDE: print_binary(op, "/", indent); break; /*SLANG_OPER_MODULUS*/ case SLANG_OPER_PREINCREMENT: spaces(indent); printf("PRE++\n"); slang_print_tree(&op->children[0], indent+3); break; case SLANG_OPER_PREDECREMENT: spaces(indent); printf("PRE--\n"); slang_print_tree(&op->children[0], indent+3); break; case SLANG_OPER_PLUS: spaces(indent); printf("SLANG_OPER_PLUS\n"); break; case SLANG_OPER_MINUS: spaces(indent); printf("SLANG_OPER_MINUS\n"); break; /*SLANG_OPER_COMPLEMENT*/ case SLANG_OPER_NOT: spaces(indent); printf("NOT\n"); slang_print_tree(&op->children[0], indent+3); break; case SLANG_OPER_SUBSCRIPT: spaces(indent); printf("SLANG_OPER_SUBSCRIPT locals=%p outer=%p\n", (void *) op->locals, (void *) op->locals->outer_scope); print_generic(op, NULL, indent+3); break; case SLANG_OPER_CALL: #if 0 slang_function *fun = _slang_function_locate(A->space.funcs, oper->a_id, oper->children, oper->num_children, &A->space, A->atoms); #endif spaces(indent); printf("CALL %s(\n", (char *) op->a_id); for (i = 0; i < op->num_children; i++) { slang_print_tree(&op->children[i], indent+3); if (i + 1 < op->num_children) { spaces(indent + 3); printf(",\n"); } } spaces(indent); printf(")\n"); break; case SLANG_OPER_METHOD: spaces(indent); printf("METHOD CALL %s.%s\n", (char *) op->a_obj, (char *) op->a_id); break; case SLANG_OPER_FIELD: spaces(indent); printf("FIELD %s of\n", (char*) op->a_id); slang_print_tree(&op->children[0], indent+3); break; case SLANG_OPER_POSTINCREMENT: spaces(indent); printf("POST++\n"); slang_print_tree(&op->children[0], indent+3); break; case SLANG_OPER_POSTDECREMENT: spaces(indent); printf("POST--\n"); slang_print_tree(&op->children[0], indent+3); break; default: printf("unknown op->type %d\n", (int) op->type); } }
// Pretty print a logical type. void print_type(std::ostream& os, const type& t) { assert(t.get_kind() == bool_type_kind); print_type(os, cast<bool_type>(t)); }
static void print_type(printbuf_t* buffer, ast_t* type) { switch(ast_id(type)) { case TK_NOMINAL: { AST_GET_CHILDREN(type, package, id, typeargs, cap, ephemeral); ast_t* origpkg = ast_sibling(ephemeral); if(origpkg != NULL && ast_id(origpkg) != TK_NONE) printbuf(buffer, "%s.", ast_name(origpkg)); ast_t* def = (ast_t*)ast_data(type); if(def != NULL) id = ast_child(def); printbuf(buffer, "%s", ast_nice_name(id)); if(ast_id(typeargs) != TK_NONE) print_typeexpr(buffer, typeargs, ", ", true); if(ast_id(cap) != TK_NONE) printbuf(buffer, " %s", token_print(cap->t)); if(ast_id(ephemeral) != TK_NONE) printbuf(buffer, "%s", token_print(ephemeral->t)); break; } case TK_UNIONTYPE: print_typeexpr(buffer, type, " | ", false); break; case TK_ISECTTYPE: print_typeexpr(buffer, type, " & ", false); break; case TK_TUPLETYPE: print_typeexpr(buffer, type, ", ", false); break; case TK_TYPEPARAMREF: { AST_GET_CHILDREN(type, id, cap, ephemeral); printbuf(buffer, "%s", ast_nice_name(id)); if(ast_id(cap) != TK_NONE) printbuf(buffer, " %s", token_print(cap->t)); if(ast_id(ephemeral) != TK_NONE) printbuf(buffer, " %s", token_print(ephemeral->t)); break; } case TK_ARROW: { AST_GET_CHILDREN(type, left, right); print_type(buffer, left); printbuf(buffer, "->"); print_type(buffer, right); break; } case TK_THISTYPE: printbuf(buffer, "this"); break; case TK_DONTCARE: printbuf(buffer, "_"); break; case TK_FUNTYPE: printbuf(buffer, "function"); break; case TK_INFERTYPE: printbuf(buffer, "to_infer"); break; case TK_ERRORTYPE: printbuf(buffer, "<type error>"); break; case TK_NONE: break; default: printbuf(buffer, "%s", token_print(type->t)); } }
static void print_pointer_type(const pointer_type_t *type) { print_type(type->points_to); fputs("*", out); }
static int res_qp_parse_cb(const struct nlmsghdr *nlh, void *data) { struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {}; struct nlattr *nla_table, *nla_entry; struct rd *rd = data; const char *name; uint32_t idx; mnl_attr_parse(nlh, 0, rd_attr_cb, tb); if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_DEV_NAME] || !tb[RDMA_NLDEV_ATTR_RES_QP]) return MNL_CB_ERROR; name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]); idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); nla_table = tb[RDMA_NLDEV_ATTR_RES_QP]; mnl_attr_for_each_nested(nla_entry, nla_table) { struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {}; uint32_t lqpn, rqpn = 0, rq_psn = 0, sq_psn; uint8_t type, state, path_mig_state = 0; uint32_t port = 0, pid = 0; char *comm = NULL; int err; err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line); if (err != MNL_CB_OK) return MNL_CB_ERROR; if (!nla_line[RDMA_NLDEV_ATTR_RES_LQPN] || !nla_line[RDMA_NLDEV_ATTR_RES_SQ_PSN] || !nla_line[RDMA_NLDEV_ATTR_RES_TYPE] || !nla_line[RDMA_NLDEV_ATTR_RES_STATE] || (!nla_line[RDMA_NLDEV_ATTR_RES_PID] && !nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])) { return MNL_CB_ERROR; } if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX]) port = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_PORT_INDEX]); if (port != rd->port_idx) continue; lqpn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_LQPN]); if (rd_check_is_filtered(rd, "lqpn", lqpn)) continue; if (nla_line[RDMA_NLDEV_ATTR_RES_RQPN]) { rqpn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_RQPN]); if (rd_check_is_filtered(rd, "rqpn", rqpn)) continue; } else { if (rd_check_is_key_exist(rd, "rqpn")) continue; } if (nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN]) { rq_psn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN]); if (rd_check_is_filtered(rd, "rq-psn", rq_psn)) continue; } else { if (rd_check_is_key_exist(rd, "rq-psn")) continue; } sq_psn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_SQ_PSN]); if (rd_check_is_filtered(rd, "sq-psn", sq_psn)) continue; if (nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]) { path_mig_state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]); if (rd_check_is_string_filtered(rd, "path-mig-state", path_mig_to_str(path_mig_state))) continue; } else { if (rd_check_is_key_exist(rd, "path-mig-state")) continue; } type = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_TYPE]); if (rd_check_is_string_filtered(rd, "type", qp_types_to_str(type))) continue; state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_STATE]); if (rd_check_is_string_filtered(rd, "state", qp_states_to_str(state))) continue; if (nla_line[RDMA_NLDEV_ATTR_RES_PID]) { pid = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_PID]); comm = get_task_name(pid); } if (rd_check_is_filtered(rd, "pid", pid)) { free(comm); continue; } if (nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]) /* discard const from mnl_attr_get_str */ comm = (char *)mnl_attr_get_str(nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]); if (rd->json_output) jsonw_start_array(rd->jw); print_link(rd, idx, name, port, nla_line); print_lqpn(rd, lqpn); print_rqpn(rd, rqpn, nla_line); print_type(rd, type); print_state(rd, state); print_rqpsn(rd, rq_psn, nla_line); print_sqpsn(rd, sq_psn); print_pathmig(rd, path_mig_state, nla_line); print_pid(rd, pid); print_comm(rd, comm, nla_line); if (nla_line[RDMA_NLDEV_ATTR_RES_PID]) free(comm); print_driver_table(rd, nla_line[RDMA_NLDEV_ATTR_DRIVER]); newline(rd); } return MNL_CB_OK; }
static void print_typealias(const typealias_t *alias) { fprintf(out, "typealias %s <- ", alias->base.symbol->string); print_type(alias->type); fprintf(out, "\n"); }
void process_xif_ifd(IFD_Type *ifd_ptr, TIFF_Hdr_Type *tiff_hdr, unsigned short segment_size, unsigned char *endofsegment_ptr) { int i; unsigned short entry_count; unsigned short tag; unsigned short type; unsigned count; unsigned value; unsigned int remaining_size; remaining_size = endofsegment_ptr - (unsigned char *)ifd_ptr; if (remaining_size > segment_size) _terminate(-1); entry_count=swap_short(ifd_ptr->Count); if (entry_count *12 + sizeof(entry_count) > remaining_size) { printf("Invalid IFD count value\n"); _terminate(-1); } printf("# of arrays: @d\n", entry_count); for (i=0; i< entry_count; ++i) { tag = swap_short(ifd_ptr->Entry[i].Tag); type = swap_short(ifd_ptr->Entry[i].Type); count = swap_word(ifd_ptr->Entry[i].Count); value = swap_word(ifd_ptr->Entry[i].Value); printf("Tag: @x (", tag); print_xif_tag_text(tag); printf(")\n"); printf("Type: @x (", type); print_type(type); printf(")\n"); printf("Count: @d\n", count); #ifdef PATCHED if (type==2) { if ( ((char *)ifd_ptr+value > (char *)tiff_hdr+segment_size) || ((char *)ifd_ptr+value < (char *)ifd_ptr )) { printf("Value: 0\n"); return; } } #endif if (type == 2) { #ifdef PATCHED if ( strlen( (char*)(ifd_ptr) + value ) > 2048 ) { ((char*)(ifd_ptr))[value+2048] = '\x00'; } #endif printf("Value: @s\n", (char *)(ifd_ptr) + value); } else { printf("Value: @u\n", value); } } }
void print_NormOperator( NormOperator *o ) { NormEffect *e; int i, m; printf("\n\n----------------Operator %s, normalized form--------------\n", o->operator->name); for ( i = 0; i < o->num_vars; i++ ) { printf("\nx%d of type ", i); print_type( o->var_types[i] ); } printf("\n\n%d vars removed from original operator:", o->num_removed_vars); for ( i = 0; i < o->num_removed_vars; i++ ) { m = o->removed_vars[i]; printf("\nx%d (%s) of type %s, type constraint ", m, o->operator->var_names[m], gtype_names[o->operator->var_types[m]]); print_type( o->type_removed_vars[i] ); } printf("\nPreconds:\n"); for ( i = 0; i < o->num_preconds; i++ ) { print_Fact( &(o->preconds[i]) ); printf("\n"); } for ( i = 0; i < o->num_numeric_preconds; i++ ) { switch ( o->numeric_preconds_comp[i] ) { case LE: printf("(< "); break; case LEQ: printf("(<= "); break; case EQ: printf("(= "); break; case GEQ: printf("(>= "); break; case GE: printf("(> "); break; default: printf("\nwrong comparator of Expnodes in normpre %d\n\n", o->numeric_preconds_comp[i]); exit( 1 ); } print_ExpNode( o->numeric_preconds_lh[i] ); print_ExpNode( o->numeric_preconds_rh[i] ); printf(")\n"); } m = 0; printf("\n\nEffects:"); for ( e = o->effects; e; e = e->next ) { printf("\n\neffect %d, parameters %d", m++, e->num_vars); for ( i = 0; i < e->num_vars; i++ ) { printf("\nx%d of type ", o->num_vars + i); print_type( e->var_types[i] ); } printf("\nConditions\n"); for ( i = 0; i < e->num_conditions; i++ ) { print_Fact( &(e->conditions[i]) ); printf("\n"); } for ( i = 0; i < e->num_numeric_conditions; i++ ) { switch ( e->numeric_conditions_comp[i] ) { case LE: printf("(< "); break; case LEQ: printf("(<= "); break; case EQ: printf("(= "); break; case GEQ: printf("(>= "); break; case GE: printf("(> "); break; default: printf("\nwrong comparator of Expnodes in normeff %d\n\n", e->numeric_conditions_comp[i]); exit( 1 ); } print_ExpNode( e->numeric_conditions_lh[i] ); print_ExpNode( e->numeric_conditions_rh[i] ); printf(")\n"); } printf("\nAdds\n"); for ( i = 0; i < e->num_adds; i++ ) { print_Fact( &(e->adds[i]) ); printf("\n"); } printf("\nDels\n"); for ( i = 0; i < e->num_dels; i++ ) { print_Fact( &(e->dels[i]) ); printf("\n"); } for ( i = 0; i < e->num_numeric_effects; i++ ) { switch ( e->numeric_effects_neft[i] ) { case ASSIGN: printf("\nassign "); break; case SCALE_UP: printf("\nscale-up "); break; case SCALE_DOWN: printf("\nscale-down "); break; case INCREASE: printf("\nincrease "); break; case DECREASE: printf("\ndecrease "); break; default: printf("\n\nprint normop: illegal neft %d\n\n", e->numeric_effects_neft[i]); exit( 1 ); } print_Fluent( &(e->numeric_effects_fluent[i]) ); print_ExpNode( e->numeric_effects_rh[i] ); } } }
void print_decl(decl *d, enum pdeclargs mode) { if(mode & PDECL_INDENT) idt_print(); if(d->store) fprintf(cc1_out, "%s ", decl_store_to_str(d->store)); if(fopt_mode & FOPT_ENGLISH){ print_decl_eng(d); }else{ print_type(d->ref, d); } if(mode & PDECL_SYM_OFFSET){ if(d->sym){ const int off = d->sym->type == sym_arg ? d->sym->loc.arg_offset : (int)d->sym->loc.stack_pos; fprintf(cc1_out, " (sym %s, pos = %d)", sym_to_str(d->sym->type), off); }else{ fprintf(cc1_out, " (no sym)"); } } if(mode & PDECL_SIZE && !type_is(d->ref, type_func)){ if(type_is_complete(d->ref)){ const unsigned sz = decl_size(d); const unsigned align = decl_align(d); fprintf(cc1_out, " size %u, align %u", sz, align); }else{ fprintf(cc1_out, " incomplete decl"); } } if(mode & PDECL_NEWLINE) fputc('\n', cc1_out); if(!type_is(d->ref, type_func) && d->bits.var.init.dinit && mode & PDECL_PINIT) { gen_str_indent++; print_decl_init(d->bits.var.init.dinit); gen_str_indent--; } if(mode & PDECL_ATTR){ gen_str_indent++; if(!type_is(d->ref, type_func) && d->bits.var.align) idt_printf("[align={as_int=%d, resolved=%d}]\n", d->bits.var.align->as_int, d->bits.var.align->resolved); print_attribute(d->attr); print_type_attr(d->ref); gen_str_indent--; } if((mode & PDECL_FUNC_DESCEND) && DECL_HAS_FUNC_CODE(d)){ decl **iter; gen_str_indent++; for(iter = d->bits.func.code->symtab->decls; iter && *iter; iter++){ sym *s = (*iter)->sym; if(s) idt_printf("offset of %s = %d\n", (*iter)->spel, s->loc.stack_pos); } idt_printf("function stack space %d\n", d->bits.func.code->symtab->auto_total_size); print_stmt(d->bits.func.code); gen_str_indent--; } }
void print_MixedOperator( MixedOperator *o ) { int i, m; Effect *e; NumericEffect *ne; Literal *l; printf("\n\n----------------Operator %s, mixed form--------------\n", o->operator->name); for ( i = 0; i < o->operator->num_vars; i++ ) { printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]); print_type( o->operator->var_types[i] ); } printf("\nPreconds:\n"); for ( i = 0; i < o->num_preconds; i++ ) { print_Fact( &(o->preconds[i]) ); printf("\n"); } for ( i = 0; i < o->num_numeric_preconds; i++ ) { switch ( o->numeric_preconds_comp[i] ) { case LE: printf("(< "); break; case LEQ: printf("(<= "); break; case EQ: printf("(= "); break; case GEQ: printf("(>= "); break; case GE: printf("(> "); break; default: printf("\nwrong comparator of Expnodes in mixedpre %d\n\n", o->numeric_preconds_comp[i]); exit( 1 ); } print_ExpNode( o->numeric_preconds_lh[i] ); print_ExpNode( o->numeric_preconds_rh[i] ); printf(")\n"); } m = 0; printf("\n\nEffects:"); for ( e = o->effects; e; e = e->next ) { printf("\n\neffect %d, parameters %d", m++, e->num_vars); for ( i = 0; i < e->num_vars; i++ ) { printf("\nx%d of type %s", o->operator->num_vars + i, gtype_names[e->var_types[i]]); } printf("\nConditions\n"); print_Wff( e->conditions, 0 ); printf("\nEffect Literals"); for ( l = e->effects; l; l = l->next ) { if ( l->negated ) { printf("\nNOT "); } else { printf("\n"); } print_Fact( &(l->fact) ); } printf("\nNumeric Effects"); for ( ne = e->numeric_effects; ne; ne = ne->next ) { switch ( ne->neft ) { case ASSIGN: printf("\nassign "); break; case SCALE_UP: printf("\nscale-up "); break; case SCALE_DOWN: printf("\nscale-down "); break; case INCREASE: printf("\nincrease "); break; case DECREASE: printf("\ndecrease "); break; default: printf("\n\nprint effect: illegal neft %d\n\n", ne->neft); exit( 1 ); } print_Fluent( &(ne->fluent) ); print_ExpNode( ne->rh ); } } }
int diff_can_type( hid_t f_tid1, /* file data type */ hid_t f_tid2, /* file data type */ int rank1, int rank2, hsize_t *dims1, hsize_t *dims2, hsize_t *maxdim1, hsize_t *maxdim2, const char *obj1_name, const char *obj2_name, diff_opt_t *options, int is_compound) { H5T_class_t tclass1; H5T_class_t tclass2; int maxdim_diff=0; /* maximum dimensions are different */ int dim_diff=0; /* current dimensions are different */ int i; int can_compare = 1; /* return value */ /*------------------------------------------------------------------------- * check for the same class *------------------------------------------------------------------------- */ if ((tclass1=H5Tget_class(f_tid1)) < 0) return -1; if ((tclass2=H5Tget_class(f_tid2)) < 0) return -1; if ( tclass1 != tclass2 ) { if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name) { if ( is_compound ) { parallel_print("Not comparable: <%s> has a class %s and <%s> has a class %s\n", obj1_name, get_class(tclass1), obj2_name, get_class(tclass2) ); } else { parallel_print("Not comparable: <%s> is of class %s and <%s> is of class %s\n", obj1_name, get_class(tclass1), obj2_name, get_class(tclass2) ); } } can_compare = 0; options->not_cmp = 1; return can_compare; } /*------------------------------------------------------------------------- * check for non supported classes *------------------------------------------------------------------------- */ HDassert(tclass1==tclass2); switch (tclass1) { case H5T_INTEGER: case H5T_FLOAT: case H5T_COMPOUND: case H5T_STRING: case H5T_ARRAY: case H5T_BITFIELD: case H5T_OPAQUE: case H5T_ENUM: case H5T_VLEN: case H5T_REFERENCE: break; default: /*H5T_TIME */ if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name) { parallel_print("Not comparable: <%s> and <%s> are of class %s\n", obj1_name,obj2_name,get_class(tclass2) ); } can_compare = 0; options->not_cmp = 1; return can_compare; } /*------------------------------------------------------------------------- * check for equal file datatype; warning only *------------------------------------------------------------------------- */ if ( (H5Tequal(f_tid1, f_tid2)==0) && (options->m_verbose) && obj1_name && obj2_name) { H5T_class_t cl = H5Tget_class(f_tid1); parallel_print("Warning: different storage datatype\n"); if ( cl == H5T_INTEGER || cl == H5T_FLOAT ) { parallel_print("<%s> has file datatype ", obj1_name); print_type(f_tid1); parallel_print("\n"); parallel_print("<%s> has file datatype ", obj2_name); print_type(f_tid2); parallel_print("\n"); } } /*------------------------------------------------------------------------- * check for the same rank *------------------------------------------------------------------------- */ if ( rank1 != rank2 ) { if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name) { parallel_print("Not comparable: <%s> has rank %d, dimensions ", obj1_name, rank1); print_dimensions(rank1,dims1); parallel_print(", max dimensions "); print_dimensions(rank1,maxdim1); parallel_print("\n" ); parallel_print("and <%s> has rank %d, dimensions ", obj2_name, rank2); print_dimensions(rank2,dims2); parallel_print(", max dimensions "); print_dimensions(rank2,maxdim2); parallel_print("\n"); } can_compare = 0; options->not_cmp = 1; return can_compare; } /*------------------------------------------------------------------------- * check for different dimensions *------------------------------------------------------------------------- */ HDassert(rank1==rank2); for ( i=0; i<rank1; i++) { if (maxdim1 && maxdim2) { if ( maxdim1[i] != maxdim2[i] ) maxdim_diff=1; } if ( dims1[i] != dims2[i] ) dim_diff=1; } /*------------------------------------------------------------------------- * current dimensions *------------------------------------------------------------------------- */ if (dim_diff==1) { if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name) { parallel_print("Not comparable: <%s> has rank %d, dimensions ", obj1_name, rank1); print_dimensions(rank1,dims1); if (maxdim1 && maxdim2) { parallel_print(", max dimensions "); print_dimensions(rank1,maxdim1); parallel_print("\n" ); parallel_print("and <%s> has rank %d, dimensions ", obj2_name, rank2); print_dimensions(rank2,dims2); parallel_print(", max dimensions "); print_dimensions(rank2,maxdim2); parallel_print("\n"); } } can_compare = 0; options->not_cmp = 1; return can_compare; } /*------------------------------------------------------------------------- * maximum dimensions; just give a warning *------------------------------------------------------------------------- */ if (maxdim1 && maxdim2 && maxdim_diff==1 && obj1_name ) { if (options->m_verbose) { parallel_print( "Warning: different maximum dimensions\n"); parallel_print("<%s> has max dimensions ", obj1_name); print_dimensions(rank1,maxdim1); parallel_print("\n"); parallel_print("<%s> has max dimensions ", obj2_name); print_dimensions(rank2,maxdim2); parallel_print("\n"); } } if ( tclass1 == H5T_COMPOUND ) { int nmembs1; int nmembs2; int j; hid_t memb_type1; hid_t memb_type2; nmembs1 = H5Tget_nmembers(f_tid1); nmembs2 = H5Tget_nmembers(f_tid2); if ( nmembs1 != nmembs2 ) { if ( (options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name) { parallel_print("Not comparable: <%s> has %d members ", obj1_name, nmembs1); parallel_print("<%s> has %d members ", obj2_name, nmembs2); parallel_print("\n"); } can_compare = 0; options->not_cmp = 1; return can_compare; } for (j = 0; j < nmembs1; j++) { memb_type1 = H5Tget_member_type(f_tid1, (unsigned)j); memb_type2 = H5Tget_member_type(f_tid2, (unsigned)j); if (diff_can_type(memb_type1, memb_type2, rank1, rank2, dims1, dims2, maxdim1, maxdim2, obj1_name, obj2_name, options, 1)!=1) { can_compare = 0; options->not_cmp = 1; H5Tclose(memb_type1); H5Tclose(memb_type2); return can_compare; } H5Tclose(memb_type1); H5Tclose(memb_type2); } } return can_compare; }
void print_backtrace(struct object_heap* oh) { word_t depth = 0, detail_depth = -1 /*raise this to print verbose args in stack longer*/; struct Interpreter* i = oh->cached.interpreter; struct Closure* closure = (struct Closure*)i->method; word_t codePointer = i->codePointer; word_t fp = i->framePointer; word_t sp = i->stackPointer; word_t codeSize = i->codeSize; word_t resultStackPointer = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_RESULT_STACK_POINTER]); struct LexicalContext* lc = (struct LexicalContext*)i->stack->elements[fp - FRAME_OFFSET_LEXICAL_CONTEXT];; fprintf(stderr, "printing backtrace from fp=%" PRIdPTR ", sp=%" PRIdPTR "\n", fp, i->stackPointer); do { word_t j; struct Object** vars; word_t input_count = object_to_smallint(closure->method->inputVariables); word_t local_count = object_to_smallint(closure->method->localVariables); vars = (closure->method->heapAllocate == oh->cached.true_object)? (&lc->variables[0]) : (&i->stack->elements[fp]); fprintf(stderr, "------------------------------\n"); fprintf(stderr, "FP: %" PRIdPTR "\n", fp); fprintf(stderr, "SP: %" PRIdPTR "\n", sp); fprintf(stderr, "IP: %" PRIdPTR "/%" PRIdPTR "\n", codePointer, codeSize); fprintf(stderr, "result: %" PRIdPTR "\n", resultStackPointer); fprintf(stderr, "code: %p\n", closure->method->code); fprintf(stderr, "selector #"); print_byte_array((struct Object*)(closure->method->selector)); fprintf(stderr, "\n"); fprintf(stderr, "regs: %" PRIdPTR "\n", object_to_smallint(closure->method->registerCount)); fprintf(stderr, "heap alloc: %s\n", (closure->method->heapAllocate == oh->cached.true_object)? "true" : "false"); for (j = 0; j < input_count; j++) { fprintf(stderr, "arg[%" PRIdPTR "] (%p) = ", j, (void*)vars[j]); if (depth > detail_depth) { print_type(oh, vars[j]); } else { print_detail(oh, vars[j]); } } if (closure->method->heapAllocate == oh->cached.true_object) { for (j = 0; j < local_count; j++) { fprintf(stderr, "var[%" PRIdPTR "] (%p)= ", j, (void*)lc->variables[j]); if (depth > detail_depth) { print_type(oh, lc->variables[j]); } else { print_detail(oh, lc->variables[j]); } } } else { for (j = input_count; j < input_count + local_count; j++) { fprintf(stderr, "var[%" PRIdPTR "] (%p) = ", j - input_count, (void*)vars[j]); if (depth > detail_depth) { print_type(oh, vars[j]); } else { print_detail(oh, vars[j]); } } } /*order matters here*/ codePointer = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_CODE_POINTER]); fp = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_PREVIOUS_FRAME_POINTER]); if (fp < FUNCTION_FRAME_SIZE) break; sp = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_BEFORE_CALL_STACK_POINTER]); resultStackPointer = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_RESULT_STACK_POINTER]); closure = (struct Closure*)i->stack->elements[fp - FRAME_OFFSET_METHOD]; lc = (struct LexicalContext*)i->stack->elements[fp - FRAME_OFFSET_LEXICAL_CONTEXT]; codeSize = array_size(closure->method->code); depth++; } while (fp >= FUNCTION_FRAME_SIZE); }