void keyer_init (int tone, int wpm)
{
int sample_rate = audio_init();
int samples_per_cycle = sample_rate / tone / 2 * 2;
dit_len = sample_rate * 12 / wpm / 10 /
samples_per_cycle * samples_per_cycle;
daah_len = 3 * dit_len;
fill_data (dit_data, dit_len, samples_per_cycle);
fill_data (daah_data, daah_len, samples_per_cycle);
}
int stream2scene(FILE* stream,element_t element,element_t light){
char ch;
scalar *data,*color,*ptr;
color=ALLOC_SCALAR(4);
color[0]=0.0; color[1]=0.0; color[2]=0.0; color[3]=0.0;
ch=fgetc(stream);
while(ch!=EOF){
switch(ch){
case 'T': /* triangle */
data=ALLOC_SCALAR(12);
data=fill_data(stream,data,9);
ptr=data+3; EXP3(ptr,-,data,ptr) /* B-A */
ptr=data+6; EXP3(ptr,-,data,ptr) /* C-A */
cross(data+3,data+6,data+9); /* compute normal */
normalize(data+9,data+9);
/* append to current element list */
element->next=create_element();
element=element->next;
element->type=TRIANGLE;
element->data=data;
element->color=color;
break;
case 'S': /* sphere */
data=ALLOC_SCALAR(4);
data=fill_data(stream,data,4);
/* append to current element list */
element->next=create_element();
element=element->next;
element->type=SPHERE;
element->data=data;
element->color=color;
break;
case 'L': /* light */
data=ALLOC_SCALAR(4);
data=fill_data(stream,data,4);
if(data[3]==0) { normalize(data,data);} /* if a parallel light source*/
/* append to current light list */
light->next=create_element();
light=light->next;
light->type=LIGHT;
light->data=data;
light->color=color;
break;
case 'C': /* if color, then update the current color */
color=ALLOC_SCALAR(4);
color=fill_data(stream,color,3);
break;
default:
break;
}
while(((ch=fgetc(stream))!=EOF)&&!isprint(ch)); /* goto nextvalid character */
}
return 0;
}
/*
Alignment test without tiling
*/
TEST(nn_workload_data_cpp_wrapper, alignment_test)
{
nn_workload_data_coords_t lengths = { 3, 4, 4, 4, 4, 4 };
nn_workload_data_layout_t layout =
{
{ 0, 0, 0, 0, 0, 0 }, // tile_log2
{ 0, 0, 0, 0, 0, 0 }, // alignment
default_ordering, // ordering
NN_DATATYPE_INT16
};
// we'll run test for two examples
nn_workload_data_coords_t alignment_n8 = { 3, 0, 0, 0, 0, 0 };
nn_workload_data_coords_t alignment_n8_x64 = { 3, 6, 0, 0, 0, 0 };
{
layout.alignment_log2 = alignment_n8;
nn::nn_workload_data_t<int16_t> nndata(lengths, layout);
memset(nndata.parent->data_buffer, 0, nndata.parent->buffer_size);
fill_data(nndata);
int16_t* buffer = (int16_t*)nndata.parent->data_buffer;
// without multiplication by 1, VC++ shows warnings...
EXPECT_EQ(1 << VAL_N_SHIFT, buffer[1 * (1<<layout.alignment_log2.t[NN_DATA_COORD_n])/sizeof(int16_t)]);
EXPECT_EQ(1 << VAL_X_SHIFT, buffer[1 * lengths.t[NN_DATA_COORD_n] * (1 << layout.alignment_log2.t[NN_DATA_COORD_n]) / sizeof(int16_t)]);
EXPECT_EQ(1 << VAL_Y_SHIFT, buffer[1 * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_n] * (1 << layout.alignment_log2.t[NN_DATA_COORD_n]) / sizeof(int16_t)]);
EXPECT_EQ(2 << VAL_Y_SHIFT, buffer[2 * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_n] * (1 << layout.alignment_log2.t[NN_DATA_COORD_n]) / sizeof(int16_t)]);
EXPECT_EQ(2 << VAL_Z_SHIFT, buffer[2 * lengths.t[NN_DATA_COORD_y] * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_n] * (1 << layout.alignment_log2.t[NN_DATA_COORD_n]) / sizeof(int16_t)]);
}
{
layout.alignment_log2 = alignment_n8_x64;
nn::nn_workload_data_t<int16_t> nndata(lengths, layout);
memset(nndata.parent->data_buffer, 0, nndata.parent->buffer_size);
fill_data(nndata);
int16_t* buffer = (int16_t*)nndata.parent->data_buffer;
// without multiplication by 1, VC++ shows warnings...
EXPECT_EQ(1 << VAL_N_SHIFT, buffer[1 * (1 << layout.alignment_log2.t[NN_DATA_COORD_n]) / sizeof(int16_t)]);
EXPECT_EQ(1 << VAL_X_SHIFT, buffer[1 * (1 << layout.alignment_log2.t[NN_DATA_COORD_x]) / sizeof(int16_t)]);
EXPECT_EQ(1 << VAL_Y_SHIFT, buffer[1 * lengths.t[NN_DATA_COORD_x] * (1 << layout.alignment_log2.t[NN_DATA_COORD_x]) / sizeof(int16_t)]);
EXPECT_EQ(2 << VAL_Y_SHIFT, buffer[2 * lengths.t[NN_DATA_COORD_x] * (1 << layout.alignment_log2.t[NN_DATA_COORD_x]) / sizeof(int16_t)]);
EXPECT_EQ(2 << VAL_Z_SHIFT, buffer[2 * lengths.t[NN_DATA_COORD_y] * lengths.t[NN_DATA_COORD_x] * (1 << layout.alignment_log2.t[NN_DATA_COORD_x]) / sizeof(int16_t)]);
}
}
t_obj *get_obj_from_file(char *file)
{
int fd;
char *buf;
t_obj *lst;
t_obj *bgn_lst;
lst = NULL;
bgn_lst = NULL;
if ((fd = check_file(file)) == -1)
file_error("Can't open file : ", file);
while (get_next_line(fd, &buf) > 0)
{
if (buf[0] == '/' || buf[0] == '*')
;
else if (buf[0] == '&')
lst = build_lnk(buf);
else if (buf[0] == '-' || (buf[0] >= '0' && buf[0] <= '9'))
{
lst = fill_data(buf, lst);
bgn_lst = lst_push_back(lst, bgn_lst);
}
free(buf);
buf = NULL;
}
return (bgn_lst);
}
// try applying sequence
int try_sequence(SEQLIST *test_sequence, int mem_size) {
SEQLIST *sptr;
unsigned char *mblock;
// reset the memory allocator being tested
MEMORY_SIZE = mem_size;
init_myalloc();
for (sptr = test_sequence; !seq_null(sptr); sptr = seq_next(sptr)) {
if (seq_alloc(sptr)) { // allocate a block
mblock = myalloc(seq_size(sptr));
if (mblock == 0) {
return 0; // failed -- return indication
}
else {
// keep track of address allocated (for later frees)
seq_set_myalloc_block(sptr, mblock);
// put data in the block
// (so we can test that it holds data w/out corruption)
fill_data(seq_ref_block(sptr), mblock, seq_size(sptr));
}
}
else { // dealloc
myfree(seq_myalloc_block(seq_tofree(sptr)));
}
}
return 1; // succeeded in allocating entire sequence
}
int get_next_line(int const fd, char **line)
{
static char *all_data = NULL;
char *rest;
int option;
if ((!all_data && (all_data = (char *)malloc(sizeof(*all_data))) == NULL) || !line
|| fd < 0 || BUFF_SIZE < 0)
return (-1);
rest = ft_strchr(all_data, '\n');
while (rest == NULL)
{
option = fill_data(fd, &all_data);
if (option == 0)
{
if (ft_strlen(all_data) == 0)
return (0);
all_data = ft_strjoin(all_data, "\n");
}
if (option < 0)
return (-1);
else
rest = ft_strchr(all_data, '\n');
}
*line = ft_strsub(all_data, 0, ft_strlen(all_data) - ft_strlen(rest));
all_data = ft_strdup(rest + 1);
return (1);
}
void read_and_echo_data(struct device *dev)
{
uart_buf_t *rx_buf;
while(true) {
rx_buf = k_fifo_get(&rx_fifo, K_FOREVER);
if (rx_buf != NULL) {
uint16_t len = sys_be16_to_cpu(*(uint16_t *)rx_buf->data);
printf("FIFO get: %d bytes [hdr=%d]\n", rx_buf->len, len);
/* if len is 0, echo bach the same data */
/* if len is !0, echo bach len bytes of data w/ filled content so receiver can verify */
if (len != 0) {
fill_data(rx_buf->data, len);
}
else {
len = rx_buf->len;
}
send_data(dev, rx_buf->data, len);
}
}
}
/*
Validate that data is placed according to requested ordering.
This test validates ordering inside a tile.
*/
TEST(nn_workload_data_cpp_wrapper, ordering_inside_tile_test)
{
nn_workload_data_coords_t lengths = { 4, 4, 4, 4, 4, 4 };
nn_workload_data_coords_t ordering_qnxzyp = { NN_DATA_COORD_q, NN_DATA_COORD_n, NN_DATA_COORD_x, NN_DATA_COORD_z, NN_DATA_COORD_y, NN_DATA_COORD_p };
// layout - create one tile that contains entire data structure
nn_workload_data_layout_t layout =
{
{ 2, 2, 2, 2, 2, 2 }, // tile_log2
{ 0, 0, 0, 0, 0, 0 }, // alignment
ordering_qnxzyp, // ordering
NN_DATATYPE_INT16
};
nn::nn_workload_data_t<int16_t> nndata(lengths, layout);
fill_data(nndata);
int16_t* buffer = (int16_t*)nndata.parent->data_buffer;
EXPECT_EQ((1 << VAL_N_SHIFT), buffer[lengths.t[NN_DATA_COORD_q]]);
EXPECT_EQ((1 << VAL_X_SHIFT), buffer[lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n]]);
EXPECT_EQ((2 << VAL_X_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n]]);
EXPECT_EQ((2 << VAL_Z_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n] * lengths.t[NN_DATA_COORD_x]]);
EXPECT_EQ((2 << VAL_Y_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n] * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_z]]);
EXPECT_EQ((1 << VAL_P_SHIFT), buffer[1 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n] * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_z] * lengths.t[NN_DATA_COORD_y]]);
EXPECT_EQ((2 << VAL_P_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n] * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_z] * lengths.t[NN_DATA_COORD_y]]);
}
static int
uniq(const char*file)
{
size_t filesize = get_simfile_size(file);
char *pmapfile = NULL;
int fd = -1, err = 0;
if((fd = open(file, O_RDONLY)) < 0)
{
perror("open");
exit(1);
}
if((pmapfile = (char *)mmap(0, filesize, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0)) == MAP_FAILED)
{
perror("mmap");
exit(1);
}
if((err = fill_data(pmapfile)) != 0)
goto end;
pr_uniqddata();
end:
if(pmapfile != NULL)
munmap(pmapfile, filesize);
if(fd != -1)
close(fd);
return err;
}
npc_edit::npc_edit(QWidget *parent) : _data_loaded(false), QWidget(parent), _npcedit_tab_selectednpc(0), ui(new Ui::npc_edit)
{
ui->setupUi(this);
QObject::connect(ui->npc_edit_tab_previewarea, SIGNAL(clickedIn()), this, SLOT(set_npc_frame()));
fill_data();
_data_loaded = true;
on_npc_edit_tab_selectnpccombo_currentIndexChanged(0);
}
int
main (int argc, const char **argv)
{
long long arr[6];
fill_data (arr);
test (arr);
return count - 5;
}
int main()
{
int lp1,lp2;
for (lp1 = 0; lp1 < 5; lp1++) {
fill_data(lp1);
DimEnterSnap(DIM_SNAP);
}
fill_data(++lp1);
DimEnterSnap(DIM_START);
for (lp2 = lp1; lp2 < 100; lp2++) {
fill_data(lp2);
DimEnterSnap(DIM_SNAP);
}
return 0;
}
tab_image::tab_image(QWidget *parent) :
QWidget(parent),
ui(new Ui::tab_image)
{
ui->setupUi(this);
fill_data();
}
TabText::TabText(QWidget *parent) :
QDialog(parent),
ui(new Ui::TabText)
{
ui->setupUi(this);
fill_data();
}
TabSfx::TabSfx(QWidget *parent) :
QWidget(parent),
ui(new Ui::TabSfx)
{
ui->setupUi(this);
fill_data();
}
/*
A test case for nn_workload_data copy functionality.
Validate that data is correctly copied according to the new layout.
*/
TEST(nn_workload_data_cpp_wrapper, copy_test)
{
nn_workload_data_coords_t lengths = { 3, 4, 3, 4, 3, 4 };
nn_workload_data_layout_t layout =
{
{ 0, 0, 0, 0, 0, 0 }, // tile_log2
{ 0, 0, 0, 0, 0, 0 }, // alignment
{ 0, 0, 0, 0, 0, 0 }, // ordering - will be set later for each test case
NN_DATATYPE_INT16
};
nn_workload_data_coords_t ordering_nxyzpq = { NN_DATA_COORD_n, NN_DATA_COORD_x, NN_DATA_COORD_y, NN_DATA_COORD_z, NN_DATA_COORD_p, NN_DATA_COORD_q };
nn_workload_data_coords_t ordering_xyzpqn = { NN_DATA_COORD_x, NN_DATA_COORD_y, NN_DATA_COORD_z, NN_DATA_COORD_p, NN_DATA_COORD_q, NN_DATA_COORD_n };
nn_workload_data_coords_t ordering_qnxzyp = { NN_DATA_COORD_q, NN_DATA_COORD_n, NN_DATA_COORD_x, NN_DATA_COORD_z, NN_DATA_COORD_y, NN_DATA_COORD_p };
layout.ordering = ordering_nxyzpq;
nn::nn_workload_data_t<int16_t> nndata(lengths, layout);
fill_data(nndata);
{
layout.ordering = ordering_xyzpqn;
// Create new nn_workload_data_t based on data copied from another nn_workload_data_t
nn::nn_workload_data_t<int16_t> nndata_1(nndata, layout);
int16_t* buffer = (int16_t*)nndata_1.parent->data_buffer;
EXPECT_EQ(1 << VAL_Y_SHIFT, buffer[lengths.t[NN_DATA_COORD_x]]);
EXPECT_EQ((1 << VAL_Z_SHIFT), buffer[lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_y]]);
EXPECT_EQ((3 << VAL_Z_SHIFT), buffer[3 * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_y]]);
EXPECT_EQ((2 << VAL_P_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_y] * lengths.t[NN_DATA_COORD_z]]);
EXPECT_EQ((3 << VAL_Q_SHIFT), buffer[3 * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_y] * lengths.t[NN_DATA_COORD_z] * lengths.t[NN_DATA_COORD_p]]);
EXPECT_EQ((1 << VAL_N_SHIFT), buffer[1 * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_y] * lengths.t[NN_DATA_COORD_z] * lengths.t[NN_DATA_COORD_p] * lengths.t[NN_DATA_COORD_q]]);
EXPECT_EQ((2 << VAL_N_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_y] * lengths.t[NN_DATA_COORD_z] * lengths.t[NN_DATA_COORD_p] * lengths.t[NN_DATA_COORD_q]]);
}
{
layout.ordering = ordering_qnxzyp;
nn::nn_workload_data_t<int16_t> nndata_1(lengths, layout);
// Copy from another nn_workload_data_t
nndata_1.copy(nndata);
int16_t* buffer = (int16_t*)nndata_1.parent->data_buffer;
EXPECT_EQ((1 << VAL_N_SHIFT), buffer[lengths.t[NN_DATA_COORD_q]]);
EXPECT_EQ((1 << VAL_X_SHIFT), buffer[lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n]]);
EXPECT_EQ((2 << VAL_X_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n]]);
EXPECT_EQ((2 << VAL_Z_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n] * lengths.t[NN_DATA_COORD_x]]);
EXPECT_EQ((2 << VAL_Y_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n] * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_z]]);
EXPECT_EQ((1 << VAL_P_SHIFT), buffer[1 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n] * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_z] * lengths.t[NN_DATA_COORD_y]]);
EXPECT_EQ((2 << VAL_P_SHIFT), buffer[2 * lengths.t[NN_DATA_COORD_q] * lengths.t[NN_DATA_COORD_n] * lengths.t[NN_DATA_COORD_x] * lengths.t[NN_DATA_COORD_z] * lengths.t[NN_DATA_COORD_y]]);
}
}
/*****************************************************************************
* Periodic handler to send RPC messages.
*****************************************************************************/
static int
periodic_event(INKCont contp, INKEvent event, void *e)
{
/*************************************************************************
* Note: Event subsystem always calls us with 'node_status_mutex' held.
*************************************************************************/
int n, size, ret;
INKClusterRPCMsg_t *rmsg;
hello_msg_t hello_msg;
struct in_addr in;
if (clusterRPC_plugin_shutdown) {
shutdown();
INKContDestroy(contp);
return 0;
}
/*************************************************************************
* Send a hello message to all online nodes.
*************************************************************************/
for (n = 1; n <= MAX_CLUSTER_NODES; ++n) {
if (nodes[n]) {
INKNodeHandleToIPAddr(&nodes[n], &in);
hello_msg.hm_version = HELLO_MSG_VERSION;
hello_msg.hm_source_handle = my_node_handle;
hello_msg.hm_dest_handle = nodes[n];
hello_msg.hm_instance = msg_instance++;
size = random() % (1 * 1024 * 1024);
if (size < sizeof(hello_msg_t)) {
size = sizeof(hello_msg_t);
}
rmsg = INKAllocClusterRPCMsg(&rpc_wireless_f10_handle, size);
hello_msg.hm_data_size = size;
/******************************************************************
* Marshal data into message.
*****************************************************************/
memcpy(rmsg->m_data, (char *) &hello_msg, sizeof(hello_msg));
fill_data(rmsg->m_data +
sizeof(hello_msg) - sizeof(hello_msg.hm_data_size),
size - sizeof(hello_msg) + sizeof(hello_msg.hm_data));
INKDebug(PLUGIN_DEBUG_TAG,
"Sending hello to [%u.%u.%u.%u] instance %d bytes %d\n",
DOT_SEPARATED(in.s_addr), hello_msg.hm_instance, size);
ret = INKSendClusterRPC(&nodes[n], rmsg);
if (ret) {
INKDebug(PLUGIN_DEBUG_ERR_TAG, "INKSendClusterRPC failed\n");
}
}
}
periodic_event_action = INKContSchedule(periodic_event_cont, (1 * 1000) /* 1 sec */ );
return 0;
}
map_tab::map_tab(QWidget *parent) :
QWidget(parent),
ui(new Ui::map_tab),
_data_loading(true)
{
std::cout << ">>>>>>>>>>>>> DEBUG#1 <<<<<<<<<<<<<<<" << std::endl;
ui->setupUi(this);
fill_data();
ui->editArea->repaint();
QObject::connect(ui->pallete, SIGNAL(signalPalleteChanged()), ui->editArea, SLOT(repaint()));
}
TabAnimation::TabAnimation(QWidget *parent) :
QWidget(parent),
ui(new Ui::TabAnimation)
{
ui->setupUi(this);
fill_data();
QObject::connect(ui->widget, SIGNAL(on_image_w_changed(int)), this, SLOT(change_w(int)));
QObject::connect(ui->widget, SIGNAL(on_image_h_changed(int)), this, SLOT(change_h(int)));
}
void fill_mlx_struct(unsigned char *image,
struct jpeg_decompress_struct *cinfo,
t_image *mlx_img_struct, void *mlx_ptr)
{
mlx_img_struct->bpp = 10;
mlx_img_struct->ptr = mlx_new_image(mlx_ptr, cinfo->image_width,
cinfo->image_height);
mlx_img_struct->data = mlx_get_data_addr \
(mlx_img_struct->ptr, &mlx_img_struct->bpp, &mlx_img_struct->sizeline,
&mlx_img_struct->endian);
fill_data(cinfo, mlx_img_struct, image);
mlx_img_struct->size[0] = cinfo->image_width;
mlx_img_struct->size[1] = cinfo->image_height;
}
int Message::encode(uint8_t* buffer, size_t len) {
if (len < 6) return -1;
int data_len = fill_data(buffer+5, len-6);
if (data_len < 0) return -1;
buffer[0] = start_delim;
buffer[1] = data_len + 5;
buffer[2] = _type;
buffer[3] = src();
buffer[4] = dst();
uint8_t checksum = 0xFF;
for(int i = 1; i < data_len+5; ++i) {
checksum -= buffer[i];
}
buffer[data_len+5] = checksum;
return data_len+6;
}
TabScenelist::TabScenelist(QWidget *parent) : QDialog(parent), ui(new Ui::ScenesList), model_scenes(this)
{
ui->setupUi(this);
ui->object_listView->setModel(&model_objects);
ui->scenes_tableView->setModel(&model_scenes);
ComboBoxDelegate* delegate = new ComboBoxDelegate(this);
ui->scenes_tableView->setItemDelegateForColumn(2, delegate);
/// @TODO: find a way that works for both Qt4 and 5 - http://stackoverflow.com/questions/17535563/how-to-get-a-qtableview-to-fill-100-of-the-width
//ui->scenes_tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch); // Qt5
//ui->scenes_tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch); // Qt4
data_loading = true;
ScenesMediator::get_instance()->scenes_list = fio.load_scenes();
fill_data();
data_loading = false;
}
// search the interval [center-radius, center+radius] for the std::sort
// threshold that yields the best run-time when sorting as much data as `data'
// contains.
size_t find_threshold(size_t center, size_t radius, std::vector<test_t> & data) {
size_t inc = radius/4;
size_t lo = (center > radius) ? (center-radius) : 0;
size_t hi = lo + 2*radius;
size_t best = 0;
double besttime = std::numeric_limits<double>::max();
for (size_t attempt = lo; attempt <= hi; attempt += inc) {
sort_timer * t = get_sort_timer(attempt);
fill_data(data);
std::cout << attempt << ' ' << std::flush;
double dur = t->run(data);
std::cout << dur << std::endl;
if (attempt == lo || dur < besttime) {
best = attempt;
besttime = dur;
}
}
std::cout << "Chose " << best << std::endl;
return best;
}
void Query::init_data()
{
QString sql;
QSqlQuery query;
for (int t = 0; t < TABLESIZE; t++) {
sql = "select number, " + table.all_column_str(t) + " from " + table.get_table_str(t);
//qDebug() << sql;
query.exec(sql);
while (query.next()) {
QString number = query.value(0).toString().toUpper();
int ind = get_value_by_key(people_map, number);
if (ind != -1) {
People *p = &people[ind];
fill_data(query, p, t);
} else {
//qDebug() << "找不到军人 " << number;
}
}
}
}
int main(int argc, const char **argv)
{
qeo_factory_t *factory;
qeocore_reader_t *reader;
qeocore_writer_t *writer;
qeocore_type_t *type;
qeocore_data_t *rdata, *wdata;
int i;
for (i = 0; i < 2; i++) {
/* initialize */
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(factory);
assert(NULL != (type = nested_type_get(1, 0, 0)));
assert(QEO_OK == qeocore_type_register(factory, type, "nested"));
assert(NULL != (reader = qeocore_reader_open(factory, type, NULL,
QEOCORE_EFLAG_STATE_UPDATE | QEOCORE_EFLAG_ENABLE, NULL, NULL)));
assert(NULL != (writer = qeocore_writer_open(factory, type, NULL,
QEOCORE_EFLAG_STATE_UPDATE | QEOCORE_EFLAG_ENABLE, NULL, NULL)));
/* write */
assert(NULL != (wdata = qeocore_writer_data_new(writer)));
fill_data(wdata);
assert(QEO_OK == qeocore_writer_write(writer, wdata));
/* check data */
assert(NULL != (rdata = qeocore_reader_data_new(reader)));
assert(QEO_OK == qeocore_reader_read(reader, NULL, rdata));
expected_status = QEOCORE_DATA;
validate_data(rdata);
/* remove */
assert(QEO_OK == qeocore_writer_remove(writer, wdata));
/* clean up */
qeocore_data_free(wdata);
qeocore_data_free(rdata);
qeocore_writer_close(writer);
qeocore_reader_close(reader);
qeocore_type_free(type);
qeocore_factory_close(factory);
}
}
void dlm_timeout_warn(struct dlm_lkb *lkb)
{
struct sk_buff *uninitialized_var(send_skb);
struct dlm_lock_data *data;
size_t size;
int rv;
size = nla_total_size(sizeof(struct dlm_lock_data)) +
nla_total_size(0); /* why this? */
rv = prepare_data(DLM_CMD_TIMEOUT, &send_skb, size);
if (rv < 0)
return;
data = mk_data(send_skb);
if (!data) {
nlmsg_free(send_skb);
return;
}
fill_data(data, lkb);
send_data(send_skb);
}
void TabAnimation::reload()
{
fill_data();
}
void TabText::reload()
{
fill_data();
}
void get_good_entity(t_trame *trame, t_id_req *id_req, t_game_info_scale *save, t_game_info_scale *select,
t_info_scale *sel, int app)
{
char *tmp;
int i;
int d;
int flag_sel;
int flag_att;
t_req_info_scale scale;
t_game_select_move dest;
char *attack;
int len;
int c;
flag_sel = 0;
flag_att = 0;
memcpy(&scale, trame->msg, trame->len);
tmp = fill_data(sizeof(int), (char*)&id_req->select);
len = sizeof(int);
attack = fill_data(sizeof(int), (char*)&id_req->attac);
for (i = 0; i < (int)scale.nb_ent; i++)
{
for (c = 0; c <= FW_MAX_SELECT - 1 && sel[c].id != -1; c++)
;
for (d = 0; d <= FW_MAX_SELECT - 1; d++)
if (select[d].id_req == scale.id_req)
{
memcpy(&(sel[c]), &scale.ent[i], sizeof(scale.ent[i]));
select[d].id_req = -1;
c++;
flag_sel = 1;
break;
}
for (d = 0; d < MAX_SAVE_EVENTS; d++)
if (save[d].id_req == scale.id_req)
{
attack = add_to_data(sizeof(int), (char*)attack,
sizeof(scale.ent[i].id), (char*)&scale.ent[i].id);
flag_att = 1;
break;
}
if (d == MAX_SAVE_EVENTS && flag_sel != 1)
{
memcpy(&(sel[c]), &scale.ent[i], sizeof(scale.ent[i]));
flag_sel = 1;
}
}
if (flag_sel == 1)
{
for (c = 0; c <= FW_MAX_SELECT - 1 && sel[c].id != -1; c++)
{
;
tmp = add_to_data(len, (char*)tmp,
sizeof(sel[c].id), (char*)&sel[c].id);
len += sizeof(sel[c].id);
}
stock_msg(&cnt->clients[0], TAG_SELECT, len
, (void*)tmp);
id_req->select++;
}
else if (flag_att == 1 && scale.ent[i - 1].app != app)
{
fprintf(stderr, "spy === %i\n", scale.ent[i].app);
stock_msg(&cnt->clients[0], TAG_SELECT_ATTACK, sizeof(int) + sizeof(scale.ent[i].id)
, (void*)attack);
id_req->attac++;
}
if (i == 0)
for (d = 0; d < MAX_SAVE_EVENTS; d++)
if (save[d].id_req == scale.id_req)
{
memcpy(&(dest), &save[d], sizeof(save[d]));
stock_msg(&cnt->clients[0], TAG_SELECT_MOVE, sizeof(dest)
, (void*)&dest);
}
free(tmp);
free(attack);
}
void TabSfx::reload()
{
fill_data();
}
