inline BOOL set_max(F64 max, I32 dim=0) { if ((9 == get_type()) && (dim < get_dim())) { this->max[dim].f64 = max; options |= 0x04; return TRUE; } return FALSE; };
static int array_size (Dwarf_Die *die, Dwarf_Word *size, Dwarf_Attribute *attr_mem, Dwarf_Die *type_mem) { Dwarf_Word eltsize; if (INTUSE(dwarf_aggregate_size) (get_type (die, attr_mem, type_mem), &eltsize) != 0) return -1; /* An array can have DW_TAG_subrange_type or DW_TAG_enumeration_type children instead that give the size of each dimension. */ Dwarf_Die child; if (INTUSE(dwarf_child) (die, &child) != 0) return -1; bool any = false; Dwarf_Word total = 0; do { Dwarf_Word count; switch (INTUSE(dwarf_tag) (&child)) { case DW_TAG_subrange_type: /* This has either DW_AT_count or DW_AT_upper_bound. */ if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_count, attr_mem) != NULL) { if (INTUSE(dwarf_formudata) (attr_mem, &count) != 0) return -1; } else { Dwarf_Sword upper; Dwarf_Sword lower; if (INTUSE(dwarf_formsdata) (INTUSE(dwarf_attr_integrate) (&child, DW_AT_upper_bound, attr_mem), &upper) != 0) return -1; /* Having DW_AT_lower_bound is optional. */ if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_lower_bound, attr_mem) != NULL) { if (INTUSE(dwarf_formsdata) (attr_mem, &lower) != 0) return -1; } else { /* Determine default lower bound from language, as per "4.12 Subrange Type Entries". */ Dwarf_Die cu = CUDIE (die->cu); switch (INTUSE(dwarf_srclang) (&cu)) { case DW_LANG_C: case DW_LANG_C89: case DW_LANG_C99: case DW_LANG_C_plus_plus: case DW_LANG_ObjC: case DW_LANG_ObjC_plus_plus: case DW_LANG_Java: case DW_LANG_D: case DW_LANG_UPC: lower = 0; break; case DW_LANG_Ada83: case DW_LANG_Ada95: case DW_LANG_Cobol74: case DW_LANG_Cobol85: case DW_LANG_Fortran77: case DW_LANG_Fortran90: case DW_LANG_Fortran95: case DW_LANG_Pascal83: case DW_LANG_Modula2: case DW_LANG_PL1: lower = 1; break; default: return -1; } } if (unlikely (lower > upper)) return -1; count = upper - lower + 1; } break; case DW_TAG_enumeration_type: /* We have to find the DW_TAG_enumerator child with the highest value to know the array's element count. */ count = 0; Dwarf_Die enum_child; int has_children = INTUSE(dwarf_child) (die, &enum_child); if (has_children < 0) return -1; if (has_children > 0) do if (INTUSE(dwarf_tag) (&enum_child) == DW_TAG_enumerator) { Dwarf_Word value; if (INTUSE(dwarf_formudata) (INTUSE(dwarf_attr_integrate) (&enum_child, DW_AT_const_value, attr_mem), &value) != 0) return -1; if (value >= count) count = value + 1; } while (INTUSE(dwarf_siblingof) (&enum_child, &enum_child) > 0); break; default: continue; } /* This is a subrange_type or enumeration_type and we've set COUNT. Now determine the stride for this array dimension. */ Dwarf_Word stride = eltsize; if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_byte_stride, attr_mem) != NULL) { if (INTUSE(dwarf_formudata) (attr_mem, &stride) != 0) return -1; } else if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_bit_stride, attr_mem) != NULL) { if (INTUSE(dwarf_formudata) (attr_mem, &stride) != 0) return -1; if (stride % 8) /* XXX maybe compute in bits? */ return -1; stride /= 8; } any = true; total += stride * count; } while (INTUSE(dwarf_siblingof) (&child, &child) == 0); if (!any) return -1; *size = total; return 0; }
void isiout_write( fields *f, FILE *fp, param *p, unsigned long refnum ) { int type = get_type( f ); if ( p->format_opts & BIBL_FORMAT_VERBOSE ) output_verbose( f, refnum ); output_type( fp, type ); output_people( fp, f, "AUTHOR", "AU", 0 ); output_easyall( fp, f, "AUTHOR:CORP", "AU", 0 ); output_easyall( fp, f, "AUTHOR:ASIS", "AU", 0 ); /* output_people( fp, f, "AUTHOR", "A2", 1 ); output_people( fp, f, "AUTHOR:CORP", "A2", 1 ); output_people( fp, f, "AUTHOR:ASIS", "A2", 1 ); output_people( fp, f, "AUTHOR", "A3", 2 ); output_people( fp, f, "AUTHOR:CORP", "A3", 2 ); output_people( fp, f, "AUTHOR:ASIS", "A3", 2 ); output_people( fp, f, "EDITOR", "ED", -1 ); output_people( fp, f, "EDITOR:CORP", "ED", -1 ); output_people( fp, f, "EDITOR:ASIS", "ED", -1 );*/ /* output_date( fp, f, refnum );*/ output_title( fp, f, "TI", 0 ); if ( type==TYPE_ARTICLE ) { output_title( fp, f, "SO", 1 ); output_abbrtitle( fp, f, "JI", 1 ); output_title( fp, f, "SE", 2 ); } else if ( type==TYPE_INBOOK ) { output_title( fp, f, "BT", 1 ); output_title( fp, f, "SE", 2 ); } else { /* type==BOOK */ output_title( fp, f, "SE", 1 ); } output_date( fp, f ); /* output_easy( fp, f, "PARTMONTH", "PD", -1 ); output_easy( fp, f, "PARTYEAR", "PY", -1 );*/ output_easy( fp, f, "PAGESTART", "BP", -1 ); output_easy( fp, f, "PAGEEND", "EP", -1 ); output_easy( fp, f, "ARTICLENUMBER", "AR", -1 ); /* output article number as pages */ output_easy( fp, f, "TOTALPAGES","PG", -1 ); output_easy( fp, f, "VOLUME", "VL", -1 ); output_easy( fp, f, "ISSUE", "IS", -1 ); output_easy( fp, f, "NUMBER", "IS", -1 ); output_easy( fp, f, "DOI", "DI", -1 ); output_easy( fp, f, "ISIREFNUM", "UT", -1 ); output_easy( fp, f, "LANGUAGE", "LA", -1 ); output_easy( fp, f, "ISIDELIVERNUM", "GA", -1 ); output_keywords( fp, f ); output_easy( fp, f, "ABSTRACT", "AB", -1 ); output_easy( fp, f, "TIMESCITED", "TC", -1 ); output_easy( fp, f, "NUMBERREFS", "NR", -1 ); output_easy( fp, f, "CITEDREFS", "CR", -1 ); output_easy( fp, f, "ADDRESS", "PI", -1 ); /* output_easy( fp, f, "PUBLISHER", "PB", -1 ); output_easy( fp, f, "DEGREEGRANTOR", "PB", -1 ); output_easy( fp, f, "ADDRESS", "CY", -1 ); output_easy( fp, f, "ABSTRACT", "AB", -1 ); output_easy( fp, f, "ISSN", "SN", -1 ); output_easy( fp, f, "ISBN", "SN", -1 ); output_easyall( fp, f, "URL", "UR", -1 ); output_easyall( fp, f, "FILEATTACH", "UR", -1 ); output_pubmed( fp, f, refnum ); output_easyall( fp, f, "NOTES", "N1", -1 ); output_easyall( fp, f, "REFNUM", "ID", -1 );*/ fprintf( fp, "ER\n\n" ); fflush( fp ); }
bool BrowserNode::same_name(const QString & s, UmlCode type) const { return ((get_type() == type) && (name == s)); }
void BrowserNode::write_id(ToolCom * com) { com->write_id(this, get_type() - UmlRelations, name); }
static void tsmf_gstreamer_enough_data(GstAppSrc *src, gpointer user_data) { TSMFGstreamerDecoder* mdecoder = user_data; (void) mdecoder; DEBUG_TSMF("%s", get_type(mdecoder)); }
StringListType* StringListType::make(const string& name, int size) { StringListType* t = new StringListType(name, size); t = static_cast<StringListType*>(get_type(t)); return t; }
// @Override virtual void debug_print(int indent) override { get_type()->debug_print(0); printf(" %s", get_name()->c_str()); }
// init - instantiate the battery monitors void AP_BattMonitor::init() { // check init has not been called before if (_num_instances != 0) { return; } _highest_failsafe_priority = INT8_MAX; convert_params(); #ifdef HAL_BATT_MONITOR_DEFAULT if (_params[0]._type == 0) { // we can't use set_default() as the type is used as a flag for parameter conversion _params[0]._type.set((AP_BattMonitor_Params::BattMonitor_Type)HAL_BATT_MONITOR_DEFAULT); } #endif // create each instance for (uint8_t instance=0; instance<AP_BATT_MONITOR_MAX_INSTANCES; instance++) { // clear out the cell voltages memset(&state[instance].cell_voltages, 0xFF, sizeof(cells)); switch (get_type(instance)) { case AP_BattMonitor_Params::BattMonitor_TYPE_ANALOG_VOLTAGE_ONLY: case AP_BattMonitor_Params::BattMonitor_TYPE_ANALOG_VOLTAGE_AND_CURRENT: drivers[instance] = new AP_BattMonitor_Analog(*this, state[instance], _params[instance]); _num_instances++; break; case AP_BattMonitor_Params::BattMonitor_TYPE_SOLO: drivers[instance] = new AP_BattMonitor_SMBus_Solo(*this, state[instance], _params[instance], hal.i2c_mgr->get_device(AP_BATTMONITOR_SMBUS_BUS_INTERNAL, AP_BATTMONITOR_SMBUS_I2C_ADDR, 100000, true, 20)); _num_instances++; break; case AP_BattMonitor_Params::BattMonitor_TYPE_MAXELL: drivers[instance] = new AP_BattMonitor_SMBus_Maxell(*this, state[instance], _params[instance], hal.i2c_mgr->get_device(AP_BATTMONITOR_SMBUS_BUS_EXTERNAL, AP_BATTMONITOR_SMBUS_I2C_ADDR, 100000, true, 20)); _num_instances++; break; case AP_BattMonitor_Params::BattMonitor_TYPE_BEBOP: #if CONFIG_HAL_BOARD_SUBTYPE == HAL_BOARD_SUBTYPE_LINUX_BEBOP || CONFIG_HAL_BOARD_SUBTYPE == HAL_BOARD_SUBTYPE_LINUX_DISCO drivers[instance] = new AP_BattMonitor_Bebop(*this, state[instance], _params[instance]); _num_instances++; #endif break; case AP_BattMonitor_Params::BattMonitor_TYPE_UAVCAN_BatteryInfo: #if HAL_WITH_UAVCAN drivers[instance] = new AP_BattMonitor_UAVCAN(*this, state[instance], AP_BattMonitor_UAVCAN::UAVCAN_BATTERY_INFO, _params[instance]); _num_instances++; #endif break; case AP_BattMonitor_Params::BattMonitor_TYPE_BLHeliESC: #ifdef HAVE_AP_BLHELI_SUPPORT drivers[instance] = new AP_BattMonitor_BLHeliESC(*this, state[instance], _params[instance]); _num_instances++; #endif break; case AP_BattMonitor_Params::BattMonitor_TYPE_NONE: default: break; } // call init function for each backend if (drivers[instance] != nullptr) { drivers[instance]->init(); } } }
void event_t::print_byte_header (FILE* f) { //fwrite_double (f, time); fwrite_int64 (f, (int64_t) time); fwrite_int64 (f, id); fwrite_int64 (f, get_type()); }
int main(int argc, char ** argv) { //get command line arguments int c; char * pvalue = NULL; while ((c = getopt (argc, argv, "p:")) != -1) { switch (c) { case 'p': pvalue = optarg; break; default: break; } } int cmd_type; //enumerated value to determine how command is executed int cmd_block; //whether to wait for child to exit or not int cmd_argc; //number of args counted while parsing char cmd_args[MAX_ARG_COUNT][MAX_INPUT_LENGTH]; //store command line args char * exec_args[MAX_ARG_COUNT]; //cmd_args incompatible type with execvp //ready prompt char prompt[MAX_INPUT_LENGTH]; init_prompt(prompt); if(pvalue != NULL) { change_prompt(prompt,pvalue); } char buffer[MAX_INPUT_LENGTH]; //general purpose string buffer int done = 0; do { //clear command buffer int i; for(i = 0; i < MAX_ARG_COUNT; i++) { cmd_args[i][0] = '\0'; } //get input print_prompt(prompt); scanf("\n"); scanf("%[^\n]",buffer); //store history strcpy(history[history_count],buffer); history_count++; //tokenize char * ptr = strtok(buffer," "); i = 0; while(ptr != NULL) { strcpy(cmd_args[i],ptr); ptr = strtok(NULL," "); i++; } argc = i; //set state based on input cmd_type = get_type(cmd_args[0]); cmd_block = get_block(cmd_args[argc-1]); int j; for(j = 0; j < argc; j++) { exec_args[j] = cmd_args[j]; } if(!cmd_block) //want to eliminate & { exec_args[argc-1] = NULL; } else //keep all args parsed { exec_args[argc] = NULL; } //check if any children exited int status, child_pid; child_pid = waitpid(-1,&status,WNOHANG); if(child_pid > 0) { get_status_str(status,child_pid,buffer); print_out(buffer); } //execute done = execute(cmd_type,cmd_block,cmd_args[0],exec_args); }while(!done); return 0; }
std::string PinguAction::get_name () const { return ActionName::to_screenname(get_type()); }
inline BOOL set_min(U32 min, I32 dim=0) { if ((4 == get_type()) && (dim < get_dim())) { this->min[dim].u64 = min; options |= 0x02; return TRUE; } return FALSE; };
inline BOOL set_no_data(F64 no_data, I32 dim=0) { if ((9 == get_type()) && (dim < get_dim())) { this->no_data[dim].f64 = no_data; options |= 0x01; return TRUE; } return FALSE; };
static BOOL tsmf_gstreamer_decodeEx(ITSMFDecoder* decoder, const BYTE *data, UINT32 data_size, UINT32 extensions, UINT64 start_time, UINT64 end_time, UINT64 duration) { GstBuffer *gst_buf; TSMFGstreamerDecoder* mdecoder = (TSMFGstreamerDecoder *) decoder; UINT64 sample_time = tsmf_gstreamer_timestamp_ms_to_gst(start_time); BOOL useTimestamps = TRUE; if (!mdecoder) { WLog_ERR(TAG, "Decoder not initialized!"); return FALSE; } /* * This function is always called from a stream-specific thread. * It should be alright to block here if necessary. * We don't expect to block here often, since the pipeline should * have more than enough buffering. */ DEBUG_TSMF("%s. Start:(%"PRIu64") End:(%"PRIu64") Duration:(%"PRIu64") Last Start:(%"PRIu64")", get_type(mdecoder), start_time, end_time, duration, mdecoder->last_sample_start_time); if (mdecoder->shutdown) { WLog_ERR(TAG, "decodeEx called on shutdown decoder"); return TRUE; } if (mdecoder->gst_caps == NULL) { WLog_ERR(TAG, "tsmf_gstreamer_set_format not called or invalid format."); return FALSE; } if (!mdecoder->pipe) tsmf_gstreamer_pipeline_build(mdecoder); if (!mdecoder->src) { WLog_ERR(TAG, "failed to construct pipeline correctly. Unable to push buffer to source element."); return FALSE; } gst_buf = tsmf_get_buffer_from_data(data, data_size); if (gst_buf == NULL) { WLog_ERR(TAG, "tsmf_get_buffer_from_data(%p, %"PRIu32") failed.", (void*) data, data_size); return FALSE; } /* Relative timestamping will sometimes be set to 0 * so we ignore these timestamps just to be safe(bit 8) */ if (extensions & 0x00000080) { DEBUG_TSMF("Ignoring the timestamps - relative - bit 8"); useTimestamps = FALSE; } /* If no timestamps exist then we dont want to look at the timestamp values (bit 7) */ if (extensions & 0x00000040) { DEBUG_TSMF("Ignoring the timestamps - none - bit 7"); useTimestamps = FALSE; } /* If performing a seek */ if (mdecoder->seeking) { mdecoder->seeking = FALSE; tsmf_gstreamer_pipeline_set_state(mdecoder, GST_STATE_PAUSED); mdecoder->pipeline_start_time_valid = 0; } if (mdecoder->pipeline_start_time_valid) { DEBUG_TSMF("%s start time %"PRIu64"", get_type(mdecoder), start_time); /* Adjusted the condition for a seek to be based on start time only * WMV1 and WMV2 files in particular have bad end time and duration values * there seems to be no real side effects of just using the start time instead */ UINT64 minTime = mdecoder->last_sample_start_time - (UINT64) SEEK_TOLERANCE; UINT64 maxTime = mdecoder->last_sample_start_time + (UINT64) SEEK_TOLERANCE; /* Make sure the minTime stops at 0 , should we be at the beginning of the stream */ if (mdecoder->last_sample_start_time < (UINT64) SEEK_TOLERANCE) minTime = 0; /* If the start_time is valid and different from the previous start time by more than the seek tolerance, then we have a seek condition */ if (((start_time > maxTime) || (start_time < minTime)) && useTimestamps) { DEBUG_TSMF("tsmf_gstreamer_decodeEx: start_time=[%"PRIu64"] > last_sample_start_time=[%"PRIu64"] OR ", start_time, mdecoder->last_sample_start_time); DEBUG_TSMF("tsmf_gstreamer_decodeEx: start_time=[%"PRIu64"] < last_sample_start_time=[%"PRIu64"] with", start_time, mdecoder->last_sample_start_time); DEBUG_TSMF("tsmf_gstreamer_decodeEX: a tolerance of more than [%lu] from the last sample", SEEK_TOLERANCE); DEBUG_TSMF("tsmf_gstreamer_decodeEX: minTime=[%"PRIu64"] maxTime=[%"PRIu64"]", minTime, maxTime); mdecoder->seeking = TRUE; /* since we cant make the gstreamer pipeline jump to the new start time after a seek - we just maintain * a offset between realtime and gstreamer time */ mdecoder->seek_offset = start_time; } } else { DEBUG_TSMF("%s start time %"PRIu64"", get_type(mdecoder), start_time); /* Always set base/start time to 0. Will use seek offset to translate real buffer times * back to 0. This allows the video to be started from anywhere and the ability to handle seeks * without rebuilding the pipeline, etc. since that is costly */ gst_element_set_base_time(mdecoder->pipe, tsmf_gstreamer_timestamp_ms_to_gst(0)); gst_element_set_start_time(mdecoder->pipe, tsmf_gstreamer_timestamp_ms_to_gst(0)); mdecoder->pipeline_start_time_valid = 1; /* Set the seek offset if buffer has valid timestamps. */ if (useTimestamps) mdecoder->seek_offset = start_time; if (!gst_element_seek(mdecoder->pipe, 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE)) { WLog_ERR(TAG, "seek failed"); } } #if GST_VERSION_MAJOR > 0 if (useTimestamps) GST_BUFFER_PTS(gst_buf) = sample_time - tsmf_gstreamer_timestamp_ms_to_gst(mdecoder->seek_offset); else GST_BUFFER_PTS(gst_buf) = GST_CLOCK_TIME_NONE; #else if (useTimestamps) GST_BUFFER_TIMESTAMP(gst_buf) = sample_time - tsmf_gstreamer_timestamp_ms_to_gst(mdecoder->seek_offset); else GST_BUFFER_TIMESTAMP(gst_buf) = GST_CLOCK_TIME_NONE; #endif GST_BUFFER_DURATION(gst_buf) = GST_CLOCK_TIME_NONE; GST_BUFFER_OFFSET(gst_buf) = GST_BUFFER_OFFSET_NONE; #if GST_VERSION_MAJOR > 0 #else gst_buffer_set_caps(gst_buf, mdecoder->gst_caps); #endif gst_app_src_push_buffer(GST_APP_SRC(mdecoder->src), gst_buf); /* Should only update the last timestamps if the current ones are valid */ if (useTimestamps) { mdecoder->last_sample_start_time = start_time; mdecoder->last_sample_end_time = end_time; } if (mdecoder->pipe && (GST_STATE(mdecoder->pipe) != GST_STATE_PLAYING)) { DEBUG_TSMF("%s: state=%s", get_type(mdecoder), gst_element_state_get_name(GST_STATE(mdecoder->pipe))); DEBUG_TSMF("%s Paused: %"PRIi32" Shutdown: %i Ready: %"PRIi32"", get_type(mdecoder), mdecoder->paused, mdecoder->shutdown, mdecoder->ready); if (!mdecoder->paused && !mdecoder->shutdown && mdecoder->ready) tsmf_gstreamer_pipeline_set_state(mdecoder, GST_STATE_PLAYING); } return TRUE; }
void PinData::on_delete() { BrowserClass * cl = get_type().type; if ((cl != 0) && cl->deletedp()) set_type((BrowserClass *) 0); }
static BOOL tsmf_gstreamer_control(ITSMFDecoder* decoder, ITSMFControlMsg control_msg, UINT32 *arg) { TSMFGstreamerDecoder* mdecoder = (TSMFGstreamerDecoder *) decoder; if (!mdecoder) { WLog_ERR(TAG, "Control called with no decoder!"); return TRUE; } if (control_msg == Control_Pause) { DEBUG_TSMF("Control_Pause %s", get_type(mdecoder)); if (mdecoder->paused) { WLog_ERR(TAG, "%s: Ignoring Control_Pause, already received!", get_type(mdecoder)); return TRUE; } tsmf_gstreamer_pipeline_set_state(mdecoder, GST_STATE_PAUSED); mdecoder->shutdown = 0; mdecoder->paused = TRUE; } else if (control_msg == Control_Resume) { DEBUG_TSMF("Control_Resume %s", get_type(mdecoder)); if (!mdecoder->paused && !mdecoder->shutdown) { WLog_ERR(TAG, "%s: Ignoring Control_Resume, already received!", get_type(mdecoder)); return TRUE; } mdecoder->shutdown = 0; mdecoder->paused = FALSE; } else if (control_msg == Control_Stop) { DEBUG_TSMF("Control_Stop %s", get_type(mdecoder)); if (mdecoder->shutdown) { WLog_ERR(TAG, "%s: Ignoring Control_Stop, already received!", get_type(mdecoder)); return TRUE; } /* Reset stamps, flush buffers, etc */ if (mdecoder->pipe) { tsmf_gstreamer_pipeline_set_state(mdecoder, GST_STATE_NULL); tsmf_window_destroy(mdecoder); tsmf_gstreamer_clean_up(mdecoder); } mdecoder->seek_offset = 0; mdecoder->pipeline_start_time_valid = 0; mdecoder->shutdown = 1; } else if (control_msg == Control_Restart) { DEBUG_TSMF("Control_Restart %s", get_type(mdecoder)); mdecoder->shutdown = 0; mdecoder->paused = FALSE; if (mdecoder->pipeline_start_time_valid) tsmf_gstreamer_pipeline_set_state(mdecoder, GST_STATE_PLAYING); } else WLog_ERR(TAG, "Unknown control message %08x", control_msg); return TRUE; }
VariableType* VariableType::make(const string& name) { VariableType* t = new VariableType(name); t = static_cast<VariableType*>(get_type(t)); return t; }
void check(const GeographicRegion& expected, const GeographicRegion& actual) { ASSERT_EQ(get_type(expected), get_type(actual)); boost::apply_visitor(check_visitor<GeographicRegion>(), expected, actual); }
bool clang_c_convertert::convert_float_literal( const clang::FloatingLiteral &floating_literal, exprt &dest) { if(!config.ansi_c.use_fixed_for_float) { std::cerr << "floatbv unsupported, sorry" << std::endl; return false; } typet type; if(get_type(floating_literal.getType(), type)) return true; llvm::APFloat val = floating_literal.getValue(); llvm::SmallVector<char, 32> string; val.toString(string, 32, 0); unsigned width = bv_width(type); mp_integer value; std::string float_string; if(!val.isInfinity()) { mp_integer significand; mp_integer exponent; float_string = parse_float(string, significand, exponent); unsigned fraction_bits; const std::string &integer_bits = type.integer_bits().as_string(); if (integer_bits == "") fraction_bits = width / 2; else fraction_bits = width - atoi(integer_bits.c_str()); mp_integer factor = mp_integer(1) << fraction_bits; value = significand * factor; if(exponent < 0) value /= power(10, -exponent); else { value *= power(10, exponent); if(value <= -power(2, width - 1) - 1) { // saturate: use "smallest value" value = -power(2, width - 1); } } } else { // saturate: use "biggest value" value = power(2, width - 1) - 1; float_string = "2147483647.99999999976716935634613037109375"; } dest = constant_exprt( integer2binary(value, bv_width(type)), float_string, type); return false; }
void AWorldSpawn::gen_hex(int x, int y, int z) { Hex* hex = get_hex(x, y, z); if (hex) hex->type = get_type(x, y, z); }
int der_get_class_num(const char *name) { return get_type(name, class_names, SIZEOF_ARRAY(class_names)); }
bool BrowserNode::tool_cmd(ToolCom * com, const char * args) { switch ((unsigned char) args[-1]) { case applyCmd: { QLOG_FATAL() << Q_FUNC_INFO << "If this got called then we have a logic flaw going on and BrowserNode needs to have Q_OBJECT in it to properly catch ToolCom::Run execution result"; Q_ASSERT_X(0, "applyCmd happened", "very bad"); int runResult = ToolCom::run(args, this, FALSE, FALSE); com->write_unsigned(runResult); break; } case createCmd: // invalid creation com->write_id(0); break; case parentCmd: if (this != BrowserView::get_project()) ((BrowserNode *) parent())->write_id(com); else com->write_id(0); break; case childrenCmd: { unsigned v = com->api_format(); unsigned n = 0; Q3ListViewItem * child; for (child = firstChild(); child != 0; child = child->nextSibling()) if (!((BrowserNode *) child)->deletedp() && ((BrowserNode *) child)->api_compatible(v)) n += 1; com->write_unsigned(n); for (child = firstChild(); child != 0; child = child->nextSibling()) if (!((BrowserNode *) child)->deletedp() && ((BrowserNode *) child)->api_compatible(v)) ((BrowserNode *) child)->write_id(com); } break; case getDefCmd: case getUmlDefCmd: case getCppDefCmd: case getJavaDefCmd: case getPhpDefCmd: case getPythonDefCmd: case getIdlDefCmd: get_data()->send_uml_def(com, this, comment); break; case isWritableCmd: com->write_bool(!is_read_only); break; case supportFileCmd: // goes up to the package return ((BrowserNode *) parent())->tool_cmd(com, args); case isOpenCmd: com->write_bool(isOpen()); break; case referencedByCmd: { BrowserNodeList targetof; referenced_by(targetof); // remove duplicats targetof.sort_it(); BrowserNode * bn; targetof.first(); while ((bn = targetof.current()) != 0) if (bn == targetof.next()) targetof.remove(); com->write_unsigned(targetof.count()); for (bn = targetof.first(); bn != 0; bn = targetof.next()) bn->write_id(com); } break; case setCoupleValueCmd: if (is_read_only && !root_permission()) com->write_ack(FALSE); else { set_value(args, args + strlen(args) + 1); package_modified(); get_data()->modified(); com->write_ack(TRUE); } break; case setDescriptionCmd: if (is_read_only && !root_permission()) com->write_ack(FALSE); else { set_comment(args); package_modified(); com->write_ack(TRUE); } break; case setNameCmd: if (is_read_only && !root_permission()) com->write_ack(FALSE); else { if (name != args) { if (((BrowserNode *) parent())->wrong_child_name(args, get_type(), allow_spaces(), allow_empty())) { com->write_ack(FALSE); return TRUE; } else { set_name(args); update_stereotype(); package_modified(); get_data()->modified(); } } com->write_ack(TRUE); } break; case setOpenCmd: BrowserView::select(this); setOpen(*args); com->write_ack(TRUE); break; case setMarkedCmd: if (*args) { if (this == BrowserView::get_project()) com->write_ack(FALSE); else { if (!is_marked) toggle_mark(); com->write_ack(TRUE); } } else { if (is_marked) toggle_mark(); com->write_ack(TRUE); } break; case moveAfterCmd: if (is_read_only && !root_permission()) com->write_ack(FALSE); else { BrowserNode * p = (BrowserNode *) parent(); BrowserNode * after = (BrowserNode *) com->get_id(args); if (after == 0) { if (p == 0) com->write_ack(FALSE); else { p->takeItem(this); p->insertItem(this); com->write_ack(TRUE); p->package_modified(); } } else if ((after->parent() != p) || (after == this)) { com->write_ack(FALSE); } else { moveItem(after); com->write_ack(TRUE); p->package_modified(); } } break; case moveInCmd: // plug-out upgrade, limited checks if (is_read_only && !root_permission()) com->write_ack(FALSE); else { BrowserNode * newparent = (BrowserNode *) com->get_id(args); BrowserNode * oldparent = (BrowserNode *) parent(); if ((newparent == oldparent) || (newparent == this)) { com->write_ack(FALSE); } else { oldparent->takeItem(this); newparent->insertItem(this); com->write_ack(TRUE); oldparent->package_modified(); newparent->package_modified(); } } break; case old_deleteCmd: case deleteCmd: if (is_read_only && !root_permission()) com->write_ack(FALSE); else { delete_it(); ((BrowserNode *) parent())->get_data()->modified(); package_modified(); com->write_ack(TRUE); } break; case applyStereotypeCmd: if (is_read_only && !root_permission()) com->write_ack(FALSE); else { ProfiledStereotypes::applyStereotype(this); // call package_modified() if needed com->write_ack(TRUE); } break; default: return FALSE; } return TRUE; }
int der_get_tag_num(const char *name) { return get_type(name, tag_names, SIZEOF_ARRAY(tag_names)); }
QString BrowserNode::drag_key() const { return QString::number(get_type()); }
static void tsmf_gstreamer_need_data(GstAppSrc *src, guint length, gpointer user_data) { TSMFGstreamerDecoder* mdecoder = user_data; (void) mdecoder; DEBUG_TSMF("%s length=%u", get_type(mdecoder), length); }
void add(int x, int c) { cnt[get_type(x, c)]++; }
BOOL tsmf_gstreamer_pipeline_build(TSMFGstreamerDecoder* mdecoder) { #if GST_VERSION_MAJOR > 0 const char* video = "appsrc name=videosource ! queue2 name=videoqueue ! decodebin name=videodecoder !"; const char* audio = "appsrc name=audiosource ! queue2 name=audioqueue ! decodebin name=audiodecoder ! audioconvert ! audiorate ! audioresample ! volume name=audiovolume !"; #else const char* video = "appsrc name=videosource ! queue2 name=videoqueue ! decodebin2 name=videodecoder !"; const char* audio = "appsrc name=audiosource ! queue2 name=audioqueue ! decodebin2 name=audiodecoder ! audioconvert ! audiorate ! audioresample ! volume name=audiovolume !"; #endif char pipeline[1024]; if (!mdecoder) return FALSE; /* TODO: Construction of the pipeline from a string allows easy overwrite with arguments. * The only fixed elements necessary are appsrc and the volume element for audio streams. * The rest could easily be provided in gstreamer pipeline notation from command line. */ if (mdecoder->media_type == TSMF_MAJOR_TYPE_VIDEO) sprintf_s(pipeline, sizeof(pipeline), "%s %s name=videosink", video, tsmf_platform_get_video_sink()); else sprintf_s(pipeline, sizeof(pipeline), "%s %s name=audiosink", audio, tsmf_platform_get_audio_sink()); DEBUG_TSMF("pipeline=%s", pipeline); mdecoder->pipe = gst_parse_launch(pipeline, NULL); if (!mdecoder->pipe) { WLog_ERR(TAG, "Failed to create new pipe"); return FALSE; } if (mdecoder->media_type == TSMF_MAJOR_TYPE_VIDEO) mdecoder->src = gst_bin_get_by_name(GST_BIN(mdecoder->pipe), "videosource"); else mdecoder->src = gst_bin_get_by_name(GST_BIN(mdecoder->pipe), "audiosource"); if (!mdecoder->src) { WLog_ERR(TAG, "Failed to get appsrc"); return FALSE; } if (mdecoder->media_type == TSMF_MAJOR_TYPE_VIDEO) mdecoder->queue = gst_bin_get_by_name(GST_BIN(mdecoder->pipe), "videoqueue"); else mdecoder->queue = gst_bin_get_by_name(GST_BIN(mdecoder->pipe), "audioqueue"); if (!mdecoder->queue) { WLog_ERR(TAG, "Failed to get queue"); return FALSE; } if (mdecoder->media_type == TSMF_MAJOR_TYPE_VIDEO) mdecoder->outsink = gst_bin_get_by_name(GST_BIN(mdecoder->pipe), "videosink"); else mdecoder->outsink = gst_bin_get_by_name(GST_BIN(mdecoder->pipe), "audiosink"); if (!mdecoder->outsink) { WLog_ERR(TAG, "Failed to get sink"); return FALSE; } g_signal_connect(mdecoder->outsink, "child-added", G_CALLBACK(cb_child_added), mdecoder); if (mdecoder->media_type == TSMF_MAJOR_TYPE_AUDIO) { mdecoder->volume = gst_bin_get_by_name(GST_BIN(mdecoder->pipe), "audiovolume"); if (!mdecoder->volume) { WLog_ERR(TAG, "Failed to get volume"); return FALSE; } tsmf_gstreamer_change_volume((ITSMFDecoder*)mdecoder, mdecoder->gstVolume*((double) 10000), mdecoder->gstMuted); } tsmf_platform_register_handler(mdecoder); /* AppSrc settings */ GstAppSrcCallbacks callbacks = { tsmf_gstreamer_need_data, tsmf_gstreamer_enough_data, tsmf_gstreamer_seek_data }; g_object_set(mdecoder->src, "format", GST_FORMAT_TIME, NULL); g_object_set(mdecoder->src, "is-live", FALSE, NULL); g_object_set(mdecoder->src, "block", FALSE, NULL); g_object_set(mdecoder->src, "blocksize", 1024, NULL); gst_app_src_set_caps((GstAppSrc *) mdecoder->src, mdecoder->gst_caps); gst_app_src_set_callbacks((GstAppSrc *)mdecoder->src, &callbacks, mdecoder, NULL); gst_app_src_set_stream_type((GstAppSrc *) mdecoder->src, GST_APP_STREAM_TYPE_SEEKABLE); gst_app_src_set_latency((GstAppSrc *) mdecoder->src, 0, -1); gst_app_src_set_max_bytes((GstAppSrc *) mdecoder->src, (guint64) 0);//unlimited g_object_set(G_OBJECT(mdecoder->queue), "use-buffering", FALSE, NULL); g_object_set(G_OBJECT(mdecoder->queue), "use-rate-estimate", FALSE, NULL); g_object_set(G_OBJECT(mdecoder->queue), "max-size-buffers", 0, NULL); g_object_set(G_OBJECT(mdecoder->queue), "max-size-bytes", 0, NULL); g_object_set(G_OBJECT(mdecoder->queue), "max-size-time", (guint64) 0, NULL); /* Only set these properties if not an autosink, otherwise we will set properties when real sinks are added */ if (!g_strcmp0(G_OBJECT_TYPE_NAME(mdecoder->outsink), "GstAutoVideoSink") && !g_strcmp0(G_OBJECT_TYPE_NAME(mdecoder->outsink), "GstAutoAudioSink")) { if (mdecoder->media_type == TSMF_MAJOR_TYPE_VIDEO) { gst_base_sink_set_max_lateness((GstBaseSink *) mdecoder->outsink, 10000000); /* nanoseconds */ } else { gst_base_sink_set_max_lateness((GstBaseSink *) mdecoder->outsink, 10000000); /* nanoseconds */ g_object_set(G_OBJECT(mdecoder->outsink), "buffer-time", (gint64) 20000, NULL); /* microseconds */ g_object_set(G_OBJECT(mdecoder->outsink), "drift-tolerance", (gint64) 20000, NULL); /* microseconds */ g_object_set(G_OBJECT(mdecoder->outsink), "latency-time", (gint64) 10000, NULL); /* microseconds */ g_object_set(G_OBJECT(mdecoder->outsink), "slave-method", 1, NULL); } g_object_set(G_OBJECT(mdecoder->outsink), "sync", TRUE, NULL); /* synchronize on the clock */ g_object_set(G_OBJECT(mdecoder->outsink), "async", TRUE, NULL); /* no async state changes */ } tsmf_window_create(mdecoder); tsmf_gstreamer_pipeline_set_state(mdecoder, GST_STATE_READY); tsmf_gstreamer_pipeline_set_state(mdecoder, GST_STATE_PLAYING); mdecoder->pipeline_start_time_valid = 0; mdecoder->shutdown = 0; mdecoder->paused = FALSE; GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(mdecoder->pipe), GST_DEBUG_GRAPH_SHOW_ALL, get_type(mdecoder)); return TRUE; }
int nr_children (patch p) { if (get_type (p) != PATCH_COMPOUND) return 1; else return N(p); }
int migrate() { xmachine_memory_keratinocyte * xmemory = current_xmachine->xmachine_keratinocyte; /* these are the 'current' parameters*/ double x1, y1, dir1, motility1; /* these will be the 'new' parameters*/ double x2, y2, z2, dir2, motility2; /* only TAs and HACATs can move*/ if (get_type() == K_TYPE_TA || get_type() == K_TYPE_HACAT) { /* these are the 'current' parameters*/ x1 = get_x(); y1 = get_y(); dir1 = get_dir(); motility1 = get_motility(); /* if rnd less than 0.1, then changed direction within +/- 45 degrees*/ if (rnd() < 0.1) { dir1 += PI * rnd()/4.0; } x1 += motility1 * cos(dir1); y1 += motility1 * sin(dir1); /* check if we're about to bump into a stationary cell*/ location_message = get_first_location_message(); while(location_message) { x2 = location_message->x; y2 = location_message->y; z2 = location_message->z; dir2 = location_message->dir; motility2 = location_message->motility; /* check if we're on the base of the dish and other cell is stationary*/ if (on_substrate_surface(z2) && motility2 == 0) { /* find distance*/ double distance_check = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2)); if (distance_check != 0 && distance_check < K_WIDTH) { dir1 -= PI; /* reverse direction*/ if (dir1 > 2 * PI) { dir1 -= 2 * PI; } x1 = get_x() + motility1 * cos(dir1); y1 = get_y() + motility1 * sin(dir1); } } location_message = get_next_location_message(location_message); } /* update memory with new parameters*/ set_x(x1); set_y(y1); set_dir(dir1); set_motility(motility1); /* check we've not gone over the edge of the dish!*/ /* if so, reverse direction*/ if (xmemory->x > substrate_width) { xmemory->x = substrate_width - xmemory->motility *rnd(); xmemory->dir = PI + PI * (rnd()-0.5)/4.0; } if (xmemory->x < 0) { xmemory->x = xmemory->motility *rnd(); xmemory->dir = PI * (rnd()-0.5)/4.0; } if (xmemory->y > substrate_width) { xmemory->y = substrate_width -xmemory->motility *rnd(); xmemory->dir = (3.0 * PI/2.0) + PI * (rnd()-0.5)/4.0; } if (xmemory->y < 0) { xmemory->y = xmemory->motility * rnd(); xmemory->dir = (PI/2.0) + PI * (rnd()-0.5)/4.0; } } return 0; }