void fill_TABLES() {
struct hash * looked_up;
struct hash * row;
struct parser_generator * parser_generator = new_parser_generator();
append_to_list( parser_generator->TABLE, new_hash() );
append_to_list( parser_generator->GOTO, new_hash() );
add_initial_itemset( parser_generator );
struct list * itemsets = parser_generator->itemsets;
int i = 0;
while ( i < parser_generator->itemsets->next_index ) {
struct itemset * current_itemset = listlookup( itemsets, i );
looked_up = listlookup( parser_generator->TABLE, i );
if ( ! looked_up ) {
row = new_hash();
append_to_list( parser_generator->TABLE, row );
}
looked_up = listlookup( parser_generator->GOTO, i );
if ( ! looked_up ) {
row = new_hash();
append_to_list( parser_generator->GOTO, row );
}
install_incomplete_transitions( i, current_itemset, parser_generator );
install_complete_transitions( i, current_itemset, parser_generator );
i++;
}
TABLE = parser_generator->TABLE;
GOTO = parser_generator->GOTO;
}
int main(int argc, char *argv[])
{
struct list_node *my_list = NULL;
add_item_to_front_of_list(&my_list, "Calvin", "Spaceman Spiff");
add_item_to_front_of_list(&my_list, "Snoopy", "Red Baron");
append_to_list(&my_list, "Marty McFly", "Calvin Klien");
append_to_list(&my_list, "Clark Kent", "Superman");
append_to_list(&my_list, "Bruce Wayne", "Batman");
print_list(my_list);
return 0;
}
void push_operator_and_command(char* chunk,
char* pair,
command_t command_to_append,
command_t operator_to_append,
command_stream* iterate_me) {
command_to_append = malloc(sizeof(struct command));
parse_chunk_to_command(chunk, command_to_append);
append_to_list(command_to_append, iterate_me);
chunk[0] = '\0';
operator_to_append = malloc(sizeof(struct command));
parse_pair_to_operator_command(pair, operator_to_append);
append_to_list(operator_to_append, iterate_me);
}
int main()
{
printf("Testing lists...\n");
List *list = (List *) create_list();
assert(list != NULL);
assert(list->data == NULL);
assert(list->next == NULL);
int w = 42;
int x = 1;
int y = 2;
int z = 3;
append_to_list(list, &x);
assert(*(int *)(list->data) == 1);
assert(list->next != NULL);
append_to_list(list, &y);
assert(*(int *)(list->next->data) == 2);
assert(list->next->next != NULL);
append_to_list(list, &z);
assert(*(int *)(list->next->next->data) == 3);
assert(list->next->next->next != NULL);
assert(list->next->next->next->data == NULL);
assert(list->next->next->next->next == NULL);
list = (List *) push_to_list(list, &w);
assert(*(int *)(list->data) == 42);
assert(list->next != NULL);
list = (List *) pop_from_list(list);
assert(*(int *)(list->data) == 1);
assert(list_length(list) == 3);
assert(list_index(list, &y) == 1);
assert(list_index(list, &w) == -1);
list = remove_from_list(list, &x);
assert(*(int *)(list->data) == 2);
list = push_to_list(list, &x);
list = remove_from_list(list, &y);
assert(*(int *)(list->next->data) == 3);
printf("List tests passed\n");
return 0;
}
void list_keys_in_hash( struct hash * current, struct list * result, char * prefix ) {
int siglen = strlen(current->sigstr);
int prefixlen = strlen(prefix);
char * path = malloc( ( prefixlen + siglen + 2 ) * sizeof(char) ); // Extra child char.
strcpy( path, prefix );
strcat( path, current->sigstr );
path[ prefixlen + siglen + 1 ] = path[ prefixlen + siglen ] = '\0';
char * chars_in_child = chars_in( current->child, 0, 0 );
char child_char = '\0';
struct hash * child_hash = NULL;
int i = current->num_children;
while ( i-- ) { // Recurse through all children.
child_char = chars_in_child[i];
if ( child_char == '\0' ) { // No keys to recurse through.
continue;
}
path[ prefixlen + siglen ] = child_char; // Get the path prefix for this child.
child_hash = charhashlookup( current->child, child_char )->data;
list_keys_in_hash( child_hash, result, path );
}
// Decide if the path to this node needs to be included in the list of keys.
if ( current->data ) {
path[ prefixlen + siglen ] = '\0';
append_to_list( result, (void *) path );
}
else {
free(path);
}
free(chars_in_child);
return;
}
/**********************************************************
* main: Prompts the user to enter an operation code, *
* then calls a function to perform the requested *
* action. Repeats until the user enters the *
* command 'q'. Prints an error message if the user *
* enters an illegal code. *
**********************************************************/
int main(void)
{
char code;
struct player *team_roster = NULL;
printf("Operation Code: a for appending to the roster, d for deleteing a player, f for finding a player"
", p for printing the roster; q for quit.\n");
for (;;) {
printf("Enter operation code: ");
scanf(" %c", &code);
while (getchar() != '\n') /* skips to end of line */
;
switch (code) {
case 'a': team_roster = append_to_list(team_roster);
break;
case 'f': find_player(team_roster);
break;
case 'p': printList(team_roster);
break;
case 'd': delete_from_list(team_roster);
break;
case 'q': clearList(team_roster);
printf("\n");
return 0;
default: printf("Illegal code");
}
printf("\n");
}
}
int main(int argc, char **argv) {
if (argc < 3) {
printf("Provide an int followed by some characters (at least one)\n"
" as command-line arguments.\n");
return EXIT_FAILURE;
}
const int length = argc - 2;
int starting_point = strtol(argv[1], NULL, 10) % length;
Node *list = NULL;
for (int i = 2; i < argc; ++i)
append_to_list(argv[i][0], &list);
Node *list_copy = list;
reverse_from(&list, starting_point);
print_list(list);
reverse_from(&list, starting_point);
print_list(list);
for (int i = 0; i < length; ++i) {
if (list != list_copy) {
printf("You cheated! Failed test.\n");
break;
}
list = list->pt_to_next_node;
list_copy = list_copy->pt_to_next_node;
}
return EXIT_SUCCESS;
}
/*
* Appends a value to the subordinate list.
*/
void to_sub_list(element_type value)
{
list_type d;
//仅仅往树添加系数的幅度值的大小，系数的符号已经编码
d.x = abs(value);
d.y = 0;
append_to_list(d);
}
void apriori(void)
{
ItemSetNode *frequent[8] = {NULL};
frequent[1] = get_frequent_one_itemsets();
int i, j, k;
for (i = 2; i < 8; i++)
{
frequent[i] = get_frequent_k_plus_one_itemsets(frequent[i - 1], frequent[1], i);
}
ItemSetNode *all_frequent = NULL, *l, *m;
for (i = 1; i < 8; i++)
{
for (l = frequent[i]; l != NULL; l = l->next)
{
append_to_list(&all_frequent, l->data);
}
}
printf("Frequent Itemsets: \n");
print_list(all_frequent);
for (l = all_frequent; l != NULL; l = l->next)
{
for (i = 0; i < 256; i++)
permutations[i] = NULL;
count = 0;
char *tmp = malloc(sizeof(char) * (strlen(l->data->item_set) + 1));
strcpy(tmp, l->data->item_set);
permute(tmp, 0, strlen(tmp) - 1);
for (i = 0; i < 256; i++)
{
if (permutations[i] != NULL)
{
for (j = 1; j < strlen(permutations[i]); j++)
{
char *LHS = malloc(sizeof(char) * (j + 1));
strncpy(LHS, permutations[i], j);
*(LHS + j) = '\0';
char *total = permutations[i];
int lhs_support, total_support;
for (m = all_frequent; m != NULL; m = m->next)
{
if (strcmp(LHS, m->data->item_set) == 0)
lhs_support = m->data->count;
if (strcmp(total, m->data->item_set) == 0)
total_support = m->data->count;
}
float conf = (float) total_support / lhs_support;
if (conf >= MIN_CONF)
printf("Rule: %s -> %s, Confidence: %f\n", LHS, j + permutations[i], conf);
}
}
}
}
}
void insert_itemset_into_tree(TreeNode **root, ItemSet *item_set, int level, int k)
{
if (*root == NULL)
{
*root = new_tree_node();
(*root)->level = level;
append_to_list(&((*root)->item_sets), item_set);
}
else if (get_size_of_list((*root)->item_sets) == MAX_NODE_SIZE && level < k)
{
ItemSetNode *tmp = NULL, *l;
append_to_list(&tmp, (*root)->item_sets->data);
append_to_list(&tmp, (*root)->item_sets->next->data);
append_to_list(&tmp, item_set);
(*root)->item_sets = NULL;
(*root)->flag = 0;
for (l = tmp; l != NULL; l = l->next)
{
if ((*(l->data->item_set + level)) % 3 == 0)
insert_itemset_into_tree(&((*root)->left), l->data, 1 + level, k);
else if ((*(l->data->item_set + level)) % 3 == 1)
insert_itemset_into_tree(&((*root)->middle), l->data, 1 + level, k);
else if ((*(l->data->item_set + level)) % 3 == 2)
insert_itemset_into_tree(&((*root)->right), l->data, 1 + level, k);
}
}
else if ((*root)->flag)
{
append_to_list(&((*root)->item_sets), item_set);
}
else
{
if ((*(item_set->item_set + level)) % 3 == 0)
insert_itemset_into_tree(&((*root)->left), item_set, 1 + level, k);
else if ((*(item_set->item_set + level)) % 3 == 1)
insert_itemset_into_tree(&((*root)->middle), item_set, 1 + level, k);
else if ((*(item_set->item_set + level)) % 3 == 2)
insert_itemset_into_tree(&((*root)->right), item_set, 1 + level, k);
}
}
int main(int argc, char **argv) {
char* array[4] = {"This ", "is ", "good ", "time "};
List* list = init_list();
for (int i = 0; i < 4; i++) {
Node *node = create_node(array[i]);
append_to_list(list, node);
}
print_list(list);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
printf("\n");
/*
* testing the creation of lists and appending
*/
printf("%s\n\n", "Commands Test 1");
LTICKET ref = create_list("Adewale");
append_to_list(ref, "Olufemi");
append_to_list(ref, "Nneka");
append_to_list(ref, "Jacob");
append_to_list(ref, "Adetola");
append_to_list(ref, "Kemi");
visit_nodes(ref);
delete_list(ref);
/*
* testing the head and tail removal as well as head insertion
*/
printf("%s\n\n", "Commands Test 2");
LTICKET ref2 = create_list("Adewale");
append_to_list(ref2, "Olufemi");
append_to_list(ref2, "Nneka");
append_to_list(ref2, "Jacob");
append_to_list(ref2, "Adetola");
append_to_list(ref2, "Kemi");
visit_nodes(ref2);
remove_head(ref2);
visit_nodes(ref2);
insert_head(ref2, "Chiamaka");
visit_nodes(ref2);
remove_tail(ref2);
visit_nodes(ref2);
delete_list(ref2);
// int check = visit_nodes(ref);
// if(LE_ISERROR(check))
// printf("%s\n", le_errbuf);
return 0;
}
void add_initial_itemset( struct parser_generator * self ) {
struct item * initial_item = new_item();
char * initial_item_key = create_item_key( initial_item );
struct itemset * initial_itemset = new_itemset();
add_to_hash( initial_itemset->items, initial_item_key, (void *) initial_item );
free( initial_item_key );
char * initial_itemset_key = create_closure_key( initial_itemset );
append_to_list( self->itemsets, (void *) initial_itemset );
int initial_state = self->itemsets->next_index - 1;
add_to_hash( self->itemsets_by_key, initial_itemset_key, (void *) (long int) initial_state );
free( initial_itemset_key );
return;
}
static LRESULT CALLBACK PopupAlarmDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch(message) {
case WM_COMMAND: // snooze
if (HIWORD(wParam) == STN_CLICKED) { //It was a click on the Popup.
ALARM *mpd = (ALARM *)CallService(MS_POPUP_GETPLUGINDATA, (WPARAM)hWnd, 0);
if (mpd->flags & ALF_NOSNOOZE)
return TRUE;
// add snooze minutes to current time
FILETIME ft;
GetLocalTime(&mpd->time);
SystemTimeToFileTime(&mpd->time, &ft);
ULARGE_INTEGER uli;
uli.LowPart = ft.dwLowDateTime;
uli.HighPart = ft.dwHighDateTime;
uli.QuadPart += mult.QuadPart * options.snooze_minutes;
ft.dwHighDateTime = uli.HighPart;
ft.dwLowDateTime = uli.LowPart;
FileTimeToSystemTime(&ft, &mpd->time);
mpd->occurrence = OC_ONCE;
mpd->snoozer = true;
mpd->flags = mpd->flags & ~(ALF_NOSTARTUP);
mpd->id = next_alarm_id++;
append_to_list(mpd);
}
PUDeletePopup(hWnd);
return TRUE;
case WM_CONTEXTMENU:
PUDeletePopup(hWnd);
return TRUE;
case UM_FREEPLUGINDATA:
ALARM *mpd = (ALARM *)CallService(MS_POPUP_GETPLUGINDATA, (WPARAM)hWnd, 0);
if (mpd > 0) {
free_alarm_data(mpd);
delete mpd;
}
return TRUE;
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
void install_incomplete_transition( int i, char * symbol, int destination, struct parser_generator * self ) {
struct hash * table_row = listlookup( self->TABLE, i );
struct hash * goto_row = listlookup( self->GOTO, i );
struct list * trans_list;
struct hash * looked_up;
if ( ( (int *) hashlookup( IS_TERMINAL, symbol )->data ) == &TRUE ) {
// Transitions on terminals go in TABLE.
looked_up = hashlookup( table_row, symbol );
if ( ! looked_up ) {
trans_list = new_list();
add_to_hash( table_row, symbol, (void *) trans_list );
}
else {
trans_list = looked_up->data;
}
struct transition * terminal_transition = new_transition();
terminal_transition->action = "shift";
terminal_transition->arg = destination;
if ( ! strcmp( symbol, "end" ) ) {
terminal_transition->action = "accept";
}
append_to_list( trans_list, (void *) terminal_transition );
}
else { // Transitions on nonterminals go in GOTO.
looked_up = hashlookup( goto_row, symbol );
if ( ! looked_up ) {
trans_list = new_list();
add_to_hash( goto_row, symbol, (void *) trans_list );
}
else {
trans_list = looked_up->data;
}
append_to_list( trans_list, (void *) (long int) destination );
}
}
KDEF_SYSCALL(thread_fork, r)
{
// example: thread_fork(stack, function, argument);
process_stack stack = init_pstack();
if(current->proc->flags & PROC_FLAG_DEBUG)
{
debug("[info]thread_fork(%x, %x, %x)\n", stack[0], stack[1], stack[2]);
}
thread_t *th = new_thread((void (*)(void))stack[1], 1);
append_to_list(current->proc->threads, th->process_threads);
th->proc = current->proc;
uint32_t *stk = (uint32_t *)stack[0];
*--stk = stack[2];
*--stk = SIGNAL_RETURN_ADDRESS;
th->r.useresp = th->r.ebp = (uint32_t)stk;
r->eax = th->tid;
return r;
}
linked_list_node *prime_numbers_less_than(int n) {
int cur = 3;
linked_list_node * head = create_linked_list_node(2);
while ((last_node(head))->data < n) {
if (cur >= n) {
break;
} else if (!list_can_divide_num(head, cur)) {
printf("%d\n", cur);
append_to_list(head, cur);
}
cur ++;
}
return head;
}
void get_leaves(TreeNode *root, ItemSetNode **list)
{
if (root == NULL)
return;
ItemSetNode *l;
for (l = root->item_sets; l != NULL; l = l->next)
{
if ((float)l->data->count / TXNS >= MIN_SUPPORT)
{
append_to_list(list, l->data);
}
}
get_leaves(root->left,list);
get_leaves(root->middle, list);
get_leaves(root->right, list);
}
INT_PTR AddAlarmService(WPARAM, LPARAM lParam)
{
ALARMINFO *alarm_info = (ALARMINFO *)lParam;
ALARM alarm = {0};
alarm.action = alarm_info->action;
alarm.flags = alarm_info->flags;
alarm.id = next_alarm_id++;
alarm.occurrence = alarm_info->occurrence;
alarm.snoozer = alarm_info->snoozer;
alarm.sound_num = alarm_info->sound_num;
alarm.szCommand = mir_tstrdup(alarm_info->szCommand);
alarm.szCommandParams = mir_tstrdup(alarm_info->szCommandParams);
alarm.szDesc = mir_tstrdup(alarm_info->szDesc);
alarm.szTitle = mir_tstrdup(alarm_info->szTitle);
alarm.time = alarm_info->time;
append_to_list(&alarm);
return 0;
}
void analyze_productions() {
GSIZE = NUM_PRODUCTIONS;
int i;
int j;
struct list * production;
struct list * productions_for_symbol;
char * symbol;
if ( ! IS_TERMINAL ) {
IS_TERMINAL = new_hash();
}
if ( ! PRODUCTIONS_FOR ) {
PRODUCTIONS_FOR = new_hash();
}
for ( i = 0; i < NUM_PRODUCTIONS; i++ ) {
production = GRAMMAR[i].production;
if ( production->next_index > GSIZE ) {
GSIZE = production->next_index;
}
for ( j = 0; j < production->next_index; j++ ) {
symbol = listlookup( production, j );
struct hash * looked_up = hashlookup( IS_TERMINAL, symbol );
if ( ! looked_up ) { // Assume each new symbol is a terminal.
add_to_hash( IS_TERMINAL, symbol, (void *) &TRUE );
}
if ( j == 0 ) { // Symbols on the left side of a productions are nonterminal.
add_to_hash( IS_TERMINAL, symbol, (void *) &FALSE );
looked_up = hashlookup( PRODUCTIONS_FOR, symbol );
if ( ! looked_up ) {
productions_for_symbol = new_list();
add_to_hash( PRODUCTIONS_FOR, symbol, (void *) productions_for_symbol );
}
else {
productions_for_symbol = looked_up->data;
}
append_to_list( productions_for_symbol, (void *) (long int) i );
}
}
}
}
ItemSetNode *get_frequent_one_itemsets(void)
{
const char* item[] = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y"};
int count[25] = {0};
FILE *fp = fopen(DATA_FILE, "r");
char *line = NULL;
int i;
while ((line = read_line(fp)) != NULL && *line != '\0')
{
for (i = 0; i < 25; i++)
{
if (strstr(line, item[i]) != NULL)
{
count[i]++;
}
}
free(line);
}
ItemSetNode *list = NULL;
for (i = 0; i < 25; i++)
{
float support = (float) count[i] / TXNS;
if (support >= MIN_SUPPORT)
{
char *tmp = malloc(sizeof(char) * 2);
*tmp = *item[i];
*(tmp + 1) = '\0';
append_to_list(&list, new_item_set(tmp, count[i]));
}
}
fclose(fp);
return list;
}
void install_incomplete_transitions( int i, struct itemset * current_itemset, struct parser_generator * self ) {
struct list * itemsets = self->itemsets;
struct hash * itemsets_by_key = self->itemsets_by_key;
struct hash * ready_for = current_itemset->ready_for;
// Prepare to loop through the keys of current_itemset->ready_for.
struct list * key_list = new_list();
list_keys_in_hash( ready_for, key_list, "" );
int j;
int k;
for ( j = 0; j < key_list->next_index; j++ ) { // Loop ready-for symbols.
char * symbol = listlookup( key_list, j );
struct list * ready_for_symbol = hashlookup( ready_for, symbol )->data;
struct itemset * proposed_itemset = new_itemset();
for ( k = 0; k < ready_for_symbol->next_index; k++ ) { // Loop symbol items.
struct item * ready_item = listlookup( ready_for_symbol, k );
struct item * proposed_item = new_item();
proposed_item->prod_num = ready_item->prod_num;
proposed_item->dot = ready_item->dot + 1;
char * proposed_item_key = create_item_key( proposed_item );
add_to_hash( proposed_itemset->items, proposed_item_key, (void *) proposed_item );
free( proposed_item_key ); // It's now in the hash.
} // End symbol items loop.
char * proposed_itemset_key = create_closure_key( proposed_itemset );
struct hash * looked_up = hashlookup( itemsets_by_key, proposed_itemset_key );
if ( ! looked_up ) {
append_to_list( itemsets, (void *) proposed_itemset );
int state_num = itemsets->next_index - 1;
looked_up = add_to_hash( itemsets_by_key, proposed_itemset_key, (void *) (long int) state_num );
}
else {
destroy_itemset( proposed_itemset );
}
int destination = (long int) looked_up->data;
install_incomplete_transition( i, symbol, destination, self );
} // End ready-for symbols loop.
return;
}
void install_complete_transitions( int i, struct itemset * current_itemset, struct parser_generator * self ) {
struct list * table = self->TABLE;
struct list * complete_items = current_itemset->complete;
char * lhs;
struct item * complete_item;
struct list * complete_production;
int j; int k;
struct hash * table_row = listlookup( self->TABLE, i );
for ( j = 0; j < complete_items->next_index; j++ ) {
complete_item = listlookup( complete_items, j );
int prod_num = complete_item->prod_num;
complete_production = GRAMMAR[prod_num].production;
lhs = listlookup( complete_production, 0 );
// Loop all terminals which can follow this lhs.
struct list * key_list = new_list();
list_keys_in_hash( hashlookup( FOLLOW, lhs )->data, key_list, "" );
for ( k = 0; k < key_list->next_index; k++ ) {
struct list * trans_list;
char * follower = listlookup( key_list, k );
// Add a reduce transition on each follower token.
struct hash * looked_up = hashlookup( table_row, follower );
if ( ! looked_up ) {
trans_list = new_list();
add_to_hash( table_row, follower, (void *) trans_list );
}
else {
trans_list = looked_up->data;
}
struct transition * reduce_transition = new_transition();
reduce_transition->action = "reduce";
reduce_transition->arg = prod_num;
append_to_list( trans_list, reduce_transition );
}
destroy_key_list( key_list );
}
}
static int handle_line(char *line)
{
int i, len = strlen(line);
unsigned char *sha1;
char *src, *origin;
struct src_data *src_data;
int pulling_head = 0;
if (len < 43 || line[40] != '\t')
return 1;
if (!prefixcmp(line + 41, "not-for-merge"))
return 0;
if (line[41] != '\t')
return 2;
line[40] = 0;
sha1 = xmalloc(20);
i = get_sha1(line, sha1);
line[40] = '\t';
if (i)
return 3;
if (line[len - 1] == '\n')
line[len - 1] = 0;
line += 42;
src = strstr(line, " of ");
if (src) {
*src = 0;
src += 4;
pulling_head = 0;
} else {
src = line;
pulling_head = 1;
}
i = find_in_list(&srcs, src);
if (i < 0) {
i = srcs.nr;
append_to_list(&srcs, xstrdup(src),
xcalloc(1, sizeof(struct src_data)));
}
src_data = srcs.payload[i];
if (pulling_head) {
origin = xstrdup(src);
src_data->head_status |= 1;
} else if (!prefixcmp(line, "branch ")) {
origin = xstrdup(line + 7);
append_to_list(&src_data->branch, origin, NULL);
src_data->head_status |= 2;
} else if (!prefixcmp(line, "tag ")) {
origin = line;
append_to_list(&src_data->tag, xstrdup(origin + 4), NULL);
src_data->head_status |= 2;
} else if (!prefixcmp(line, "remote branch ")) {
origin = xstrdup(line + 14);
append_to_list(&src_data->r_branch, origin, NULL);
src_data->head_status |= 2;
} else {
origin = xstrdup(src);
append_to_list(&src_data->generic, xstrdup(line), NULL);
src_data->head_status |= 2;
}
if (!strcmp(".", src) || !strcmp(src, origin)) {
int len = strlen(origin);
if (origin[0] == '\'' && origin[len - 1] == '\'') {
origin = xmemdupz(origin + 1, len - 2);
} else {
origin = xstrdup(origin);
}
} else {
char *new_origin = xmalloc(strlen(origin) + strlen(src) + 5);
sprintf(new_origin, "%s of %s", origin, src);
origin = new_origin;
}
append_to_list(&origins, origin, sha1);
return 0;
}
static void shortlog(const char *name, unsigned char *sha1,
struct commit *head, struct rev_info *rev, int limit)
{
int i, count = 0;
struct commit *commit;
struct object *branch;
struct list subjects = { NULL, NULL, 0, 0 };
int flags = UNINTERESTING | TREESAME | SEEN | SHOWN | ADDED;
branch = deref_tag(parse_object(sha1), sha1_to_hex(sha1), 40);
if (!branch || branch->type != OBJ_COMMIT)
return;
setup_revisions(0, NULL, rev, NULL);
rev->ignore_merges = 1;
add_pending_object(rev, branch, name);
add_pending_object(rev, &head->object, "^HEAD");
head->object.flags |= UNINTERESTING;
if (prepare_revision_walk(rev))
die("revision walk setup failed");
while ((commit = get_revision(rev)) != NULL) {
char *oneline, *bol, *eol;
/* ignore merges */
if (commit->parents && commit->parents->next)
continue;
count++;
if (subjects.nr > limit)
continue;
bol = strstr(commit->buffer, "\n\n");
if (bol) {
unsigned char c;
do {
c = *++bol;
} while (isspace(c));
if (!c)
bol = NULL;
}
if (!bol) {
append_to_list(&subjects, xstrdup(sha1_to_hex(
commit->object.sha1)),
NULL);
continue;
}
eol = strchr(bol, '\n');
if (eol) {
oneline = xmemdupz(bol, eol - bol);
} else {
oneline = xstrdup(bol);
}
append_to_list(&subjects, oneline, NULL);
}
if (count > limit)
printf("\n* %s: (%d commits)\n", name, count);
else
printf("\n* %s:\n", name);
for (i = 0; i < subjects.nr; i++)
if (i >= limit)
printf(" ...\n");
else
printf(" %s\n", subjects.list[i]);
clear_commit_marks((struct commit *)branch, flags);
clear_commit_marks(head, flags);
free_commit_list(rev->commits);
rev->commits = NULL;
rev->pending.nr = 0;
free_list(&subjects);
}
static void node_checkdirectory(struct imgtooltest_state *state, xml_data_node *node)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
imgtool_directory *imageenum;
imgtool_dirent ent;
char expected_listing[1024];
char actual_listing[1024];
int i/*, actual_count*/;
int mismatch;
xml_attribute_node *attr_node;
xml_data_node *child_node;
const char *filename;
expected_dirent *entry;
expected_dirent entries[256];
int entry_count;
if (!state->m_partition)
{
state->m_failed = 1;
report_message(MSG_FAILURE, "Partition not loaded");
return;
}
attr_node = xml_get_attribute(node, "path");
filename = attr_node ? attr_node->value : "";
memset(&entries, 0, sizeof(entries));
entry_count = 0;
for (child_node = xml_get_sibling(node->child, "entry"); child_node; child_node = xml_get_sibling(child_node->next, "entry"))
{
if (entry_count >= ARRAY_LENGTH(entries))
{
report_message(MSG_FAILURE, "Too many directory entries");
return;
}
entry = &entries[entry_count++];
attr_node = xml_get_attribute(child_node, "name");
entry->filename = attr_node ? attr_node->value : NULL;
attr_node = xml_get_attribute(child_node, "size");
entry->size = attr_node ? atoi(attr_node->value) : -1;
}
/* build expected listing string */
expected_listing[0] = '\0';
for (i = 0; i < entry_count; i++)
{
append_to_list(expected_listing,
ARRAY_LENGTH(expected_listing),
entries[i].filename);
}
/* now enumerate though listing */
//actual_count = 0;
actual_listing[0] = '\0';
mismatch = FALSE;
memset(&ent, 0, sizeof(ent));
err = imgtool_directory_open(state->m_partition, filename, &imageenum);
if (err)
goto done;
i = 0;
do
{
err = imgtool_directory_get_next(imageenum, &ent);
if (err)
goto done;
if (!ent.eof)
{
append_to_list(actual_listing,
ARRAY_LENGTH(actual_listing),
ent.filename);
if (i < entry_count && (strcmp(ent.filename, entries[i].filename)))
mismatch = TRUE;
i++;
}
}
while(!ent.eof);
if (i != entry_count)
mismatch = TRUE;
if (mismatch)
{
state->m_failed = 1;
report_message(MSG_FAILURE, "File listing mismatch: {%s} expected {%s}",
actual_listing, expected_listing);
goto done;
}
done:
if (imageenum)
imgtool_directory_close(imageenum);
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
}
}
void pool_add(lky_mempool *pool, void *obj)
{
struct poolnode *next = gen_node(obj);
append_to_list(&(pool->head), &(pool->tail), next);
}
List *split_into_simple_commands( char *cmd )
{
List *command_list = NULL;
int escaped = 0;
int in_single_quote = 0;
int in_double_quote = 0;
int in_backwards_quote = 0;
int start_index = 0;
int current_index = 0;
int cmd_length = strlen( cmd );
char c;
char prev_c;
char next_c;
//fprintf( stderr, "split_into_simple_commands(%s)\n", cmd );
while ( current_index < cmd_length ) {
/* It is sometimes easiest if we can look one character to the
right or to the left of the current position, whilst not
going off either end of the string. */
c = cmd[ current_index ];
if ( current_index > 0 ) {
prev_c = cmd[ current_index - 1 ];
} else {
prev_c = '\0';
}
if ( (current_index + 1) < cmd_length ) {
next_c = cmd[ current_index + 1 ];
} else {
next_c = '\0';
}
switch(c) {
case '\\' :
escaped = 1;
current_index++;
break;
case '\'' :
if ( escaped ) {
escaped = 0;
current_index++;
} else {
in_single_quote = !in_single_quote;
current_index++;
}
break;
case '\"' :
if ( escaped ) {
escaped = 0;
current_index++;
} else {
in_double_quote = !in_double_quote;
current_index++;
}
break;
case '`' :
if ( escaped ) {
escaped = 0;
current_index++;
} else {
in_backwards_quote = !in_backwards_quote;
current_index++;
}
break;
case '|' :
case '&' :
case '(' :
case ')' :
case ';' :
escaped = 0;
if (in_single_quote || in_double_quote || in_backwards_quote) {
current_index++;
} else {
if ( ((c == '&') && (next_c == '&')) ||
((c == '|') && (next_c == '|')) ||
((c == '|') && (next_c == '&')) ) {
command_list = append_to_list( command_list,
strndup( &(cmd[start_index]), current_index-start_index ) );
command_list = append_to_list( command_list,
strndup( &(cmd[current_index]), 2 ) );
current_index += 2;
start_index = current_index;
} else if ( (prev_c == '>') && (c == '&') ) { // ignore >& redirect
current_index++;
} else {
command_list = append_to_list( command_list,
strndup( &(cmd[start_index]), current_index-start_index ) );
command_list = append_to_list( command_list,
strndup( &(cmd[current_index]), 1 ) );
current_index++;
start_index = current_index;
}
}
break;
case ' ' :
case '\t' :
/* If we see one or more spaces or tabs at the start of a
(simple) command, then keep moving start_index forward,
so that if we eventually find a command, we've already
stepped over the white space. */
if (start_index == current_index) {
current_index++;
start_index = current_index;
} else {
current_index++;
}
escaped = 0;
break;
default :
escaped = 0;
current_index++;
}
}
if (start_index != current_index) {
command_list = append_to_list( command_list,
strndup( &(cmd[start_index]), current_index-start_index ) );
}
//fprintf( stderr, "split_into_simple_commands returns\n" );
//print_list( command_list );
return command_list;
}
INT_PTR CALLBACK DlgProcAlarm(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch ( msg ) {
case WM_INITDIALOG:
TranslateDialogDefault( hwndDlg );
{
Utils_RestoreWindowPositionNoSize(hwndDlg, 0, MODULE, "Notify");
SetFocus(GetDlgItem(hwndDlg, IDC_SNOOZE));
WindowData *wd = new WindowData;
wd->moving = false;
wd->alarm = 0;
wd->win_num = win_num++;
if (wd->win_num > 0) {
RECT r;
GetWindowRect(hwndDlg, &r);
r.top += 20;
r.left += 20;
SetWindowPos(hwndDlg, 0, r.left, r.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
Utils_SaveWindowPosition(hwndDlg, 0, MODULE, "Notify");
}
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)wd);
// options
SendMessage(hwndDlg, WMU_SETOPT, 0, 0);
// fonts
SendMessage(hwndDlg, WMU_SETFONTS, 0, 0);
}
return FALSE;
case WMU_REFRESH:
InvalidateRect(hwndDlg, 0, TRUE);
return TRUE;
case WM_CTLCOLORSTATIC:
{
HDC hdc = (HDC)wParam;
HWND hwndCtrl = (HWND)lParam;
if (hBackgroundBrush) {
if (hTitleFont && GetDlgItem(hwndDlg, IDC_TITLE) == hwndCtrl)
SetTextColor(hdc, title_font_colour);
else if (hWindowFont)
SetTextColor(hdc, window_font_colour);
SetBkMode(hdc, TRANSPARENT);
return (BOOL)hBackgroundBrush;
}
}
break;
case WM_CTLCOLORDLG:
if (hBackgroundBrush)
return (BOOL)hBackgroundBrush;
break;
case WMU_SETFONTS:
// fonts
if (hWindowFont)
SendMessage(hwndDlg, WM_SETFONT, (WPARAM)hWindowFont, TRUE);
if (hTitleFont)
SendDlgItemMessage(hwndDlg, IDC_TITLE, WM_SETFONT, (WPARAM)hTitleFont, TRUE);
if (hBackgroundBrush) {
SetClassLong(hwndDlg, GCLP_HBRBACKGROUND, (LONG)hBackgroundBrush);
InvalidateRect(hwndDlg, 0, TRUE);
}
return TRUE;
case WMU_SETOPT:
{
Options *opt;
if (lParam) opt = (Options *)lParam;
else opt = &options;
// round corners
if (opt->aw_roundcorners) {
HRGN hRgn1;
RECT r;
int v,h;
int w=10;
GetWindowRect(hwndDlg,&r);
h=(r.right-r.left)>(w*2)?w:(r.right-r.left);
v=(r.bottom-r.top)>(w*2)?w:(r.bottom-r.top);
h=(h<v)?h:v;
hRgn1=CreateRoundRectRgn(0,0,(r.right-r.left+1),(r.bottom-r.top+1),h,h);
SetWindowRgn(hwndDlg,hRgn1,1);
}
else {
HRGN hRgn1;
RECT r;
int v,h;
int w=10;
GetWindowRect(hwndDlg,&r);
h=(r.right-r.left)>(w*2)?w:(r.right-r.left);
v=(r.bottom-r.top)>(w*2)?w:(r.bottom-r.top);
h=(h<v)?h:v;
hRgn1=CreateRectRgn(0,0,(r.right-r.left+1),(r.bottom-r.top+1));
SetWindowRgn(hwndDlg,hRgn1,1);
}
// transparency
#ifdef WS_EX_LAYERED
SetWindowLongPtr(hwndDlg, GWL_EXSTYLE, GetWindowLongPtr(hwndDlg, GWL_EXSTYLE) | WS_EX_LAYERED);
#endif
#ifdef LWA_ALPHA
SetLayeredWindowAttributes(hwndDlg, RGB(0,0,0), (int)((100 - opt->aw_trans) / 100.0 * 255), LWA_ALPHA);
#endif
}
return TRUE;
case WMU_SETALARM:
{
ALARM *data = (ALARM *)lParam;
SetWindowText(hwndDlg, data->szTitle);
HWND hw = GetDlgItem(hwndDlg, IDC_TITLE);
SetWindowText(hw, data->szTitle);
SetDlgItemText(hwndDlg, IDC_ED_DESC, data->szDesc);
((WindowData *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA))->alarm = data;
if (data->action & AAF_SOUND && options.loop_sound) {
if (data->sound_num <= 3)
SetTimer(hwndDlg, ID_TIMER_SOUND, SOUND_REPEAT_PERIOD, 0);
else if (data->sound_num == 4)
SetTimer(hwndDlg, ID_TIMER_SOUND, SPEACH_REPEAT_PERIOD, 0);
}
hw = GetDlgItem(hwndDlg, IDC_SNOOZE);
EnableWindow(hw, !(data->flags & ALF_NOSNOOZE));
ShowWindow(hw, (data->flags & ALF_NOSNOOZE) ? SW_HIDE : SW_SHOWNA);
}
return TRUE;
case WMU_FAKEALARM:
{
SetWindowText(hwndDlg, TranslateT("Example alarm"));
SetDlgItemText(hwndDlg, IDC_TITLE, TranslateT("Example alarm"));
SetDlgItemText(hwndDlg, IDC_ED_DESC, TranslateT("Some example text. Example, example, example."));
}
return TRUE;
case WM_TIMER:
if (wParam == ID_TIMER_SOUND) {
WindowData *dw = (WindowData *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
if (dw) {
ALARM *data = dw->alarm;
if (data && data->action & AAF_SOUND) {
if (data->sound_num <= 3) {
char buff[128];
mir_snprintf(buff, SIZEOF(buff), "Triggered%d", data->sound_num);
SkinPlaySound(buff);
}
else if (data->sound_num == 4) {
if (data->szTitle != NULL && data->szTitle[0] != '\0') {
if (ServiceExists("Speak/Say")) {
CallService("Speak/Say", 0, (LPARAM)data->szTitle);
}
}
}
}
}
}
return TRUE;
case WM_MOVE:
Utils_SaveWindowPosition(hwndDlg, 0, MODULE, "Notify");
break;
case WMU_ADDSNOOZER:
{
WindowData *wd = (WindowData *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
if (wd) {
ALARM *data = wd->alarm;
if (data) {
// add snooze minutes to current time
FILETIME ft;
GetLocalTime(&data->time);
SystemTimeToFileTime(&data->time, &ft);
ULARGE_INTEGER uli;
uli.LowPart = ft.dwLowDateTime;
uli.HighPart = ft.dwHighDateTime;
// there are 10000000 100-nanosecond blocks in a second...
uli.QuadPart += mult.QuadPart * (int)(wParam);
ft.dwHighDateTime = uli.HighPart;
ft.dwLowDateTime = uli.LowPart;
FileTimeToSystemTime(&ft, &data->time);
data->occurrence = OC_ONCE;
data->snoozer = true;
data->flags = data->flags & ~ALF_NOSTARTUP;
data->id = next_alarm_id++;
append_to_list(data);
}
}
}
return TRUE;
case WM_COMMAND:
if ( HIWORD( wParam ) == BN_CLICKED ) {
switch( LOWORD( wParam )) {
case IDCANCEL: // no button - esc pressed
case IDOK: // space?
case IDC_SNOOZE:
SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)options.snooze_minutes, 0);
//drop through
case IDC_DISMISS:
{
WindowData *window_data = (WindowData *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
KillTimer(hwndDlg, ID_TIMER_SOUND);
if (window_data) {
if (window_data->alarm) {
free_alarm_data(window_data->alarm);
delete window_data->alarm;
}
delete window_data;
}
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, 0);
win_num--;
//EndDialog(hwndDlg, IDOK); // not modal!
WindowList_Remove(hAlarmWindowList, hwndDlg);
DestroyWindow(hwndDlg);
}
break;
case IDC_SNOOZELIST:
{
POINT pt, pt_rel;
GetCursorPos(&pt);
pt_rel = pt;
ScreenToClient(hwndDlg,&pt_rel);
HMENU hMenu = CreatePopupMenu();
MENUITEMINFO mmi = {0};
mmi.cbSize = sizeof(mmi);
mmi.fMask = MIIM_ID | MIIM_STRING;
#define AddItem(x) \
mmi.wID++; \
mmi.dwTypeData = TranslateT(x); \
mmi.cch = ( UINT )mir_tstrlen(mmi.dwTypeData); \
InsertMenuItem(hMenu, mmi.wID, FALSE, &mmi);
AddItem(LPGEN("5 mins"));
AddItem(LPGEN("15 mins"));
AddItem(LPGEN("30 mins"));
AddItem(LPGEN("1 hour"));
AddItem(LPGEN("1 day"));
AddItem(LPGEN("1 week"));
TPMPARAMS tpmp = {0};
tpmp.cbSize = sizeof(tpmp);
LRESULT ret = (LRESULT)TrackPopupMenuEx(hMenu, TPM_RETURNCMD, pt.x, pt.y, hwndDlg, &tpmp);
switch(ret) {
case 0: DestroyMenu(hMenu); return 0; // dismis menu
case 1: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)5, 0); break;
case 2: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)15, 0); break;
case 3: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)30, 0); break;
case 4: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)60, 0); break;
case 5: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)(60 * 24), 0); break;
case 6: SendMessage(hwndDlg, WMU_ADDSNOOZER, (WPARAM)(60 * 24 * 7), 0); break;
}
DestroyMenu(hMenu);
SendMessage(hwndDlg, WM_COMMAND, IDC_DISMISS, 0);
}
break;
}
}
return TRUE;
case WM_MOUSEMOVE:
if (wParam & MK_LBUTTON) {
SetCapture(hwndDlg);
POINT newp;
newp.x = (short)LOWORD(lParam);
newp.y = (short)HIWORD(lParam);
ClientToScreen(hwndDlg, &newp);
WindowData *window_data = (WindowData *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
if (!window_data->moving)
window_data->moving = true;
else {
RECT r;
GetWindowRect(hwndDlg, &r);
SetWindowPos(hwndDlg, 0, r.left + (newp.x - window_data->p.x), r.top + (newp.y - window_data->p.y), 0, 0, SWP_NOSIZE | SWP_NOZORDER);
}
window_data->p.x = newp.x;
window_data->p.y = newp.y;
}
else {
ReleaseCapture();
WindowData *window_data = (WindowData *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
window_data->moving = false;
}
return TRUE;
}
return FALSE;
}
void
MyString::append_to_list(MyString const &str,char const *delim /* ="," */) {
append_to_list(str.Value(),delim);
}