// 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;
}
