void frame_print(frame * i, int print_scope)
{
char *flags[] = {
"ASTERPEND_CONTINUE",
"ATPEND_CONTINUE",
"ARGUMENT",
"ELIPSIS_ARGUMENT",
"ELIPSIS_ASTERPEND_CONTINUE",
"ELIPSIS_ATPEND_CONTINUE",
"EVALUATE",
"CONTINUE",
"APPLY_FUNCTION",
"PREPARE_ARGUMENTS",
"PAUSE",
"HANDLE_SIGNALS"
};
printf(" --> ");
printf("%s, ", flags[i->flag]);
if (i->instruction)
oyster_print(i->instruction);
if (print_scope) {
printf("\n Scope:\n");
table_print(i->scope);
printf("Upcoming scope:\n");
table_print(i->scope_to_be);
}
printf("\n");
}
void
table_show(int ac, char *av[])
{
int nbytes, nalloc = 1024;
void *data = NULL;
NEXT_ARG;
if (isdigit(**av)) {
nbytes = nalloc;
while (nbytes >= nalloc) {
nalloc = nalloc * 2 + 256;
nbytes = nalloc;
if (data == NULL) {
if ((data = malloc(nbytes)) == NULL) {
err(EX_OSERR, "malloc");
}
} else if ((data = realloc(data, nbytes)) == NULL) {
err(EX_OSERR, "realloc");
}
/* store table id in the header of data */
int *head = (int *)data;
*head = atoi(*av);
if (*head < 0 || *head > IPFW_TABLES_MAX - 1)
errx(EX_USAGE, "table id `%d' invalid", *head);
if (do_get_x(IP_FW_TABLE_SHOW, data, &nbytes) < 0)
err(EX_OSERR, "do_get_x(IP_FW_TABLE_LIST)");
struct ipfw_ioc_table *tbl;
tbl = (struct ipfw_ioc_table *)data;
table_print(tbl);
}
} else {
errx(EX_USAGE, "ipfw3 table `%s' show invalid", *av);
}
}
int main (int argc, char *argv[]) {
if (argc != 2) {
usage();
exit(1);
}
char *infile = argv[1];
TreeNode *tree = huffman_build_tree(infile);
if (tree == NULL) {
printf("Could not build the tree!");
usage();
exit(1);
}
EncodeTable *etab = table_build(tree);
if (etab == NULL) {
printf("Could not build the table!");
usage();
exit(1);
}
table_print(etab);
table_free(etab);
tree_free(tree);
return 0;
}
// reg_get - returns the register to be used
reg* reg_get(){
reg* res;
reg* aux;
int max=-1;
if(registers==NULL || registers->length<1)
return NULL;
if(registers->free){
// pop free register
res=registers->first;
while(res!=NULL && !strequal(res->next->name, "r0")){
if(res->free==true) break;
res=res->next;
}
registers->free--;
} else {
// findMaxNext
res=(registers->first);
aux=(registers->first);
while(aux!=NULL && !strequal(aux->next->name, "r0")){
if(((aux->dist<0) || (aux->dist)>max) && aux->dirty){
max=aux->dist;
res=aux;
}
aux=aux->next;
}
// recheck
if(res==NULL){
// for(...) check if is dirty, then do it.
for(aux=(registers->first); aux!=NULL; aux=aux->next){
if(aux->dirty && !strequal(aux->next->name, "r0")){
max=aux->dist;
res=aux;
}
}
}
}
res->dirty=false;
#ifdef VERBOSE
printf(" [reg_get] returning ");
if(res!=NULL)
printf(" '%s'\n", res->name);
else {
printf(" null\n");
table_print(registers);
}
#endif
return res;
}
/*
* Main function
*/
main(int argc, char *argv[]) {
char *buf;
pmacnet_init();
pmacnet_collect();
if (argc > 1)
buf = table_outtable(pmacnet_tab);
else
buf = table_print(pmacnet_tab);
puts(buf);
nfree(buf);
table_destroy(pmacnet_tab);
exit(0);
}
/*
* Main function
*/
main(int argc, char *argv[]) {
char *buf;
plinnames_init();
plinnames_collect();
if (argc > 1)
buf = table_outtable(tab);
else
buf = table_print(tab);
puts(buf);
nfree(buf);
table_destroy(tab);
exit(0);
}
int main(int argc, char **argv)
{
TABLE tab1;
char *buf1;
iiab_start("", argc, argv, "", test_cf);
tab1 = cf_getstatus(iiab_cf);
buf1 = table_print(tab1);
printf("%s\n", buf1);
nfree(buf1);
table_destroy(tab1);
iiab_stop();
exit(0);
}
/*
* Main function
*/
main(int argc, char *argv[]) {
char *buf;
iiab_start("", argc, argv, "", NULL);
plinps_init();
plinps_collect();
if (argc > 1)
buf = table_outtable(plinps_tab);
else
buf = table_print(plinps_tab);
if (buf)
puts(buf);
else
elog_die(FATAL, "plinps", 0, "no output produced");
nfree(buf);
table_destroy(plinps_tab);
plinps_fini();
iiab_stop();
exit(0);
}
void machine_print(machine * m)
{
frame *f = m->current_frame;
printf("Now: ");
frame_print(m->now, 0);
if (m->now->instruction && !table_empty(oyster_bindings(m->now->instruction))) {
printf(" with the bindings: \n");
table_print(oyster_bindings(m->now->instruction));
}
while (f) {
printf("frame: ");
frame_print(f, 0);
f = f->below;
}
if (m->accumulator) {
printf("accum: ");
oyster_print(m->accumulator);
}
printf
("\n--- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n\n\n\n");
}
struct symbol *gen_para_regs (struct symbol *parameters)
{
char *registers[6] = {"rdi", "rsi", "rdx", "rcx", "r8", "r9"};
int i=0;
struct symbol *para_start = parameters;
while (parameters != NULL) {
if (i > 5) {
not_supported ("more than 6 function parameters\n");
}
parameters->reg = strdup (registers[i++]);
parameters = parameters->next;
}
#ifdef MY_DEBUG
printf ("#-- ASSIGNING PARAMETER REGISTERS\n");
table_print (para_start);
printf ("\n");
#endif
return para_start;
}
int main()
{
#ifdef DEBUG
logfile_create("stdout", 3);
#endif
HashTable* ht;
char key[64];
int valuesize = 8;
char val[64];
unsigned int attrformat[3] = {4, 3, 1};
unsigned int attrarray[3][3] = { {8, 3, 1}, { 7, 2,1}, {6, 2, 1} };
int num = 200;
int attrnum = 3;
int ret;
int i = 0;
char *name = "test";
char *conffile;
conffile = "memlink.conf";
DINFO("config file: %s\n", conffile);
myconfig_create(conffile);
my_runtime_create_common("memlink");
ht = g_runtime->ht;
ret = hashtable_create_table(ht, name, valuesize, attrformat, attrnum,
MEMLINK_LIST, MEMLINK_VALUE_STRING);
if (ret != MEMLINK_OK) {
DERROR("create table error:%d\n", ret);
return -1;
}
Table *tb = hashtable_find_table(ht, name);
///////////begin test;
//test1 : hashtable_add_info_attr - create key
for (i = 0; i < num; i++) {
sprintf(key, "heihei%03d", i);
table_create_node(tb, key);
}
for (i = 0; i < num; i++) {
sprintf(key, "heihei%03d", i);
HashNode* pNode = table_find(tb, key);
if (NULL == pNode) {
DERROR("table_find error. can not find %s\n", key);
return -1;
}
}
//test : hashtable_add_attr insert num value
DINFO("1 insert 1000 \n");
int pos = 0;
HashNode *node = NULL;
DataBlock *dbk = NULL;
char *item = NULL;
num = 200;
for (i = 0; i < num; i++) {
sprintf(val, "value%03d", i);
pos = i;
ret = hashtable_insert(ht, name, key, val, attrarray[i%3], 3, pos);
if (ret < 0) {
DERROR("hashtable_add_attr err! ret:%d, val:%s, pos:%d \n", ret, val, pos);
return ret;
}
}
DINFO("2 insert %d\n", num);
MemLinkStat stat;
ret = hashtable_stat(ht, name, key, &stat);
if (ret != MEMLINK_OK) {
DERROR("stat error!\n");
}
DINFO("blocks:%d, data_used:%d\n", stat.blocks, stat.data_used);
for (i = 0; i < num; i++) {
sprintf(val, "value%03d", i);
ret = table_find_value(tb, key, val, &node, &dbk, &item);
if (ret < 0) {
DERROR("not found value: %d, %s\n", ret, val);
return ret;
}
}
//hashtable_print(g_runtime->ht, key);
sprintf(val, "value%03d", 50);
ret = hashtable_del(ht, name, key, val);
if (ret < 0) {
DERROR("del value: %d, %s\n", ret, val);
return ret;
}
DINFO("deleted %s\n", val);
table_print(tb, key);
ret = table_find_value(tb, key, val, &node, &dbk, &item);
if (ret >= 0) {
DERROR("found value: %d, %s\n", ret, val);
return ret;
}
ret = hashtable_insert(ht, name, key, val, attrarray[2], attrnum, 100);
if (ret < 0) {
DERROR("add value err: %d, %s\n", ret, val);
return ret;
}
ret = table_find_value(tb, key, val, &node, &dbk, &item);
if (ret < 0) {
DERROR("not found value: %d, %s\n", ret, val);
return ret;
}
DINFO("test: insert ok!\n");
table_print(tb, key);
/////////// hashtable_del
for (i = 0; i < num; i++) {
sprintf(val, "value%03d", i);
//pos = i;
ret = hashtable_del(ht, name, key, val);
if (ret < 0) {
DERROR("hashtable_del err! ret:%d, val:%s \n", ret, val);
return ret;
}
}
DINFO("del %d!\n", num);
for (i = 0; i < num; i++) {
sprintf(val, "value%03d", i);
ret = table_find_value(tb, key, val, &node, &dbk, &item);
if (ret >= 0) {
DERROR("err should not found value: %d, %s\n", ret, key);
return ret;
}
}
DINFO("test: del ok!\n");
return 0;
}
int main(int c, char * argv[]){
char *player_name = (char*)malloc(sizeof(char) * 50);
int n_players;
int starting_amount;
int limit;
int check = 1;
Table *table;
srand(time(NULL));
printf("Welcome to Poker! What's your name?\n");
while(check){
scanf("%[^\n]s", player_name);
if(strlen(player_name)>0){
check = 0;
}
else
printf("Player name must be more than 0 characters.\n");
}
check = 1;
user_letter();
printf("Choose between 2 and 4 players (including yourself).\n");
while(check){
n_players = user_letter();
if(n_players != '2' && n_players != '3' && n_players != '4'){
printf("Must select between 2 and 4 players\n");
}
else
check = 0;
}
if(n_players == '2')
n_players = 2;
if(n_players == '3')
n_players = 3;
if(n_players == '4')
n_players = 4;
check = 1;
printf("\n");
printf("Please choose the amount each player will begin with and the limit for each bet.\n");
printf("Note: Limits must be less than starting amounts and starting amounts should be a\n");
printf("\tmultiple of the limit.\n\n");
while(check){
printf("Starting Amount: (recommended value 100)\n");
scanf("%d", &starting_amount);
printf("Limit: (recommended value 5)\n");
scanf("%d", &limit);
if(starting_amount < limit){
printf("Limit is greater than starting amount.\n\n");
}
else if(starting_amount % limit != 0){
printf("Starting amount should be a multiple of limit.\n\n");
}
else{
check = 0;
}
}
printf("Thanks %s! Initializing your game now!\n\n", player_name);
table = init_table(player_name, n_players, limit, starting_amount, 100000);
while(table->n_players > 1){
table->deck->shuffle(table->deck);
printf("Press Enter to Begin Next Hand");
user_letter();
printf("\n**********************************************************************************\n");
printf("\nBeginning New Hand\n\n");
printf("Current Standings:\n\n");
table_print(table, 0);
printf("\n**********************************************************************************\n");
printf("\n");
sleep(WAIT);
table_unfold(table);
table_deal(table);
printf("Collecting Antes\n\n");
table_ante(table);
sleep(WAIT);
printf("\n**********************************************************************************\n\n");
printf("Beginning First Round of Betting\n");
table_bet(table);
if(table->players_n_folded > 1){
printf("\n**********************************************************************************\n");
printf("\nExchanging Cards...\n\n");
table_new_cards(table);
printf("\n**********************************************************************************\n");
printf("\nBeginning Second Round of Betting\n\n");
table_bet(table);
}
printf("\n**********************************************************************************\n");
printf("\nAll rounds of betting are complete. Revealing final hands\n\n");
sleep(2);
table_print(table, 1);
table_winner(table);
printf("\n**********************************************************************************\n");
table_return_cards(table);
table_shift(table);
table_remove_players(table);
}
printf("%s has won the game!\n\n", table->players[0]->name);
return 0;
}
int main() {
int i;
struct timespec start, end, diff[8];
table* t;
int widths[] = { 20, 20, 20 };
machine* server;
half_long_string hl_str;
config_server();
deploy(machines[0], "./rpc_times_server");
deploy(machines[2], "./rpc_times_server");
deploy(machines[3], "./rpc_times_server");
sleep(5);
// 1028 bytes arg
for (i = 0; i < 1024; i++) {
hl_str.str1[i] = 65 + i % 26;
hl_str.str2[i] = 65 + i % 26;
}
{
// Local call 4 bytes
printf("Calling Local (no RPC): 4 bytes");
fflush(stdout);
clock_gettime(CLOCK_REALTIME, &start);
local_call_4(1000);
clock_gettime(CLOCK_REALTIME, &end);
diff[0].tv_nsec = end.tv_nsec - start.tv_nsec;
diff[0].tv_sec = end.tv_sec - start.tv_sec;
// Local call 2048 bytes
printf(", 2048 bytes\t\tOK\n");
clock_gettime(CLOCK_REALTIME, &start);
local_call_2048(hl_str);
clock_gettime(CLOCK_REALTIME, &end);
diff[1].tv_nsec = end.tv_nsec - start.tv_nsec;
diff[1].tv_sec = end.tv_sec - start.tv_sec;
}
{
server = machines[4];
// Remote call 4 bytes
printf("Calling Local RPC: 4 bytes");
clock_gettime(CLOCK_REALTIME, &start);
rpc_call_4(server->ip, 1000);
clock_gettime(CLOCK_REALTIME, &end);
diff[2].tv_nsec = end.tv_nsec - start.tv_nsec;
diff[2].tv_sec = end.tv_sec - start.tv_sec;
// Remote call 2048 bytes
printf(", 2048 bytes\t\tOK\n");
clock_gettime(CLOCK_REALTIME, &start);
rpc_call_2048(server->ip, hl_str);
clock_gettime(CLOCK_REALTIME, &end);
diff[3].tv_nsec = end.tv_nsec - start.tv_nsec;
diff[3].tv_sec = end.tv_sec - start.tv_sec;
}
{
server = machines[2];
// Remote call 4 bytes (Remote: Fedora)
printf("Calling Remote Homogeneous: 4 bytes");
clock_gettime(CLOCK_REALTIME, &start);
rpc_call_4(server->ip, 1000);
clock_gettime(CLOCK_REALTIME, &end);
diff[4].tv_nsec = end.tv_nsec - start.tv_nsec;
diff[4].tv_sec = end.tv_sec - start.tv_sec;
// Remote call 2048 bytes (Remote: Fedora)
printf(", 2048 bytes\t\tOK\n");
clock_gettime(CLOCK_REALTIME, &start);
rpc_call_2048(server->ip, hl_str);
clock_gettime(CLOCK_REALTIME, &end);
diff[5].tv_nsec = end.tv_nsec - start.tv_nsec;
diff[5].tv_sec = end.tv_sec - start.tv_sec;
}
{
server = machines[2];
// Remote call 4 bytes (Remote: Alpha)
printf("Calling Remote heterogeneous: 4 bytes");
clock_gettime(CLOCK_REALTIME, &start);
rpc_call_4(server->ip, 1000);
clock_gettime(CLOCK_REALTIME, &end);
diff[6].tv_nsec = end.tv_nsec - start.tv_nsec;
diff[6].tv_sec = end.tv_sec - start.tv_sec;
// Remote call 2048 bytes (Remote: Alpha)
printf(", 2048 bytes\t\tOK\n");
clock_gettime(CLOCK_REALTIME, &start);
rpc_call_2048(server->ip, hl_str);
clock_gettime(CLOCK_REALTIME, &end);
diff[7].tv_nsec = end.tv_nsec - start.tv_nsec;
diff[7].tv_sec = end.tv_sec - start.tv_sec;
}
printf("\nResultados\n");
printf("==========\n");
// Initialize table
t = table_initialize(3, widths);
// Write row data
table_add_row(t);
table_add_data(t, 0, 0, "");
table_add_data(t, 0, 1, "4b in, 4b out");
table_add_data(t, 0, 2, "2x1024 in, 2048 out");
// Write row data
table_add_row(t);
table_add_data(t, 1, 0, "Local call");
table_add_data(t, 1, 1, "%lis %09li ns", diff[0].tv_sec, diff[0].tv_nsec);
table_add_data(t, 1, 2, "%lis %09li ns", diff[1].tv_sec, diff[1].tv_nsec);
// Write row data
table_add_row(t);
table_add_data(t, 2, 0, "RPC (local)");
table_add_data(t, 2, 1, "%lis %09li ns", diff[2].tv_sec, diff[2].tv_nsec);
table_add_data(t, 2, 2, "%lis %09li ns", diff[3].tv_sec, diff[3].tv_nsec);
// Write row data
table_add_row(t);
table_add_data(t, 3, 0, "RPC (remota)");
table_add_data(t, 3, 1, "%lis %09li ns", diff[4].tv_sec, diff[4].tv_nsec);
table_add_data(t, 3, 2, "%lis %09li ns", diff[5].tv_sec, diff[5].tv_nsec);
// Write row data
table_add_row(t);
table_add_data(t, 4, 0, "RPC (hetero)");
table_add_data(t, 4, 1, "%lis %09li ns", diff[6].tv_sec, diff[6].tv_nsec);
table_add_data(t, 4, 2, "%lis %09li ns", diff[7].tv_sec, diff[7].tv_nsec);
// Print table
table_print(t);
return 0;
}
int main(void)
{
Table *table = table_create();
printf("-------------------------------------------\n");
printf("Commands:\n");
printf("a <key> <value> - push to table\n");
printf("d <key> - delete from table\n");
printf("s - sort table\n");
printf("p - print table\n");
printf("f <key> - find element by key\n");
printf("c - clear table\n");
printf("q - exit\n");
printf("-------------------------------------------\n");
size_t cnt = 0;
char last_cmd = '\n';
while (true) {
if (!cnt || last_cmd == '\n')
printf("> ");
char cmd;
bool is_finished = false;
scanf("%c", &cmd);
size_t pos;
//LinearlistElement *this = NULL;
Key *key = key_create();
switch (cmd) {
case 'q':
is_finished = true;
break;
case 'a':
table_push(table);
break;
case 'd':
//scanf("%d", &pos);
key_set_value_from_input(key);
table_note_delete(table, key);
break;
case 's':
table_sort(table);
break;
case 'p':
table_print(table);
break;
case 'c':
table_clear(table);
break;
case 'f':
key_set_value_from_input(key);
Note *found = table_search(table, key, &pos);
if (found == NULL) {
printf("There are no notes with this key in the table\n");
break;
}
note_print(table, found);
break;
case '\n':
break;
default:
printf("Invalid command `%c`\n", cmd);
break;
}
last_cmd = cmd;
key_destroy(&key);
if (is_finished) break;
cnt++;
cnt %= 2;
//printf("First: %lld\n", (long long) linearlist_get_value(linearlist_get_first(linearlist)));
//printf("Last: %lld\n", (long long) linearlist_get_value(linearlist_get_last(linearlist)));
}
printf("Goodbye!\n");
table_destroy(&table);
return 0;
}
//Функция формирует данные для таблицы и выводит данные на экран
state print_records(void* data, void* param)
{
//Данные для вывода
phonebook_item_t** phonebook = (phonebook_item_t**)data;
size_t* count = (size_t*)param;
size_t i;
table_t* table = table_create(0, *count);
//Выделяем память под колонки
size_t* n = (size_t*)calloc(*count, sizeof(size_t));
char** last_names = (char**) calloc(*count, sizeof(char**));
char** first_names = (char**) calloc(*count, sizeof(char**));
char** patronymics = (char**) calloc(*count, sizeof(char**));
char** streets = (char**) calloc(*count, sizeof(char**));
char** blds = (char**) calloc(*count, sizeof(char**));
char** aps = (char**) calloc(*count, sizeof(char**));
char** phones = (char**) calloc(*count, sizeof(char**));
//Добавляем колонки в таблицу
table_add_column(table, Rus("№"), n, INTEGER,0, 5);
table_add_column(table, Rus("ФАМИЛИЯ"), last_names, STRING, 5, 0);
table_add_column(table, Rus("ИМЯ"), first_names,STRING, 5, 0);
table_add_column(table, Rus("ОТЧЕСТВО"),patronymics,STRING, 5, 0);
table_add_column(table, Rus("УЛИЦА"), streets, STRING, 5, 0);
table_add_column(table, Rus("ДОМ"), blds, STRING, 3, 6);
table_add_column(table, Rus("КВ."), aps, STRING, 3, 6);
table_add_column(table, Rus("ТЕЛЕФОН"), phones, STRING, 6, 7);
//Заполняем колонки данными
for (i = 0; i < *count; ++i)
{
*(n + i) = (*phonebook + i)->id;
*(last_names + i) = (*phonebook + i)->last_name;
*(first_names + i) = (*phonebook + i)->first_name;
*(patronymics + i) = (*phonebook + i)->patronymic;
*(streets + i) = (*phonebook + i)->street;
*(blds + i) = (*phonebook + i)->bld;
*(aps + i) = (*phonebook + i)->ap;
*(phones + i) = (*phonebook + i)->phone;
}
//Получаем ширину консоли
size_t sreen_width;
CONSOLE_SCREEN_BUFFER_INFO csbi;
int ret;
ret = GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
if (ret)
{
sreen_width = csbi.dwSize.X - 4;
} else {
sreen_width = 110;
}
//Выводим таблицу
table_print(table, sreen_width);
//Освобождаем память
free(n);
free(last_names);
free(first_names);
free(patronymics);
free(streets);
free(blds);
free(aps);
free(phones);
free(table);
system("pause");
return REDRAW;
}
IMAGE *process_pipeline(IMAGE *image){
if(!image){
/// "Не задано входное изображение"
ERRX(_("No input image given"));
}
if(!farray || !farray_size){
/// "Не заданы параметры конвейера"
WARNX(_("No pipeline parameters given"));
}
size_t i;
Filter **far = farray;
IMAGE *in = copyFITS(image); // copy original image to leave it unchanged
IMAGE *processed = NULL;
for(i = 0; i < farray_size; ++i, ++far){
Filter *f = *far;
DBG("Got filter #%d: w=%d, h=%d, sx=%g, sy=%g\n", f->FilterType,
f->w, f->h, f->sx, f->sy);
printf("try filter %zd\n", i);
Itmarray oarg = {NULL, 0};
processed = f->imfunc(in, f, &oarg);
/// "Ошибка в обработке конвейера"
if(!processed) ERRX(_("Error on pipeline processing!"));
// TODO: what should I do with oarg???
if(oarg.size){
size_t i, l = oarg.size;
//if(verbose_level){
green("got oarg: \n");
for(i = 0; i < l; ++i){
printf("%5zd: %g\n", i, oarg.data[i]);
}
//}
char tabname[80];
snprintf(tabname, 80, "%s_CONVERSION", f->name);
FITStable *tab = table_new(processed, tabname);
if(tab){
table_column col = {
.width = sizeof(int32_t),
.repeat = l,
.coltype = TINT
};
int32_t *levls = MALLOC(int32_t, l);
for(i = 0; i < l; ++i) levls[i] = (int32_t) i;
col.contents = levls;
sprintf(col.colname, "level");
*col.unit = 0;
table_addcolumn(tab, &col);
FREE(levls);
col.contents = oarg.data;
col.coltype = TDOUBLE;
col.width = sizeof(double),
sprintf(col.colname, "value");
sprintf(col.unit, "ADU");
table_addcolumn(tab, &col);
printf("Create table:\n");
table_print(tab);
}
FREE(oarg.data);
}
processed->keylist = in->keylist;
char changes[FLEN_CARD];
snprintf(changes, FLEN_CARD, "HISTORY modified by routine %s", f->name);
list_add_record(&(processed->keylist), changes);
//list_print(processed->keylist);
in->keylist = NULL; // prevent deleting global keylist
imfree(&in);
in = processed;
}
return processed;
}
void table_print_all(IMAGE *img){
if(!img->tables || img->tables->amount < 1) return;
size_t i, N = img->tables->amount;
for(i = 0; i < N; ++i)
table_print(img->tables->tables[i]);
}
static int list_images(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
_cleanup_(table_unrefp) Table *table = NULL;
int r;
r = acquire_bus(&bus);
if (r < 0)
return r;
r = sd_bus_call_method(
bus,
"org.freedesktop.portable1",
"/org/freedesktop/portable1",
"org.freedesktop.portable1.Manager",
"ListImages",
&error,
&reply,
NULL);
if (r < 0)
return log_error_errno(r, "Failed to list images: %s", bus_error_message(&error, r));
table = table_new("name", "type", "ro", "crtime", "mtime", "usage", "state");
if (!table)
return log_oom();
r = sd_bus_message_enter_container(reply, 'a', "(ssbtttso)");
if (r < 0)
return bus_log_parse_error(r);
for (;;) {
const char *name, *type, *state;
uint64_t crtime, mtime, usage;
TableCell *cell;
bool ro_bool;
int ro_int;
r = sd_bus_message_read(reply, "(ssbtttso)", &name, &type, &ro_int, &crtime, &mtime, &usage, &state, NULL);
if (r < 0)
return bus_log_parse_error(r);
if (r == 0)
break;
r = table_add_many(table,
TABLE_STRING, name,
TABLE_STRING, type);
if (r < 0)
return log_error_errno(r, "Failed to add row to table: %m");
ro_bool = ro_int;
r = table_add_cell(table, &cell, TABLE_BOOLEAN, &ro_bool);
if (r < 0)
return log_error_errno(r, "Failed to add row to table: %m");
if (ro_bool) {
r = table_set_color(table, cell, ansi_highlight_red());
if (r < 0)
return log_error_errno(r, "Failed to set table cell color: %m");
}
r = table_add_many(table,
TABLE_TIMESTAMP, crtime,
TABLE_TIMESTAMP, mtime,
TABLE_SIZE, usage);
if (r < 0)
return log_error_errno(r, "Failed to add row to table: %m");
r = table_add_cell(table, &cell, TABLE_STRING, state);
if (r < 0)
return log_error_errno(r, "Failed to add row to table: %m");
if (!streq(state, "detached")) {
r = table_set_color(table, cell, ansi_highlight_green());
if (r < 0)
return log_error_errno(r, "Failed to set table cell color: %m");
}
}
r = sd_bus_message_exit_container(reply);
if (r < 0)
return bus_log_parse_error(r);
if (table_get_rows(table) > 1) {
r = table_set_sort(table, (size_t) 0, (size_t) -1);
if (r < 0)
return log_error_errno(r, "Failed to sort table: %m");
table_set_header(table, arg_legend);
r = table_print(table, NULL);
if (r < 0)
return log_error_errno(r, "Failed to show table: %m");
}
if (arg_legend) {
if (table_get_rows(table) > 1)
printf("\n%zu images listed.\n", table_get_rows(table) - 1);
else
printf("No images.\n");
}
return 0;
}
/* ------------------------------------------------------------------------------------------ */
void checkInstruction(ins *p){
reg *rz=NULL;
reg *rx=NULL;
reg *ry=NULL;
reg *rt=NULL; // temporary register (may or not be used)
ins *ip=NULL; // auxiliary instruction pointer (for other registers)
ins *ti=NULL; // temporary instruction pointer (to be used with the temporary register)
ins *mi=NULL; // main instruction pointer (used with the final instruction)
/*
* >> input: rz = rx <op> ry
*
*
* rx = ARP + lookup(rx->value)
* rx = * rx
* ry = ARP + lookup(ry->value)
* ry = * ry
* rt = rx <op> ry
* rz = ARP + lookup(rz->value)
* *rz = rt
*/
if(p == NULL)
return;
#ifdef VERBOSE
printf("\n");
table_print(registers);
printf("[checkInstruction] ");
printInstruction(p);
#endif
// :: -------------------------------- :: THE ALGORITHM ::
// 1st step: ensure that 'rx' and 'ry' have register
// --
// checking 'rx'
if((p->src1[0] != '\0') && !isNumeric(p->src1)){
rx=reg_search(p->src1);
if(rx==NULL){
// allocates register
rx=reg_ensure(p->src1);
if(isVar(p->src1)){
// loading the local variable from memory
load(p->src1);
ip = createInstruction(idx++);
copy(ip->dst, rx->name);
ip->arp=true;
ip->offset=lookup(p->src1);
append(ip);
ip = createInstruction(idx++);
copy(ip->dst, rx->name);
ip->ops1='*';
copy(ip->src1, rx->name);
append(ip);
}
if(rx!=NULL){
// set properties for register
rx->dist=distance(p, rx->value);
rx->dirty=false;
}
}
} else rx=NULL;
// checking 'ry'
if((p->src2[0] != '\0') && !isNumeric(p->src2)){
ry=reg_search(p->src2);
if(ry==NULL){
// allocates register
ry=reg_ensure(p->src2);
if(isVar(p->src2)){
// loading the local variable 'ry' from memory
load(p->src2);
// loading the local variable 'ry' from memory
ip = createInstruction(idx++);
copy(ip->dst, ry->name);
ip->arp=true;
ip->offset=lookup(p->src2);
append(ip);
ip = createInstruction(idx++);
copy(ip->dst, ry->name);
ip->ops1='*';
copy(ip->src1, ry->name);
append(ip);
}
if(ry!=NULL){
// set properties for register
ry->dist=distance(p, ry->value);
ry->dirty=true;
}
}
} else ry=NULL;
// 2nd step: allocate the 'rt' temporary register; creates the 'ti' temporary instruction
// --
ti = createInstruction(idx++);
// get 'rx'
if(isNumeric(p->src1))
copy(ti->src1, p->src1); // found a constant
else if(rx!=NULL)
copy(ti->src1, rx->name); // got the 'rx'
// get the operator
ti->ops2=p->ops2;
// get 'ry'
if(isNumeric(p->src2))
copy(ti->src2, p->src2); // found a constant
else if(ry!=NULL)
copy(ti->src2, ry->name); // got the 'ry'
if((p->dst[0] != '\0') && !isNumeric(p->dst)){
// allocate the 'rt' register ("r0" by default)
rt=reg_search("store");
// rt=reg_get();
if(rt!=NULL)
rt->dirty=false;
} else rt=NULL; // this could lead to an error
if(rt!=NULL)
copy(ti->dst, rt->name);
append(ti);
// 3rd step: frees if possible frees 'rx' and 'ry'
// --
// free 'rx'
if((rx!=NULL) && (rx->dist==MAXDIST || rx->dist==-2))
reg_free(rx);
// free 'ry'
if((ry!=NULL) && (ry->dist==MAXDIST || ry->dist==-2))
reg_free(ry);
// 4th step: allocate the 'rz' register and create the main instruction 'mi'
// --
mi = createInstruction(idx++);
// allocate the 'rz' register
if((p->dst[0] != '\0') && !isNumeric(p->dst)){
// store
store(p->dst);
rz=reg_search(p->dst);
if(rz==NULL){
// allocates register
rz=reg_ensure(p->dst);
if(isVar(p->dst)){
// loads the local variable for store operation
ip = createInstruction(idx++);
copy(ip->dst, rz->name);
ip->arp=true;
ip->offset=lookup(p->dst);
append(ip);
}
if(rz!=NULL){
// set properties for register
rz->dist=distance(p, rz->value);
rz->dirty=false;
}
}
} else rz=NULL; // this would be an error
if(rz!=NULL)
copy(mi->dst, rz->name);
if(rt!=NULL)
copy(mi->src1, rt->name);
if(isVar(p->dst))
mi->opd='*';
append(mi);
// 5th step: frees 'rt'; if possible frees 'rz'
// --
#ifdef VERBOSE
if(rt!=NULL) printf(" [rt] store: %s :: (%s)\n", rt->name, rt->value);
else printf(" [rt] is null\n");
if(rz!=NULL) printf(" [rz] store: %s :: (%s)\n", rz->name, rz->value);
else printf(" [rz] is null\n");
#endif
// free 'rt'
if(rt!=NULL) reg_free(rt);
// free 'rz'
if((rz!=NULL) && (rz->dist==MAXDIST || rz->dist<0))
reg_free(rz);
// 6th step: set the dirty property for the registers
// --
// check 'rx'
if(rx!=NULL)
rx->dirty=true;
// check 'ry'
if(ry!=NULL)
ry->dirty=true;
// check 'rt'
if(rt!=NULL)
rt->dirty=true;
// check 'rz'
if(rz!=NULL)
rz->dirty=false;
// nota: um registo e' dirty apenas quando o seu conteudo e' manipulado na memoria !!!!
// (confirmar e corrigir se necessario o 6o passo)
// mudar os valores de dirty para oposto: 'false' <-> 'true'
// :: -------------------------------- :: THE END ::
#ifdef VERBOSE
table_print(registers);
printf("\n");
#endif
return;
}
