/** * Pops and returns the top element of the stack. */ void* pop(struct stack_pointer* stack) { if (is_empty(stack)) { fatal_error("Cannot pop an empty stack\n"); } return stack->stack[(stack->stack_pointer_m)--]; }
int main(int argc, char** argv) { IntList* list1 = mk_list(); print_list(list1); printf("is_empty(list1) = 1? %d\n", is_empty(list1)); printf("length(list1) = 0? %d\n", length(list1)); free_list(list1); IntList* list2 = mk_list(); push_back(list2, 4); push_back(list2, 5); printf("is_empty(list2) = 0? %d\n", is_empty(list2)); printf("length(list2) = 2? %d\n", length(list2)); print_list(list2); printf("sum(list2) = 9? %d\n", sum(list2)); int ret1, ret2, ret3; printf("index_of(list2, 4, ret1) = true? %d\n", index_of(list2, 4, &ret1)); printf("index_of(list2, 5, ret2) = true? %d\n", index_of(list2, 5, &ret2)); printf("index_of(list2, 6, ret3) = false? %d\n", index_of(list2, 6, &ret3)); printf("index_of(list2, 4, ret1), ret1 = 0? %d\n", ret1); printf("index_of(list2, 5, ret2), ret2 = 1? %d\n", ret2); push_front(list2, 6); print_list(list2); printf("index_of(list2, 4, ret1) = true? %d\n", index_of(list2, 4, &ret1)); printf("index_of(list2, 5, ret2) = true? %d\n", index_of(list2, 5, &ret2)); printf("index_of(list2, 6, ret3) = true? %d\n", index_of(list2, 6, &ret3)); printf("index_of(list2, 4, ret1), ret1 = 1? %d\n", ret1); printf("index_of(list2, 5, ret2), ret2 = 2? %d\n", ret2); printf("index_of(list2, 6, ret3), ret2 = 0? %d\n", ret3); insert(list2, 8, 0); print_list(list2); insert(list2, 9, 2); print_list(list2); insert(list2, 7, 4); print_list(list2); intersperse(list2, 3); print_list(list2); IntList* list3 = mk_list(); push_back(list3, 4); push_back(list3, 5); intersperse(list3, 2); print_list(list3); int pop; pop_front(list3, &pop); print_list(list3); printf("pop = %d\n", pop); pop_front(list3, &pop); print_list(list3); printf("pop = %d\n", pop); pop_front(list3, &pop); print_list(list3); printf("pop = %d\n", pop); printf("list3 = "); print_list(list3); printf("\nfree_list(list2)...\n"); free_list(list2); printf("free_list(list3)...\n"); free_list(list3); return 0; }
/** * Parse Identifier (ECMA-262 v5, 7.6) or ReservedWord (7.6.1; 7.8.1; 7.8.2). * * @return TOK_NAME - for Identifier, * TOK_KEYWORD - for Keyword or FutureReservedWord, * TOK_NULL - for NullLiteral, * TOK_BOOL - for BooleanLiteral */ static token lexer_parse_identifier_or_keyword (void) { ecma_char_t c = LA (0); JERRY_ASSERT (lexer_is_char_can_be_identifier_start (c)); new_token (); bool is_correct_identifier_name = true; bool is_escape_sequence_occured = false; bool is_all_chars_were_lowercase_ascii = true; while (true) { c = LA (0); if (c == LIT_CHAR_BACKSLASH) { consume_char (); is_escape_sequence_occured = true; bool is_unicode_escape_sequence = (LA (0) == LIT_CHAR_LOWERCASE_U); consume_char (); if (is_unicode_escape_sequence) { /* UnicodeEscapeSequence */ if (!lexer_convert_escape_sequence_digits_to_char (&src_iter, true, &c)) { is_correct_identifier_name = false; break; } else { /* c now contains character, encoded in the UnicodeEscapeSequence */ // Check character, converted from UnicodeEscapeSequence if (!lexer_is_char_can_be_identifier_part (c)) { is_correct_identifier_name = false; break; } } } else { is_correct_identifier_name = false; break; } } else if (!lexer_is_char_can_be_identifier_part (c)) { break; } else { if (!(c >= LIT_CHAR_ASCII_LOWERCASE_LETTERS_BEGIN && c <= LIT_CHAR_ASCII_LOWERCASE_LETTERS_END)) { is_all_chars_were_lowercase_ascii = false; } consume_char (); } } if (!is_correct_identifier_name) { PARSE_ERROR (JSP_EARLY_ERROR_SYNTAX, "Illegal identifier name", lit_utf8_iterator_get_pos (&src_iter)); } const lit_utf8_size_t charset_size = TOK_SIZE (); token ret = empty_token; if (!is_escape_sequence_occured && is_all_chars_were_lowercase_ascii) { /* Keyword or FutureReservedWord (TOK_KEYWORD), or boolean literal (TOK_BOOL), or null literal (TOK_NULL) */ ret = lexer_parse_reserved_word (TOK_START (), charset_size); } if (is_empty (ret)) { /* Identifier (TOK_NAME) */ if (!is_escape_sequence_occured) { ret = lexer_create_token_for_charset (TOK_NAME, TOK_START (), charset_size); } else { ret = lexer_create_token_for_charset_transform_escape_sequences (TOK_NAME, TOK_START (), charset_size); } } is_token_parse_in_progress = false; return ret; } /* lexer_parse_identifier_or_keyword */
// 피크 함수 element peak(LinkedStackType *s){ if(is_empty(s)){ fprintf(stderr, "스택 공백 에러\n"); exit(1); }else return s->top->item; }
Item peek(Stack s) { if (is_empty(s)) terminate("Error in peek: stack is empty."); return s->contents[s->top - 1]; }
/******************************************************************************* Return the minimum number of items that can appear in an instance of the type. Returned value may be 0 or 1. ********************************************************************************/ int XQType::min_card() const { return (is_empty() ? 0 : RootTypeManager::QUANT_MIN_CNT[get_quantifier()]); }
void infix_to_postfix(char exp[]) { Stack s; int i, n, strlength; char* newstr; strlength = strlen(exp); newstr = (char*) malloc(strlength); stack_init(&s); n = 0; for (i = 0; i < strlength; ++i) { char temp = exp[i]; if (temp == '(') stack_push(&s, temp); else if (temp == ')') { char topOp = (char) stack_pop(&s); while (topOp != '(') { newstr[n++] = topOp; topOp = (char) stack_pop(&s); } } else if (is_operend(temp)) { char topOp = (char)stack_peek(&s); while (!is_empty(&s) && get_operend_priority(topOp) >= get_operend_priority(temp)) { newstr[n++] = (char) stack_pop(&s); topOp = (char)stack_peek(&s); } stack_push(&s, temp); } else { newstr[n++] = exp[i]; } //next } while (!is_empty(&s)) { newstr[n++] = (char) stack_pop(&s); } memset(exp, 0, strlength); for (i = 0; i < n; ++i) { exp[i] = newstr[i]; } stack_destroy(&s); free(newstr); }
bool Stack::pop(char& elem){ if (is_empty()) return false; //you can't bleed a stone elem = dat_ptr[--the_top]; //move back to pop the highest value off the stack }
bool Stack::top(char& elem){ if (is_empty()) return false; //nothing in here elem = dat_ptr[elem - 1]; //what's on top? return true; //a successful look at the top value }
double mixing_tank::get_mix( ) const { assert (!is_empty()); return ((quantity_a / get_volume ())); }
void test_board_is_empty() { Board* board = new_board(3); assert(is_empty(board)); destroy_board(board); }
//------------------------------------------------------------------------------ int is_frontier_empty() { return is_empty(&pqueue); }
/**@return true if node is literal *******************************************************************************/ inline bool is_literal(const Node_id nid, Triple_store const& ts) { Node const& node = ts[nid]; return is_empty(node.ns_id()); }
/* Return whether the queue is empty */ bool queueEmpty(Queue *queue) { return is_empty(queue->stk_ptr); }
void *peek_end(RB) {if (!RB || is_empty(RB)) return NULL; return data[prev(RB,e)]; }
queue = NULL; front = 1; rear = 0; } // insert,插入队列,从队尾插入 void insert( QUEUE_TYPE value ) { assert( !is_full( ) ); rear = ( rear + 1 ) % ARRAY_SIZE; queue[rear] = value; } // delete 从队头删除 void delete( void ) { assert( !is_empty( ) ); front = ( front + 1 ) % ARRAY_SIZE; } // first,队头元素 QUEUE_TYPE first( void ) { assert( !is_empty( ) ); return queue[front]; } // is_empty int is_empty( void ) { return ( rear + 1 ) % ARRAY_SIZE == front; }
void *get_end(RB) { CHKRB; if (is_empty(RB)) return -1; e=prev(RB,e); return data[e]; }
/** * @brief Creates the text surface. * * This function is called when there is a change. */ void TextSurface::rebuild() { if (surface != NULL) { // another text was previously set: delete it SDL_FreeSurface(surface->get_internal_surface()); delete surface; surface = NULL; } if (is_empty()) { // empty string: no surface to create return; } // create the text surface SDL_Surface *internal_surface = NULL; switch (rendering_mode) { case TEXT_SOLID: internal_surface = TTF_RenderUTF8_Solid(fonts[font_id].internal_font, text.c_str(), *text_color.get_internal_color()); break; case TEXT_SHADED: internal_surface = TTF_RenderUTF8_Shaded(fonts[font_id].internal_font, text.c_str(), *text_color.get_internal_color(), *background_color.get_internal_color()); break; case TEXT_BLENDED: internal_surface = TTF_RenderUTF8_Blended(fonts[font_id].internal_font, text.c_str(), *text_color.get_internal_color()); break; } Debug::check_assertion(internal_surface != NULL, StringConcat() << "Cannot create the text surface for string '" << text << "': " << SDL_GetError()); surface = new Surface(internal_surface); // calculate the coordinates of the top-left corner int x_left = 0, y_top = 0; switch (horizontal_alignment) { case ALIGN_LEFT: x_left = x; break; case ALIGN_CENTER: x_left = x - surface->get_width() / 2; break; case ALIGN_RIGHT: x_left = x - surface->get_width(); break; } switch (vertical_alignment) { case ALIGN_TOP: y_top = y; break; case ALIGN_MIDDLE: y_top = y - surface->get_height() / 2; break; case ALIGN_BOTTOM: y_top = y - surface->get_height(); break; } text_position.set_xy(x_left, y_top); }
void convertPostfix(char infix[], char postfix[]) { /* parenCount checks for paren errors */ int inCount, postCount, check, check2, parenCount; int tmpCount, errorLevel = 0; char *tmpString, mesg[256]; char oper; STACK st; char *prog_name = "postfix module"; inCount = 0; postCount = 0; check2 = 0; parenCount = 0; check = 20; postfix[0] = '\0'; init_stack(&st); for(inCount = 0; infix[inCount] != '\0'; inCount++) { /* if it's a number or a char, just pass it on */ /* need to check for '.' also!!! */ if(isalnum(infix[inCount]) || infix[inCount] == '.' || infix[inCount] == '_') { postfix[postCount++] = infix[inCount]; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif } else if(infix[inCount] == '(') { parenCount++; push('(', &st); /*postfix[postCount++] = ' ';*/ /*postfix[postCount] = '\0';*/ #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif } else if(infix[inCount] == ')') { parenCount--; while((oper = pop(&st)) != '(' && is_empty(st) != 1) { if(oper != '(') { postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf(") detected postfix=%s\n", postfix); #endif postfix[postCount++] = oper; postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf(") detected postfix=%s\n", postfix); #endif } else { postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf(") detected postfix=%s\n", postfix); #endif } } } else if(infix[inCount] == '-') { check2 = 4; if(check2 >= check && is_empty(st) != 1) { postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif oper = pop(&st); if(oper != '(') { postfix[postCount++] = oper; postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif } } else { postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif } push('-', &st); check = check2; } else if(infix[inCount] == '+') { check2 = 3; if(check2 >= check && is_empty(st) != 1) { postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf("Before+pop\n"); #endif oper = pop(&st); #ifdef DEBUG_POST printf("oper=%c\n",oper); #endif if(oper != '(') { postfix[postCount++] = oper; postfix[postCount++] = ' '; postfix[postCount] = '\0'; } } else { postfix[postCount++] = ' '; postfix[postCount] = '\0'; } push('+', &st); #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif check = check2; } else if(infix[inCount] == '*') { check2 = 1; if(check2 >= check && is_empty(st) != 1) { postfix[postCount++] = ' '; postfix[postCount] = '\0'; oper = pop(&st); if(oper != '(') { postfix[postCount++] = oper; postfix[postCount++] = ' '; postfix[postCount] = '\0'; } } else { postfix[postCount++] = ' '; postfix[postCount] = '\0'; } push('*', &st); #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif check = check2; } else if(infix[inCount] == '/') { check2 = 2; if(check2 >= check && is_empty(st) != 1) { postfix[postCount++] = ' '; postfix[postCount] = '\0'; oper = pop(&st); if(oper != '(') { postfix[postCount++] = oper; postfix[postCount++] = ' '; postfix[postCount] = '\0'; } } else { postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif } push('/', &st); #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif check = check2; } else if(infix[inCount] == ' ') { continue; /* ingore spaces in infix for now */ } else { /* error condition */ errorLevel = 1; sprintf(mesg,"%s is not a valid character in the expression", infix[inCount]); ERROR(prog_name, mesg, 1); } } /* end of for loop */ /* now pop the rest of the operators off of the stack */ while(is_empty(st) != 1) { oper = pop(&st); if(oper != '(') { postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf("popping operator %c\n", oper); #endif postfix[postCount++] = oper; postfix[postCount] = '\0'; } #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif } /* adds the last operator to the postfix string */ /*if(oper != '(') { postfix[postCount++] = ' '; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf("popping operator %c\n", oper); #endif postfix[postCount++] = oper; postfix[postCount] = '\0'; #ifdef DEBUG_POST printf("postfix=%s\n", postfix); #endif }*/ /* checks to see that there was an equal number of left and right parentheses */ if(parenCount != 0) { errorLevel = 2; ERROR(prog_name, "Mismatched parentheses in mathematical equation", 1); } #ifdef DEBUG_POST printf("convertPostfix completed\n"); #endif } /* end of convertPostfix() */
int main( int argc, char ** argv ) { stk f, s, t; int i; if( argc == 2 ) n = atoi(argv[1]); else n = 3; init_stack( &f ); init_stack( &s ); init_stack( &t ); for( i = n; i > 0; --i ) push( &f, i ); #ifdef __DEBUG__ printf("\n"); p( f, s, t ); #endif i = 0; while( ( !is_empty( f ) || !is_empty( s ) ) ) { i++; // counter to keep from inf loops int moved; if( ( moved = move( &f, &s ) ) > 0 ) { #ifdef __DEBUG__ printf("moved %d first to second\n", moved ); #endif } else if( ( moved = move( &f, &t ) ) > 0 ) { #ifdef __DEBUG__ printf("moved %d first to third\n", moved ); #endif } else if( ( moved = move( &s, &t ) ) > 0 ) { #ifdef __DEBUG__ printf("moved %d second to third\n", moved ); #endif } else if( ( moved = move( &t, &f ) ) > 0 ) { #ifdef __DEBUG__ printf("moved %d third to first\n", moved ); #endif } else if( ( moved = move( &t, &s ) ) > 0 ) { #ifdef __DEBUG__ printf("moved %d third to second\n", moved ); #endif } else if( ( moved = move( &s, &f ) ) > 0 ) { #ifdef __DEBUG__ printf("moved %d second to first\n", moved ); #endif } else { #ifdef __DEBUG__ printf("NOP\n"); #endif } last_moved = moved; p( f, s, t ); } print_stacks( f, s, t ); printf("\n\nTook %d moves\n", i ); return 0; }
command_t make_command_tree(token_stream_t t) { token_t sub_head = t->head;//the sub_head is t->head token_t token_now = sub_head; stack_t operators = (stack_t)checked_malloc(sizeof(Stack)); stack_t operands = (stack_t)checked_malloc(sizeof(Stack));//build two stacks to hold operands and operators command_t comm;//one command command_t prev = NULL; int line = token_now->line; while(token_now!=NULL) { if( !(token_now->t_type == LEFT_DERCTION || token_now->t_type == RIGHT_DERCTION) ) { // make new command comm = checked_malloc(sizeof( struct command )); } switch(token_now->t_type) { case AND: comm->type = AND_COMMAND; while ( !is_empty(operators) &&( top(operators)->type == PIPE_COMMAND || top(operators)->type == OR_COMMAND || top(operators)->type == AND_COMMAND )) { command_t pop_ops = pop(operators);//pop until the top ops has smaller presendence than if (!make_command_branch(pop_ops, operands)) { error(2, 0, "Line %d: Syntax error. Not enough children to create new tree.", line); return NULL; } } push(operators,comm);//push ADD command to ops break; case OR: comm->type = OR_COMMAND; while ( !is_empty(operators) &&( top(operators)->type == PIPE_COMMAND || top(operators)->type == OR_COMMAND || top(operators)->type == AND_COMMAND )) { command_t pop_ops = pop(operators);//pop until the top ops has smaller presendence than if (!make_command_branch(pop_ops, operands)) { error(2, 0, "Line %d: Syntax error. Not enough children to create new tree.", line); return NULL; } } push(operators,comm);//push ADD command to ops break; // push OR to ops push(operators,comm); break; case PIPELINE: comm->type = PIPE_COMMAND; while ( !is_empty(operators) && top(operators)->type == PIPE_COMMAND ) { command_t pop_ops = pop(operators);//pop until the top ops has smaller presendence than if (!make_command_branch(pop_ops, operands)) { error(2, 0, "Line %d: Syntax error. Not enough children to create new tree.", line); return NULL; } } push(operators,comm);//push PIPE command to ops break; case SEMICOLON: comm->type = SEQUENCE_COMMAND; // always pop since SEMICOLON <= all ops while (!is_empty(operators)) { command_t pop_ops = pop(operators); if (!make_command_branch(pop_ops, operands)) { error(2, 0, "Line %d: Syntax error. Not enough children to create new tree.", line); return NULL; } } // push SEMICOLON to ops push(operators,comm); break; case WORD: comm->type = SIMPLE_COMMAND; //seprated by word int num_words = 1; token_t count = token_now; while(count!=NULL&&count->next!=NULL&&count->next->t_type==WORD)//while next is still word { count = count ->next; num_words++; } comm->u.word[0] = token_now->text; int i =1; while(i< num_words) { token_now = token_now->next; comm->u.word[i] = token_now->text; i++; //if(i == num_words) } comm->u.word[num_words] = NULL; push(operators,comm); break; case SUBSHELL: comm->type = SUBSHELL_COMMAND; // process subshell command tree comm->u.subshell_command = make_command_tree( convert_buffer_to_token_stream(token_now->text, strlen(token_now->text)) ); // push SUBSHELL tree to operands push(operands, comm); break; case LEFT_DERCTION: // check that previous command is a subshell or word if (prev== NULL || !(prev->type == SIMPLE_COMMAND || prev->type == SUBSHELL_COMMAND)) { error(2, 0, "Line %d: Syntax error. ONLY words and SUBSHELL can follow redirection", line); return NULL; } else if (prev->output != NULL) { error(2, 0, "Line %d: Syntax error. Previous command already has output. ", line); return NULL; } else if (prev->input != NULL) { error(2, 0, "Line %d: Syntax error. Previous command already has input.", line); return NULL; } token_now= token_now->next; if (token_now->t_type == WORD) // followed by a word { //which is valid input prev->input = token_now->text; } else { error(2, 0, "Line %d: Syntax error. Redirects must be followed by words.", line); return NULL; } // no pushing required break; case RIGHT_DERCTION: // check that previous command is a subshell or word if (prev== NULL || !(prev->type == SIMPLE_COMMAND || prev->type == SUBSHELL_COMMAND)) { error(2, 0, "Line %d: Syntax error. ONLY words and SUBSHELL can follow redirection", line); return NULL; } else if (prev->output != NULL) { error(2, 0, "Line %d: Syntax error. Previous command already has output. ", line); return NULL; } else if (prev->input != NULL) { error(2, 0, "Line %d: Syntax error. Previous command already has input.", line); return NULL; } token_now= token_now->next; if (token_now->t_type == WORD) // followed by a word { //which is valid output prev->output = token_now->text; } else { error(2, 0, "Line %d: Syntax error. Redirects must be followed by words.", line); return NULL; } // no pushing required break; default: break; }; prev = comm; } while(size(operators) > 0) { command_t pop_ops = pop(operators); if (!make_command_branch(pop_ops, operands)) { error(2, 0, "Line %d: Syntax error. Not enough children to create new tree.", line); return NULL; } } // check for single root if (size(operands) != 1) { error(2, 0, "Line %d: Syntax error. Tree did not converge into single root.", line); return NULL; } command_t root = pop(operands); // the root should be the final tree left in operands return root; }
double farmer(int numprocs) { MPI_Status status; int i, flag, source, w_id; double result, incoming[5], *derp; int w_out[numprocs-1]; // Set up stack stack *stack = new_stack(); double data[5] = {A, B, F(A), F(B), (F(A)+F(B)) * (B-A)/2}; push(data, stack); // Set up queue queue *queue = new_queue(); for (i=1; i<numprocs; i++) { push_queue(i, queue); w_out[i-1] = 0; } while (1) { if (!is_empty(stack)) { derp = pop(stack); w_id = pop_queue(queue); w_out[w_id] = 1; MPI_Send(derp, 5, MPI_DOUBLE, w_id, TAG_DO_TASK, MPI_COMM_WORLD); tasks_per_process[w_id]++; } // peek for messages MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, &status); // if there is a message if (flag) { switch(status.MPI_TAG) { case TAG_ADD_TASK: // receive data and push onto stack source = status.MPI_SOURCE; MPI_Recv(&incoming, 5, MPI_DOUBLE, source, TAG_ADD_TASK, MPI_COMM_WORLD, &status); push(incoming, stack); if (w_out[source]) { push_queue(source, queue); w_out[source] = 0; } break; case TAG_RESULT: source = status.MPI_SOURCE; MPI_Recv(&incoming, 5, MPI_DOUBLE, source, TAG_RESULT, MPI_COMM_WORLD, &status); result += incoming[4]; if (w_out[source]) { push_queue(source, queue); w_out[source] = 0; } break; } } // ready to finish? if (workers_available(queue) == numprocs-1 && is_empty(stack)) { break; } } // kill and free for (i=1; i<numprocs; i++) { MPI_Send(&data, 5, MPI_DOUBLE, i, TAG_KILL, MPI_COMM_WORLD); } free_stack(stack); free_queue(queue); return result; }
Item pop(Stack s) { if (is_empty(s)) terminate("Error in pop: stack is empty."); return s->contents[--s->top]; }
int main(int argn, char** argv) { int xsize, ysize; char c, c2; int i, i2; int x, y; WINDOW* wnd; char buf[50]; tile* temp_tile; /* Inicjalizacja generatora liczb losowych */ srand(time(0)); wnd = initscr(); start_color(); if(has_colors()) { enable_tile_colors(); use_default_colors(); /* Przyporządkuj każdej płytce kolor */ init_pair(1, COLOR_YELLOW, -1); init_pair(2, COLOR_GREEN, -1); init_pair(3, COLOR_RED, -1); init_pair(4, COLOR_YELLOW, -1); init_pair(5, COLOR_WHITE, -1); init_pair(6, COLOR_RED, -1); init_pair(7, COLOR_GREEN, -1); init_pair(8, COLOR_BLUE, -1); init_pair(9, COLOR_CYAN, -1); init_pair(10, COLOR_MAGENTA, -1); } else { disable_tile_colors(); } cbreak(); echo(); nonl(); intrflush(stdscr, FALSE); keypad(stdscr, TRUE); getmaxyx(wnd, ysize, xsize); /* Pobierz docelowy rozmiar */ while(1) { werase(wnd); draw_frame(wnd); wmove(wnd, ysize/2-(MAX_SIZE-MIN_SIZE+2), 20); wprintw(wnd, "Available pool size:"); for(i=MIN_SIZE;i<=MAX_SIZE;i++) { wmove(wnd, ysize/2-(MAX_SIZE-MIN_SIZE+2)+(i-MIN_SIZE+1), 20); attron(COLOR_PAIR(5) | A_BOLD); wprintw(wnd, "%d", i); attroff(COLOR_PAIR(5) | A_BOLD); wprintw(wnd, " for %dx%d", i, i); } wmove(wnd, ysize-2, 2); wprintw(wnd, "Saephir (c), 2010"); wmove(wnd, ysize/2+1, 20); wprintw(wnd, "Type the desired number: "); c = getch(); buf[0] = c; buf[1] = 0; i2 = atoi(buf); if(i2 >= MIN_SIZE && i2 <= MAX_SIZE) { TILES_COUNT = i2; init(); break; } } while(1) { werase(wnd); draw_frame(wnd); /* Wygrana gra */ if(verify()) { print_game(wnd); wmove(wnd, ysize/2, 40); wprintw(wnd, "Well done!"); wmove(wnd, ysize/2+1, 40); wprintw(wnd, "Press ENTER to exit..."); getch(); break; } print_game(wnd); print_pool(wnd); wmove(wnd, ysize-2, 1); wgetnstr(wnd, buf, 49); buf[49] = 0; if(strcmp(buf, "exit") == 0 || strcmp(buf, "quit") == 0 || strcmp(buf, "q") == 0) { break; } else if(strcmp(buf, "help") == 0 || strcmp(buf, "?") == 0) { wmove(wnd, ysize-2, 1); wclrtoeol(wnd); draw_frame(wnd); wmove(wnd, ysize-2, 1); wprintw(wnd, HELP_LINE); getch(); wmove(wnd, ysize-2, 1); wclrtoeol(wnd); draw_frame(wnd); wmove(wnd, ysize-2, 1); wprintw(wnd, HELP_LINE2); getch(); } else if(strcmp(buf, "<<") == 0) { push_left(); } else if(strcmp(buf, ">>") == 0) { push_right(); } else if(strcmp(buf, "^^") == 0) { push_top(); } else if(strcmp(buf, "vv") == 0) { push_bottom(); } else if(sscanf(buf, "%c%d<%c%d", &c, &i, &c2, &i2) == 4) { i--; i2--; if(c == c2 && i == i2) continue; if(c-'a' < 0 || c-'a' >= 2*TILES_COUNT) continue; if(c2-'a' < 0 || c2-'a' >= 2*TILES_COUNT) continue; if(i < 0 || i >= TILES_COUNT) continue; if(i2 < 0 || i2 >= TILES_COUNT) continue; /* Przesuwamy na pole gry */ if(c-'a' < TILES_COUNT) { temp_tile = &game[i][c-'a']; /* Miejsce musi być puste */ if(!is_empty(temp_tile)) continue; /* przesuwamy z puli do gry */ if(c2-'a' >= TILES_COUNT) temp_tile = &pool[i2][c2-'a'-TILES_COUNT]; /* przesuwamy z gry do gry */ else temp_tile = &game[i2][c2-'a']; /* Żródło nie może być puste */ if(is_empty(temp_tile)) continue; move_tile(&game[i][c-'a'], temp_tile); } /* Przesuwamy do puli */ else { temp_tile = &pool[i][c-'a'-TILES_COUNT]; /* Miejsce musi być puste */ if(!is_empty(temp_tile)) continue; /* Przesuwamy z pola gry do puli */ if(c2-'a' < TILES_COUNT) temp_tile = &game[i2][c2-'a']; /* Przesuwamy z puli do puli */ else temp_tile = &pool[i2][c2-'a'-TILES_COUNT]; /* Żródło nie może być puste */ if(is_empty(temp_tile)) continue; move_tile(&pool[i][c-'a'-TILES_COUNT], temp_tile); } } else if(sscanf(buf, "%c%d>%c%d", &c, &i, &c2, &i2) == 4) { i--; i2--; if(c == c2 && i == i2) continue; if(c-'a' < 0 || c-'a' >= 2*TILES_COUNT) continue; if(c2-'a' < 0 || c2-'a' >= 2*TILES_COUNT) continue; if(i < 0 || i >= TILES_COUNT) continue; if(i2 < 0 || i2 >= TILES_COUNT) continue; /* Przesuwamy do puli */ if(c2-'a' >= TILES_COUNT) { temp_tile = &pool[i2][c2-'a'-TILES_COUNT]; /* Miejsce musi być puste */ if(!is_empty(temp_tile)) continue; /* Przesuwamy z pola gry */ if(c-'a' < TILES_COUNT) temp_tile = &game[i][c-'a']; /* Przesuwamy z puli */ else temp_tile = &pool[i][c-'a'-TILES_COUNT]; /* Żródło nie może być puste */ if(is_empty(temp_tile)) continue; move_tile(&pool[i2][c2-'a'-TILES_COUNT], temp_tile); } /* Przesuwamy na pole gry */ else { temp_tile = &game[i2][c2-'a']; /* Miejsce musi być puste */ if(!is_empty(temp_tile)) continue; /* Przesuwamy z puli na pole gry */ if(c-'a' >= TILES_COUNT) temp_tile = &pool[i][c-'a'-TILES_COUNT]; /* Przesuwamy z pola gry na pole gry */ else temp_tile = &game[i][c-'a']; /* Żródło nie może być puste */ if(is_empty(temp_tile)) continue; move_tile(&game[i2][c2-'a'], temp_tile); } } else if(sscanf(buf, "%c%d>pool", &c, &i) == 2 || sscanf(buf, "pool<%c%d", &c, &i) == 2) { i--; if(strcmp(&buf[2], ">pool") != 0) { buf[5] = 0; if(strcmp(buf, "pool<") != 0) continue; } if(c-'a' < 0 || c-'a' >= TILES_COUNT) continue; if(i < 0 || i >= TILES_COUNT) continue; /* Żródło nie może być puste */ if(is_empty(&game[i][c-'a'])) continue; /* Jeżeli źródło nie jest puste, to istnieją wolne miejsca w puli */ /* znajdujemy więc pierwsze wolne miejsce */ for(y=0;y<TILES_COUNT;y++) { for(x=0;x<TILES_COUNT;x++) { if(is_empty(&pool[x][y])) { move_tile(&pool[x][y], &game[i][c-'a']); break; } } } } } endwin(); return 0; }
static void send_presence_soap(struct sipe_core_private *sipe_private, gboolean do_publish_calendar, gboolean do_reset_status) { struct sipe_calendar* cal = sipe_private->calendar; gchar *body; gchar *tmp; gchar *tmp2 = NULL; gchar *res_note = NULL; gchar *res_oof = NULL; const gchar *note_pub = NULL; gchar *states = NULL; gchar *calendar_data = NULL; gchar *epid = get_epid(sipe_private); gchar *from = sip_uri_self(sipe_private); time_t now = time(NULL); gchar *since_time_str = sipe_utils_time_to_str(now); const gchar *oof_note = cal ? sipe_ews_get_oof_note(cal) : NULL; const char *user_input; gboolean pub_oof = cal && oof_note && (!sipe_private->note || cal->updated > sipe_private->note_since); if (oof_note && sipe_private->note) { SIPE_DEBUG_INFO("cal->oof_start : %s", asctime(localtime(&(cal->oof_start)))); SIPE_DEBUG_INFO("sipe_private->note_since : %s", asctime(localtime(&(sipe_private->note_since)))); } SIPE_DEBUG_INFO("sipe_private->note : %s", sipe_private->note ? sipe_private->note : ""); if (!SIPE_CORE_PRIVATE_FLAG_IS(INITIAL_PUBLISH) || do_reset_status) sipe_status_set_activity(sipe_private, SIPE_ACTIVITY_AVAILABLE); /* Note */ if (pub_oof) { note_pub = oof_note; res_oof = SIPE_SOAP_SET_PRESENCE_OOF_XML; cal->published = TRUE; } else if (sipe_private->note) { if (SIPE_CORE_PRIVATE_FLAG_IS(OOF_NOTE) && !oof_note) { /* stale OOF note, as it's not present in cal already */ g_free(sipe_private->note); sipe_private->note = NULL; SIPE_CORE_PRIVATE_FLAG_UNSET(OOF_NOTE); sipe_private->note_since = 0; } else { note_pub = sipe_private->note; res_oof = SIPE_CORE_PRIVATE_FLAG_IS(OOF_NOTE) ? SIPE_SOAP_SET_PRESENCE_OOF_XML : ""; } } if (note_pub) { /* to protocol internal plain text format */ tmp = sipe_backend_markup_strip_html(note_pub); res_note = g_markup_printf_escaped(SIPE_SOAP_SET_PRESENCE_NOTE_XML, tmp); g_free(tmp); } /* User State */ if (!do_reset_status) { if (sipe_status_changed_by_user(sipe_private) && !do_publish_calendar && SIPE_CORE_PRIVATE_FLAG_IS(INITIAL_PUBLISH)) { const gchar *activity_token; int avail_2007 = sipe_ocs2007_availability_from_status(sipe_private->status, &activity_token); states = g_strdup_printf(SIPE_SOAP_SET_PRESENCE_STATES, avail_2007, since_time_str, epid, activity_token); } else /* preserve existing publication */ { if (sipe_private->ocs2005_user_states) { states = g_strdup(sipe_private->ocs2005_user_states); } } } else { /* do nothing - then User state will be erased */ } SIPE_CORE_PRIVATE_FLAG_SET(INITIAL_PUBLISH); /* CalendarInfo */ if (cal && (!is_empty(cal->legacy_dn) || !is_empty(cal->email)) && cal->fb_start && !is_empty(cal->free_busy)) { char *fb_start_str = sipe_utils_time_to_str(cal->fb_start); char *free_busy_base64 = sipe_cal_get_freebusy_base64(cal->free_busy); calendar_data = g_strdup_printf(SIPE_SOAP_SET_PRESENCE_CALENDAR, !is_empty(cal->legacy_dn) ? cal->legacy_dn : cal->email, fb_start_str, free_busy_base64); g_free(fb_start_str); g_free(free_busy_base64); } user_input = (sipe_status_changed_by_user(sipe_private) || sipe_is_user_available(sipe_private)) ? "active" : "idle"; /* generate XML */ body = g_strdup_printf(SIPE_SOAP_SET_PRESENCE, sipe_private->username, sipe_ocs2005_availability_from_status(sipe_private), sipe_ocs2005_activity_from_status(sipe_private), (tmp = g_ascii_strup(g_get_host_name(), -1)), res_note ? res_note : "", res_oof ? res_oof : "", states ? states : "", calendar_data ? calendar_data : "", epid, since_time_str, since_time_str, user_input); g_free(tmp); g_free(tmp2); g_free(res_note); g_free(states); g_free(calendar_data); g_free(since_time_str); g_free(epid); sip_soap_raw_request_cb(sipe_private, from, body, NULL, NULL); g_free(body); }
/* check_source: checks source code for syntax errors */ int check_source(void) { extern char line[]; extern stack_t stack; extern state_t state; extern int comments; extern int quotes; extern int error; int c, d, i; int ln, len; error = 0; ln = 0; comments = quotes = 0; while ((len = getln()) > 0) { ++ln; i = 0; while (i < len && (c = line[i++]) != EOF) { switch (state) { case CODE: if (c == '\'' || c == '"') { state = QUOTES; break; } if (c == '/') { d = line[i++]; if (d == '*') { state = COMMENT; break; } } if (c == '(' || c == '[' || c == '{') { push(&stack, c, ln); } else if (c == ')' || c == ']' || c == '}') { if (is_empty(&stack)) { printf("Syntax error line %d: '%c' doesn't have match.\n", ln, c); error = 1; } else { int val, pos; pop(&stack, &val, &pos); if ((val != '(' && c == ')') || (val != '[' && c == ']') || (val != '{' && c == '}')) { printf("Syntax error line %d: '%c' does not match" " '%c'.\n", pos, val, c); error = 1; } } } break; case QUOTES: if (c == '\\') continue; else if (c == '\'' || c == '"') { quotes++; state = CODE; } break; case COMMENT: if (c == '*') { d = line[i++]; if (d == '/') { comments++; state = CODE; } } break; } } } report(); return 0; }
inline bool basic_cstring<CharT>::empty() const { return is_empty(); }
void *peek(RB) {CHKRB; if (is_empty(RB)) return NULL; return data[s]; }
void ContiguousSpace::object_iterate(ObjectClosure* blk) { if (is_empty()) return; WaterMark bm = bottom_mark(); object_iterate_from(bm, blk); }
void InterpretedIC::clear_without_deallocation_pic() { if (is_empty()) return; set(Bytecodes::original_send_code_for(send_code()), oop(selector()), smiOop_zero); }