// The test program (function is called in an endless loop) // Used to display all digits // Activated when both buttons are pressed during system startup // Button 0 switches between continous running mode (where // digits just get incremented every 250ms) and selective mode where // Button 1 is used to increment the digits void test_program(void) { update_buttons(); if(g_buttons[0] && !g_last_buttons[0]) g_last_blink_state = 1 - g_last_blink_state; if(g_last_blink_state == 0) { if(g_buttons[1] && !g_last_buttons[1]) { g_last_blink_action = g_ticks; g_blink_numbers = (g_blink_numbers + 1) % 10; } } else if(time_since(g_last_blink_action) > 25) { g_last_blink_action = g_ticks; g_blink_numbers = (g_blink_numbers + 1) % 10; } set_number(pins_d1, g_blink_numbers); set_number(pins_d2, g_blink_numbers); set_number(pins_d3, g_blink_numbers); set_number(pins_d4, g_blink_numbers); }
/* * use gdb to get field offset of struct task_struct, for example: * * gdb vmlinux * (gdb)p &(((struct task_struct *)0).prio) */ static int kplib_curr_taskinfo(ktap_state_t *ks) { int offset = kp_arg_checknumber(ks, 1); int fetch_bytes = kp_arg_checkoptnumber(ks, 2, 4); /* fetch 4 bytes */ if (offset >= sizeof(struct task_struct)) { set_nil(ks->top++); kp_error(ks, "access out of bound value of task_struct\n"); return 1; } #define RET_VALUE ((unsigned long)current + offset) switch (fetch_bytes) { case 4: set_number(ks->top, *(unsigned int *)RET_VALUE); break; case 8: set_number(ks->top, *(unsigned long *)RET_VALUE); break; default: kp_error(ks, "unsupported fetch bytes in curr_task_info\n"); set_nil(ks->top); break; } #undef RET_VALUE incr_top(ks); return 1; }
void write_output(uint8_t a, uint8_t b) { set_number(pins_d1, a > 99 ? 0xF : (a / 10)); set_number(pins_d2, a > 99 ? 0xF : (a % 10)); set_number(pins_d3, b > 99 ? 0xF : (b / 10)); set_number(pins_d4, b > 99 ? 0xF : (b % 10)); }
void test_serde() { // dynamic create message. MessageHelper helper; FileDescriptorProto file_proto; file_proto.set_name("test.proo"); DescriptorProto *message_proto = file_proto.add_message_type(); message_proto->set_name("Pair"); auto field = message_proto->add_field(); field->set_name("key"); field->set_label(FieldDescriptorProto_Label_LABEL_REQUIRED); field->set_type(FieldDescriptorProto_Type_TYPE_STRING); field->set_number(1); field = message_proto->add_field(); field->set_name("value"); field->set_label(FieldDescriptorProto_Label_LABEL_REQUIRED); field->set_type(FieldDescriptorProto_Type_TYPE_BYTES); field->set_number(2); helper.registerDynamicMessage(file_proto); auto src = helper.createMessage("Pair"); auto ref = src->GetReflection(); string key("scott"); string value("tiger"); ref->SetString(src.get(), src->GetDescriptor()->FindFieldByName("key"), key); ref->SetString(src.get(), src->GetDescriptor()->FindFieldByName("value"), value); // test serde check_serde_str(src.get(), helper.createMessage("Pair").get()); check_serde_array(src.get(), helper.createMessage("Pair").get()); check_serstr_dearray(src.get(), helper.createMessage("Pair").get()); check_serarray_destr(src.get(), helper.createMessage("Pair").get()); }
/* Functions to manage NSSM-specific settings in the registry. */ static int setting_set_number(const TCHAR *service_name, void *param, const TCHAR *name, void *default_value, value_t *value, const TCHAR *additional) { HKEY key = (HKEY) param; if (! key) return -1; unsigned long number; long error; /* Resetting to default? */ if (! value || ! value->string) { error = RegDeleteValue(key, name); if (error == ERROR_SUCCESS || error == ERROR_FILE_NOT_FOUND) return 0; print_message(stderr, NSSM_MESSAGE_REGDELETEVALUE_FAILED, name, service_name, error_string(error)); return -1; } if (str_number(value->string, &number)) return -1; if (default_value && number == (unsigned long) default_value) { error = RegDeleteValue(key, name); if (error == ERROR_SUCCESS || error == ERROR_FILE_NOT_FOUND) return 0; print_message(stderr, NSSM_MESSAGE_REGDELETEVALUE_FAILED, name, service_name, error_string(error)); return -1; } if (set_number(key, (TCHAR *) name, number)) return -1; return 1; }
HandCloseWindow::HandCloseWindow(QWidget *parent) : QDialog(parent), ui(new Ui::HandCloseWindow) { ui->setupUi(this); QObject::connect(&timer, SIGNAL(timeout()),this,SLOT(set_number())); }
static int kplib_gettimeofday_us(ktap_state *ks) { set_number(ks->top, gettimeofday_us()); incr_top(ks); return 1; }
/* * This built-in function mainly purpose scripts/schedule/schedtimes.kp */ static int kplib_in_iowait(ktap_state *ks) { set_number(ks->top, current->in_iowait); incr_top(ks); return 1; }
static int kplib_gettimeofday_s(ktap_state *ks) { set_number(ks->top, gettimeofday_ns() / NSEC_PER_SEC); incr_top(ks); return 1; }
/* Init its cdata type, but not its actual value */ static void kp_cdata_init(ktap_state_t *ks, ktap_val_t *val, void *addr, int len, csymbol_id id) { ffi_type type = csym_type(id_to_csym(ks, id)); switch (type) { case FFI_PTR: set_cdata(val, kp_cdata_new_ptr(ks, addr, len, id, 0)); break; case FFI_STRUCT: case FFI_UNION: set_cdata(val, kp_cdata_new_record(ks, addr, id)); break; case FFI_UINT8: case FFI_INT8: case FFI_UINT16: case FFI_INT16: case FFI_UINT32: case FFI_INT32: case FFI_UINT64: case FFI_INT64: /* set all these value into ktap_number(long) */ set_number(val, 0); break; default: set_cdata(val, kp_cdata_new(ks, id)); break; } }
static int kplib_tid(ktap_state *ks) { pid_t pid = task_pid_vnr(current); set_number(ks->top, (int)pid); incr_top(ks); return 1; }
MaskWindow::MaskWindow(QWidget *parent) : QDialog(parent), ui(new Ui::MaskWindow) { ui->setupUi(this); if(!Configuration::config().user_mask.empty()) ui->pushButton->setText("Reconfigure mask"); QObject::connect(&timer, SIGNAL(timeout()),this,SLOT(set_number())); }
static int kplib_in_interrupt(ktap_state *ks) { int ret = in_interrupt(); set_number(ks->top, ret); incr_top(ks); return 1; }
static int kplib_avg(ktap_state *ks) { ktap_value *v = kp_arg(ks, 1); ktap_stat_data *sd; if (is_nil(v)) { set_number(ks->top, 0); incr_top(ks); return 1; } kp_arg_check(ks, 1, KTAP_TYPE_STATDATA); sd = sdvalue(v); set_number(ks->top, sd->sum / sd->count); incr_top(ks); return 1; }
static int ktap_lib_min(ktap_state *ks) { ktap_value *v = kp_arg(ks, 1); ktap_stat_data *sd; if (is_nil(v)) { set_number(ks->top, 0); incr_top(ks); return 1; } kp_arg_check(ks, 1, KTAP_TSTATDATA); sd = sdvalue(v); set_number(ks->top, sd->min); incr_top(ks); return 1; }
/* * use gdb to get field offset of struct task_struct, for example: * * gdb vmlinux * (gdb)p &(((struct task_struct *)0).prio) */ static int kplib_curr_taskinfo(ktap_state *ks) { int offset; int fetch_bytes; kp_arg_check(ks, 1, KTAP_TYPE_NUMBER); offset = nvalue(kp_arg(ks, 1)); if (kp_arg_nr(ks) == 1) fetch_bytes = 4; /* default fetch 4 bytes*/ else { kp_arg_check(ks, 2, KTAP_TYPE_NUMBER); fetch_bytes = nvalue(kp_arg(ks, 2)); } if (offset >= sizeof(struct task_struct)) { set_nil(ks->top++); kp_error(ks, "access out of bound value of task_struct\n"); return 1; } #define RET_VALUE ((unsigned long)current + offset) switch (fetch_bytes) { case 4: set_number(ks->top, *(unsigned int *)RET_VALUE); break; case 8: set_number(ks->top, *(unsigned long *)RET_VALUE); break; default: kp_error(ks, "unsupported fetch bytes in curr_task_info\n"); set_nil(ks->top); break; } #undef RET_VALUE incr_top(ks); return 1; }
static int process_command(usb_dev_handle *handle, char *cmd) { int tube = 0; int value = 0; int anim = 0; int speed = 0; int r = 0; int g = 0; int b = 0; if (sscanf(cmd, "t%d:%d", &tube, &value) == 2 && tube >= 0 && value >= 0) { printf("Setting nixie tube %u to %u.\n", tube, value); return set_tube(handle, tube, value); } else if (sscanf(cmd, "l%d:%d/%d/%d", &tube, &r, &g, &b) == 4 && tube >= 0) { printf("Setting nixie LED %u to %u/%u/%u.\n", tube, r, g, b); return set_led(handle, tube, r, g, b); } else if (sscanf(cmd, "anim:%d:%d", &anim, &speed) == 2 && anim >= 0 && anim >= 0) { printf("Setting animation style %u with speed %u.\n", anim, speed); return set_animation(handle, anim, speed); } else if (sscanf(cmd, "lnum:%d", &value) == 1 && value >= 0) { printf("Setting number %u\n", value); return set_number(handle, value, 1); } else if (sscanf(cmd, "num:%d", &value) == 1 && value >= 0) { printf("Setting number %u\n", value); return set_number(handle, value, 0); } else if (sscanf(cmd, "color:%d/%d/%d", &r, &g, &b) == 3) { printf("Setting color %u/%u/%u\n", r, g, b); return set_color(handle, r, g, b); } else if (strcmp(cmd, "off") == 0) { printf("Turning off all tubes...\n"); return tubes_off(handle); } else if (strcmp(cmd, "read") == 0) { printf("Reading commands from stdin...\n"); return read_cmds(handle, 0); } else if (strcmp(cmd, "readf") == 0) { printf("Reading commands from stdin (autofail)...\n"); return read_cmds(handle, 1); } else { fprintf(stderr, "Unable to parse command: %s\n", cmd); return 2; } return 0; }
static int kplib_uid(ktap_state *ks) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0) uid_t uid = from_kuid_munged(current_user_ns(), current_uid()); #else uid_t uid = current_uid(); #endif set_number(ks->top, (int)uid); incr_top(ks); return 1; }
static int kplib_len(ktap_state *ks) { int len = kp_obj_len(ks, kp_arg(ks, 1)); if (len < 0) return -1; set_number(ks->top, len); incr_top(ks); return 1; }
void Person_PhoneNumber::MergeFrom(const Person_PhoneNumber& from) { GOOGLE_CHECK_NE(&from, this); if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { if (from.has_number()) { set_number(from.number()); } if (from.has_type()) { set_type(from.type()); } } mutable_unknown_fields()->append(from.unknown_fields()); }
static int load_constants(struct load_state *S, ktap_proto *f) { int i,n; n = READ_INT(S); f->sizek = n; f->k = NEW_VECTOR(S, n * sizeof(ktap_value)); for (i = 0; i < n; i++) set_nil(&f->k[i]); for (i=0; i < n; i++) { ktap_value *o = &f->k[i]; int t = READ_CHAR(S); switch (t) { case KTAP_TNIL: set_nil(o); break; case KTAP_TBOOLEAN: set_boolean(o, READ_CHAR(S)); break; case KTAP_TNUMBER: /* * todo: kernel not support fp, check double when * loading */ set_number(o, READ_NUMBER(S)); break; case KTAP_TSTRING: set_string(o, READ_STRING(S)); break; default: kp_error(S->ks, "ktap: load_constants: " "unknow ktap_value\n"); return -1; } } n = READ_INT(S); f->p = NEW_VECTOR(S, n * sizeof(ktap_proto)); f->sizep = n; for (i = 0; i < n; i++) f->p[i] = NULL; for (i = 0; i < n; i++) { f->p[i] = kp_newproto(S->ks); if (load_function(S, f->p[i])) return -1; } return 0; }
void u_setfaction(unit * u, faction * f) { int cnt = u->number; if (u->faction == f) return; if (u->faction) { set_number(u, 0); if (count_unit(u)) --u->faction->no_units; join_group(u, NULL); free_orders(&u->orders); set_order(&u->thisorder, NULL); if (u->nextF) u->nextF->prevF = u->prevF; if (u->prevF) u->prevF->nextF = u->nextF; else u->faction->units = u->nextF; } if (f != NULL) { if (f->units) f->units->prevF = u; u->prevF = NULL; u->nextF = f->units; f->units = u; } else u->nextF = NULL; u->faction = f; if (u->region) update_interval(f, u->region); if (cnt && f) { set_number(u, cnt); if (count_unit(u)) ++f->no_units; } }
static int killunit_handle(trigger * t, void *data) { /* call an event handler on killunit. * data.v -> ( variant event, int timer ) */ unit *u = (unit *)t->data.v; if (u) { /* we can't remove_unit() here, because that's what's calling us. */ set_number(u, 0); } unused_arg(data); return 0; }
void temp_handler(void) { temp_samples[sample++] = make_fixed(raw_temp); if (sample == N_SAMPLES) { fixed_t t = make_fixed(0); for (uint8_t i = 0; i < N_SAMPLES; i++) { t = fixed_add(t, temp_samples[i]); } temp = fixed_round(fixed_div(fixed_div(t, N_SAMPLES), 4)); set_number(0, temp, relay_on); sample = 0; } }
TEST(zmq_protobuf_msg_test, send_recv) { tutorial::MessageUnion msg; auto person = msg.mutable_person(); person->set_name("bob"); person->set_id(678); auto phone = person->add_phone(); phone->set_number("4125556666"); phone->set_type(tutorial::Person::WORK); tutorial::MessageUnion out = msg2protobuf(protobuf2msg(msg)); EXPECT_TRUE(out.msg_case() == tutorial::MessageUnion::kPerson); EXPECT_TRUE(out.has_person()); EXPECT_EQ(out.person().name(), msg.person().name()); // note that person() creates a default instance if the oneof did // not contain a person, I had expected exception instead. }
void model_implicant::assign_value(expr* e, expr* val) { rational r; if (m.is_true(val)) { set_true(e); } else if (m.is_false(val)) { set_false(e); } else if (m_arith.is_numeral(val, r)) { set_number(e, r); } else if (m.is_value(val)) { set_value(e, val); } else { IF_VERBOSE(3, verbose_stream() << "Not evaluated " << mk_pp(e, m) << " := " << mk_pp(val, m) << "\n";); TRACE("pdr", tout << "Variable is not tracked: " << mk_pp(e, m) << " := " << mk_pp(val, m) << "\n";);
void scale_number(unit * u, int n) { skill_t sk; const attrib *a; int remain; if (n == u->number) return; if (n && u->number > 0) { int full; remain = ((u->hp % u->number) * (n % u->number)) % u->number; full = u->hp / u->number; /* wieviel kriegt jede person mindestens */ u->hp = full * n + (u->hp - full * u->number) * n / u->number; assert(u->hp >= 0); if ((rng_int() % u->number) < remain) ++u->hp; /* Nachkommastellen */ } else { remain = 0; u->hp = 0; } if (u->number > 0) { for (a = a_find(u->attribs, &at_effect); a && a->type == &at_effect; a = a->next) { effect_data *data = (effect_data *) a->data.v; int snew = data->value / u->number * n; if (n) { remain = data->value - snew / n * u->number; snew += remain * n / u->number; remain = (remain * n) % u->number; if ((rng_int() % u->number) < remain) ++snew; /* Nachkommastellen */ } data->value = snew; } } if (u->number == 0 || n == 0) { for (sk = 0; sk < MAXSKILLS; sk++) { remove_skill(u, sk); } } set_number(u, n); }
static void equip_newunits(const struct equipment *eq, struct unit *u) { struct region *r = u->region; const struct resource_type *rtype; switch (old_race(u_race(u))) { case RC_ELF: rtype = rt_find("fairyboot"); set_show_item(u->faction, rtype->itype); break; case RC_GOBLIN: rtype = rt_find("roi"); set_show_item(u->faction, rtype->itype); set_number(u, 10); break; case RC_HUMAN: if (u->building == NULL) { const building_type *btype = bt_find("castle"); if (btype != NULL) { building *b = new_building(btype, r, u->faction->locale); b->size = 10; u_set_building(u, b); building_set_owner(u); } } break; case RC_CAT: rtype = rt_find("roi"); set_show_item(u->faction, rtype->itype); break; case RC_AQUARIAN: { ship *sh = new_ship(st_find("boat"), r, u->faction->locale); sh->size = sh->type->construction->maxsize; u_set_ship(u, sh); } break; case RC_CENTAUR: rsethorses(r, 250 + rng_int() % 51 + rng_int() % 51); break; default: break; } }
/** * Return the source IP address for a given sock */ static int kplib_ip_sock_saddr(ktap_state *ks) { struct inet_sock *isk; int family; kp_arg_check(ks, 1, KTAP_TYPE_NUMBER); /* need to validate the address firstly */ isk = (struct inet_sock *)nvalue(kp_arg(ks, 1)); family = isk->sk.__sk_common.skc_family; if (family == AF_INET) { set_number(ks->top, isk->inet_rcv_saddr); } else { kp_error(ks, "ip_sock_saddr only support ipv4 now\n"); set_nil(ks->top); } incr_top(ks); return 1; }
static int caldera_handle(trigger * t, void *data) { /* call an event handler on caldera. * data.v -> ( variant event, int timer ) */ building *b = (building *)t->data.v; if (b != NULL) { unit **up = &b->region->units; while (*up) { unit *u = *up; if (u->building == b) { message *msg; if (u->items) { item **ip = &u->items; msg = msg_message("caldera_handle_1", "unit items", u, u->items); while (*ip) { item *i = *ip; i_remove(ip, i); if (*ip == i) ip = &i->next; } } else { msg = msg_message("caldera_handle_0", "unit", u); } add_message(&u->region->msgs, msg); set_number(u, 0); } if (*up == u) up = &u->next; } } else { log_error("could not perform caldera::handle()\n"); } unused_arg(data); return 0; }