static SLang_Foreach_Context_Type * cl_foreach_open (SLtype type, unsigned int num) { SLang_Foreach_Context_Type *c; (void) type; if (num != 0) { _pSLang_verror (SL_NOT_IMPLEMENTED, "%s does not support 'foreach using' form", SLclass_get_datatype_name (type)); return NULL; } if (NULL == (c = (SLang_Foreach_Context_Type *) SLcalloc (1, sizeof (SLang_Foreach_Context_Type)))) return NULL; if (-1 == pop_list (&c->list)) { SLfree ((char *) c); return NULL; } return c; }
void pop_all_list(t_list **t) { void *data; while (42) if ((long)(data = pop_list(t)) < 0) break; }
/*================================================= * append_to_text_list - add onto fixed width string list * newline: flag to not append to last element of list * we build each line in current, and add it to list as done * ptr points to the undone part of text * curptr points to the end (insertion point) of current * NB: We also build list from last to first, so client can use * FORLIST traversal (which is backwards) * TO DO: Break at whitespace *=================================================*/ static void append_to_text_list (LIST list, STRING text, INT width, BOOLEAN newline) { STRING ptr = text; STRING temp, current, curptr; INT len, curlen; if (!text || !text[0]) return; /* pull off last line into temp, to append to */ if (newline) { temp = NULL; } else { temp = pop_list(list); if (temp && (INT)strlen(temp) >= width) { enqueue_list(list, temp); temp = NULL; } } current=stdalloc((width+1)*sizeof(char)); current[0] = 0; curptr = current; curlen = width; if (temp) { llstrcatn(&curptr, temp, &curlen); } while (1) { len = strlen(ptr); if (!len) { /* done */ if (current[0]) { enqueue_list(list, strsave(current)); } stdfree(current); return; } if (len > curlen) len = curlen; temp = curptr; llstrcatn(&curptr, ptr, &curlen); ptr += (curptr - temp); if (!curlen) { /* filled up an item */ enqueue_list(list, strsave(current)); current[0] = 0; curptr = current; curlen = width; } } }
static void list_pop (void) { int indx = 0; SLang_List_Type *list; if (SLang_Num_Function_Args == 2) { if (-1 == SLang_pop_integer (&indx)) return; } if (-1 == pop_list (&list)) return; (void) list_pop_nth (list, indx); free_list (list); }
static int pop_insert_append_args (SLang_List_Type **listp, SLang_Object_Type *obj, int *indx) { if (SLang_Num_Function_Args == 3) { if (-1 == SLang_pop_integer (indx)) return -1; } if (-1 == SLang_pop (obj)) return -1; if (-1 == pop_list (listp)) { SLang_free_object (obj); return -1; } return 0; }
static void list_to_array (void) { SLang_List_Type *list; SLtype type = 0; if ((SLang_Num_Function_Args == 2) && (-1 == SLang_pop_datatype (&type))) return; if (-1 == pop_list (&list)) return; (void) _pSLarray_convert_to_array ((VOID_STAR) list, l2a_get_type_callback, l2a_push_callback, list->length, type); free_list (list); }
int opt_name_team(t_info *info, char **argv, int i) { t_team *team; int flag; while (pop_list(&info->team)); flag = 0; while (argv[i] && (is_options(argv[i]) == -1)) { flag = 1; team = xmalloc(sizeof(*team)); team->name = argv[i]; team->nb = 0; team->max = info->nb_player; push_list(&info->team, team); i++; } return (flag == 1 ? i : -1); }
void destroy_info(t_info *info) { t_list *clients; t_client *client; int i; close(info->socket); clients = info->clients; while ((client = pop_list(&clients))) { free(client->team_name); free(client); } for (i = 0; i < info->x; i++) free(info->object[i]); free(info->object); for (i = 0; i < info->x; i++) free(info->status[i]); free(info->status); }
void move_player_to_pos(t_list *map, t_player *player, \ int x, int y) { t_case *old_cas; t_case *new_cas; if (map && player) { old_cas = find_case_by_index(map, player->x, player->y); new_cas = find_case_by_index(map, x, y); if (old_cas && new_cas) { old_cas->player = pop_list(old_cas->player, player); player->x = x; player->y = y; new_cas->player = append_list(new_cas->player, player); player->spell = false; } } }
static int pop_list_and_index (unsigned int num_indices, SLang_List_Type **listp, SLang_Array_Type **ind_atp, SLindex_Type *indx) { SLang_List_Type *list; *listp = NULL; if (-1 == pop_list (&list)) return -1; if (num_indices != 1) { _pSLang_verror (SL_InvalidParm_Error, "List_Type objects are limited to a single index"); free_list (list); return -1; } *ind_atp = NULL; if (SLang_peek_at_stack () == SLANG_ARRAY_INDEX_TYPE) { if (-1 == SLang_pop_array_index (indx)) { free_list (list); return -1; } } else { if (-1 == _pSLarray_pop_index (list->length, ind_atp, indx)) { free_list (list); return -1; } } *listp = list; return 0; }
int main(int argc, char const *argv[]) { struct LinkList* list = create_list(); append_list(list, 1); insert_list(list, 2, 0); push_list(list, 10); show_list(list); int data = pop_list(list); printf("pop data is %d\n", data); show_list(list); push_list(list, 10); push_list(list, 11); push_list(list, 10); push_list(list, 11); show_list(list); remove_list(list, 1); show_list(list); remove_data_list(list, 10); show_list(list); remove_all_data_list(list, 11); show_list(list); struct Node* node = get_node_list(list, 0); printf("data is %d\n", node->data); int index = search_list(list, 2); printf("index is %d\n", index); destory_list(list); return 0; }
int main(void) { list* l = initialize_list(); list_node* c_node = create_list_node("c"); list_node* a_node = create_list_node("a"); list_node* z_node = create_list_node("z"); list_node* x_node = create_list_node("x"); push_list_node(l, a_node); remove_internal_list_node(l, a_node); push_list_node(l, a_node); push_list(l, "b"); push_list_node(l, c_node); unshift_list_node(l, z_node); unshift_list(l, "y"); unshift_list_node(l, x_node); remove_internal_list_node(l, z_node); remove_internal_list_node(l, a_node); remove_internal_list_node(l, x_node); free_list_node(z_node); free_list_node(a_node); free_list_node(x_node); while(l->length > 0) { printf("%s\n", (char*)pop_list(l)); } unsigned long dl; destroy_list(l, DESTROY_MODE_IGNORE_VALUES, &dl); printf("-------queue test-------------\n"); unsigned long priority; char* id; priority_queue* pq = initialize_priority_queue(); push_priority_queue(pq, 30, "id_1", "value_1"); push_priority_queue(pq, 10, "id_2", "value_2"); push_priority_queue(pq, 10, "id_3", "value_3"); push_priority_queue(pq, 40, "id_4", "value_4"); push_priority_queue(pq, 5, "id_5", "value_5"); push_priority_queue(pq, 30, "id_6", "value_6"); push_priority_queue(pq, 30, "id_7", "value_7"); printf("queue length = %ld\n", pq->length); unsigned long num_destroyed; char* tmp = peek_priority_queue(pq, &priority, &id, 0); printf("first is \"%s\"\n", tmp); set_priority_for_id_in_priority_queue(pq, "id_5", 35); tmp = peek_priority_queue(pq, &priority, &id, 0); printf("first is \"%s\"\n", tmp); set_priority_for_id_in_priority_queue(pq, "id_2", 36); tmp = peek_priority_queue(pq, &priority, &id, 0); printf("first is \"%s\"\n", tmp); /* char** values = (char**)destroy_priority_queue(pq, DESTROY_MODE_RETURN_VALUES, &num_destroyed); int index = 0; for(index = 0; values[index] != NULL; index++) { printf("%s\n", values[index]); } */ while(pq->length > 0) { char* value = (char*)shift_priority_queue(pq, &priority, &id); printf("%s\n", value); free(id); } destroy_priority_queue(pq, DESTROY_MODE_FREE_VALUES, &dl); return 0; }
/* * Function: pop_retrieve * * Purpose: Retrieve a specified message from the maildrop. * * Arguments: * server The server to retrieve from. * message The message number to retrieve. * markfrom * If true, then mark the string "From " at the beginning * of lines with '>'. * msg_buf Output parameter to which a buffer containing the * message is assigned. * * Return value: The number of bytes in msg_buf, which may contain * embedded nulls, not including its final null, or -1 on error * with pop_error set. * * Side effects: May kill connection on error. */ int pop_retrieve (popserver server, int message, int markfrom, char **msg_buf) { int *IDs, *sizes, bufsize, fromcount = 0, cp = 0; char *ptr, *fromserver; int ret; if (server->in_multi) { strcpy (pop_error, "In multi-line query in pop_retrieve"); return (-1); } if (pop_list (server, message, &IDs, &sizes)) return (-1); if (pop_retrieve_first (server, message, &fromserver)) { return (-1); } /* * The "5" below is an arbitrary constant -- I assume that if * there are "From" lines in the text to be marked, there * probably won't be more than 5 of them. If there are, I * allocate more space for them below. */ bufsize = sizes[0] + (markfrom ? 5 : 0); ptr = (char *)malloc (bufsize); free ((char *) IDs); free ((char *) sizes); if (! ptr) { strcpy (pop_error, "Out of memory in pop_retrieve"); pop_retrieve_flush (server); return (-1); } while ((ret = pop_retrieve_next (server, &fromserver)) >= 0) { if (! fromserver) { ptr[cp] = '\0'; *msg_buf = ptr; return (cp); } if (markfrom && fromserver[0] == 'F' && fromserver[1] == 'r' && fromserver[2] == 'o' && fromserver[3] == 'm' && fromserver[4] == ' ') { if (++fromcount == 5) { bufsize += 5; ptr = (char *)realloc (ptr, bufsize); if (! ptr) { strcpy (pop_error, "Out of memory in pop_retrieve"); pop_retrieve_flush (server); return (-1); } fromcount = 0; } ptr[cp++] = '>'; } memcpy (&ptr[cp], fromserver, ret); cp += ret; ptr[cp++] = '\n'; } free (ptr); return (-1); }
int ib_trans_line( /*****************/ section_def *section, int alloc_size ) { char *ptr; char *end; int ch; char *ctx_name; char *ctx_text; char buf[ 100 ]; int indent = 0; int ctr; char *file_name; // check for special pre-processing stuff first ptr = Line_buf; ch = *(unsigned char *)ptr; // We start at a new line... Wrap_Safe = section->section_size; Cursor_X = 0; R_Chars = 0; if( Blank_line && ( ch != CH_LIST_ITEM || Curr_list->compact != LIST_SPACE_COMPACT ) ) { Blank_line = FALSE; } switch( ch ) { // Tabbed-example case CH_TABXMP: if( *skip_blank( ptr + 1 ) == '\0' ) { Tab_xmp = FALSE; } else { read_tabs( ptr + 1 ); Tab_xmp = TRUE; } return( alloc_size ); // Box-mode start case CH_BOX_ON: ctr = 0; // indent properly while( ctr < Curr_indent ) { ctr++; trans_add_char( ' ', section, &alloc_size); } // draw the top line of the box trans_add_char( BOX_CORNER_TOP_LEFT, section, &alloc_size ); for( ctr = 1; ctr <= Right_Margin - Curr_indent - 2; ctr++ ) { trans_add_char( BOX_HBAR, section, &alloc_size ); } trans_add_char( BOX_CORNER_TOP_RIGHT, section, &alloc_size ); trans_add_char_wrap( '\n', section, &alloc_size); Box_Mode = TRUE; return( alloc_size ); case CH_BOX_OFF: ctr = 0; while( ctr < Curr_indent ) { ctr++; trans_add_char( ' ', section, &alloc_size); } trans_add_char( BOX_CORNER_BOTOM_LEFT, section, &alloc_size ); for( ctr = 1; ctr <= Right_Margin - Curr_indent - 2; ctr++ ) { trans_add_char( BOX_HBAR, section, &alloc_size ); } trans_add_char( BOX_CORNER_BOTOM_RIGHT, section, &alloc_size ); Box_Mode = FALSE; trans_add_char_wrap( '\n', section, &alloc_size ); return( alloc_size ); case CH_OLIST_START: new_list( LIST_TYPE_ORDERED ); set_compact( ptr ); Curr_indent += Text_Indent; return( alloc_size ); case CH_LIST_START: case CH_DLIST_START: new_list( ( ch == CH_LIST_START ) ? LIST_TYPE_UNORDERED : LIST_TYPE_DEFN ); set_compact( ptr ); Curr_indent += Text_Indent; if( ch == CH_DLIST_START ) { ptr = skip_blank( ptr + 1 ); if( *ptr != '\0' ) { /* due to a weakness in GML, the definition term must be allowed on the same line as the definition tag. So if its there, continue */ break; } } return( alloc_size ); case CH_DLIST_TERM: Curr_indent -= Text_Indent; break; case CH_SLIST_START: indent = 0; if( Curr_list->type == LIST_TYPE_SIMPLE ) { /* nested simple lists, with no pre-indent. Force an indent */ indent = Text_Indent; } new_list( LIST_TYPE_SIMPLE ); set_compact( ptr ); Curr_indent += indent; return( alloc_size ); case CH_SLIST_END: case CH_OLIST_END: case CH_LIST_END: case CH_DLIST_END: pop_list(); return( alloc_size ); case CH_DLIST_DESC: Curr_indent += Text_Indent; if( *skip_blank( ptr + 1 ) == '\0' ) { /* no description on this line. Ignore it so that no blank line gets generated */ return( alloc_size ); } break; case CH_CTX_KW: ptr = whole_keyword_line( ptr ); if( ptr == NULL ) { return( alloc_size ); } break; } // skip preceding blank lines if( *skip_blank( ptr ) == '\0' && Curr_ctx->empty ) { return( alloc_size ); } // remove '\n' on the end if( Blank_line ) { --section->section_size; } // indent properly if the first char is not white-space if( ch != '\0' && ch != ' ' && ch != '\t') { ctr = ( ch == CH_LIST_ITEM && !Box_Mode && Curr_list->type != LIST_TYPE_SIMPLE ) ? Text_Indent : 0; while( ctr < Curr_indent ) { ctr++; trans_add_char_wrap( ' ', section, &alloc_size); } if( Box_Mode ) { trans_add_char_wrap( BOX_VBAR, section, &alloc_size); trans_add_char_wrap( ' ', section, &alloc_size); } } Blank_line = TRUE; for( ;; ) { ch = *(unsigned char *)ptr; if( ch != '\0' && ( ch != ' ' || ch != '\t' ) ) { Blank_line = FALSE; } if( ch == '\0' ) { // this just shuts off bolding after a def. list term if( Line_postfix == LPOSTFIX_TERM ) { Line_postfix = LPOSTFIX_NONE; trans_add_str( STR_BOLD_OFF, section, &alloc_size ); } trans_add_char_wrap( '\n', section, &alloc_size ); break; } else if( ch == CH_HLINK || ch == CH_DFN || ch == CH_FLINK ) { Curr_ctx->empty = FALSE; if( ch == CH_FLINK ) { file_name = strchr( ptr + 1, ch ); if( file_name == NULL ) { error( ERR_BAD_LINK_DFN, TRUE ); } *file_name = '\0'; } else { file_name = ptr; } ctx_name = strchr( file_name + 1, ch ); if( ctx_name == NULL ) { error( ERR_BAD_LINK_DFN, TRUE ); } *ctx_name = '\0'; ctx_text = strchr( ctx_name + 1, ch ); if( ctx_text == NULL ) { error( ERR_BAD_LINK_DFN, TRUE ); } *ctx_text = '\0'; ctx_text = ctx_name + 1; ctx_name = file_name + 1; file_name = ptr + 1; if( ch != CH_FLINK ) { add_link( ctx_name ); } ptr = ctx_text + strlen( ctx_text ) + 1; // Definition pop-up's are converted to hyper-links in InfoBench trans_add_char( CHR_TEMP_HLINK , section, &alloc_size ); // Add line number to hyperlink so we can give meaningful errors trans_add_str( itoa( Line_num, buf, 10 ), section, &alloc_size ); trans_add_char( CHR_TEMP_HLINK, section, &alloc_size ); // We don't want links to break as IB doesn't like this... to_nobreak( ctx_text ); indent = Curr_indent; if( indent < 0 ) indent = 0; // find out the maximum allowed length for hyper-link text: ctr = Right_Margin - indent - ( ( Hyper_Brace_L == '<' ) ? 2 : 0 ); // if the link name is too long then we warn & truncate it if( strlen( ctx_text ) > ctr ) { warning( "Hyperlink name too long", Line_num ); ctx_text[ ctr ] = '\0'; } /* If hyper-link bracing is on we have to do a kludge to fix * the spacing. The "XX" will make the wrap routine happy. * They're stripped off when it comes time to write the file. */ if( Hyper_Brace_L == '<' ) { trans_add_str_wrap( "XX", section, &alloc_size ); } trans_add_str_wrap( ctx_text, section, &alloc_size ); trans_add_char( CHR_HLINK_BREAK , section, &alloc_size ); trans_add_str( ctx_name, section, &alloc_size ); if( ch == CH_FLINK ) { trans_add_char( CHR_HLINK_BREAK, section, &alloc_size ); trans_add_str( file_name, section, &alloc_size ); } trans_add_char( CHR_TEMP_HLINK , section, &alloc_size ); } else if( ch == CH_LIST_ITEM ) { if( Curr_list->type != LIST_TYPE_SIMPLE ) { if( Curr_list->type == LIST_TYPE_UNORDERED ) { // generate a bullet, correctly spaced for tab size buf[0] = '\0'; for( ctr = 1; ctr <= Text_Indent; ctr++) { strcat( buf, " " ); } buf[ Text_Indent / 2 - 1 ] = CHR_BULLET; } else if( Curr_list->type == LIST_TYPE_ORDERED ) { /* ordered list type */ sprintf( buf, "%*d. ", Text_Indent - 2, Curr_list->number ); ++Curr_list->number; } trans_add_str_wrap( buf, section, &alloc_size ); } Eat_blanks = TRUE; ptr = skip_blank( ptr + 1 ); } else if( ch == CH_DLIST_DESC ) { ptr = skip_blank( ptr + 1 ); } else if( ch == CH_DLIST_TERM ) { /* definition list term */ trans_add_str( STR_BOLD_ON, section, &alloc_size ); Line_postfix = LPOSTFIX_TERM; ptr = skip_blank( ptr + 1 ); Eat_blanks = TRUE; } else if( ch == CH_CTX_KW ) { end = strchr( ptr + 1, CH_CTX_KW ); memcpy( buf, ptr + 1, end - ptr - 1 ); buf[end - ptr - 1] = '\0'; add_ctx_keyword( Curr_ctx, buf ); ptr = end + 1; if( *ptr == ' ' ) { /* kludge fix cuz of GML: GML thinks that keywords are are real words, so it puts a space after them. This should fix that */ ++ptr; } } else if( ch == CH_PAR_RESET ) { // we ignore paragraph resets ++ptr; } else if( ch == CH_BMP ) { // we ignore bitmaps ptr = strchr( ptr + 3, CH_BMP ) + 1; } else if( ch == CH_FONTSTYLE_START ) { ++ptr; end = strchr( ptr, CH_FONTSTYLE_START ); for( ; ptr != end; ++ptr ) { switch( *ptr ) { // bold and italic map to bold case 'b': case 'i': trans_add_str( STR_BOLD_ON, section, &alloc_size ); break; // underline and underscore map to underline case 'u': case 's': trans_add_str( STR_UNDERLINE_ON, section, &alloc_size ); break; } } ++ptr; } else if( ch == CH_FONTSTYLE_END ) { // reset style (bold off, underline off) trans_add_str( Reset_Style, section, &alloc_size ); ++ptr; } else if( ch == CH_FONTTYPE ) { // we basically ignore font type changes ptr = strchr( strchr( ptr + 1 , CH_FONTTYPE ) + 1, CH_FONTTYPE ) + 1; } else { ++ptr; if( !Eat_blanks || ch != ' ' ) { Curr_ctx->empty = FALSE; if( Tab_xmp && ch == Tab_xmp_char ) { tab_align( section, &alloc_size ); ptr = skip_blank( ptr ); } else { trans_add_char_wrap( ch, section, &alloc_size ); } Eat_blanks = FALSE; } } } return( alloc_size ); }
int main(int argc, char **argv) { char *table = argv[1]; char *delete_chain = argv[2]; if(argc != 3) { printf("USAGE: %s [TABLE] [CHAIN TO DELETE]\n\n", argv[0]); return 0; } char *command = dynamic_strcat(3, "iptables -t ", table, " -L -n --line-numbers 2>/dev/null"); unsigned long num_lines = 0; char** table_dump = get_shell_command_output_lines(command, &num_lines); free(command); unsigned long line_index; char* current_chain = NULL; list* delete_commands = initialize_list(); for(line_index=0; line_index < num_lines; line_index++) { char* line = table_dump[line_index]; unsigned long num_pieces = 0; char whitespace[] = { '\t', ' ', '\r', '\n' }; char** line_pieces = split_on_separators(line, whitespace, 4, -1, 0, &num_pieces); if(strcmp(line_pieces[0], "Chain") == 0) { if(current_chain != NULL) { free(current_chain); } current_chain = strdup(line_pieces[1]); } else { unsigned long line_num; int read = sscanf(line_pieces[0], "%ld", &line_num); if(read > 0 && current_chain != NULL && num_pieces >1) { if(strcmp(line_pieces[1], delete_chain) == 0) { char* delete_command = dynamic_strcat(7, "iptables -t ", table, " -D ", current_chain, " ", line_pieces[0], " 2>/dev/null"); push_list(delete_commands, delete_command); } } } //free line_pieces free_null_terminated_string_array(line_pieces); } free_null_terminated_string_array(table_dump); /* final two commands to flush chain being deleted and whack it */ unshift_list(delete_commands, dynamic_strcat(5, "iptables -t ", table, " -F ", delete_chain, " 2>/dev/null")); unshift_list(delete_commands, dynamic_strcat(5, "iptables -t ", table, " -X ", delete_chain, " 2>/dev/null")); /* run delete commands */ while(delete_commands->length > 0) { char *next_command = (char*)pop_list(delete_commands); char **out = get_shell_command_output_lines(next_command, &num_lines); free_null_terminated_string_array(out); } return 0; }
int SLang_pop_list (SLang_List_Type **list) { return pop_list (list); }
static void levelup(t_client *client, t_info *info) { t_list *t; t_client *c; void *data; int x; int y; t = info->zone[client->x][client->y].clients; while (t) { c = t->data; c->level++; SEND(c->buf_write, LVLUP_OK); putnbr(c->level, c->buf_write); SEND(c->buf_write, "\n"); t = t->next; } while ((data = pop_list(&(info->zone[client->x][client->y].ressources)))) { x = get_random(info->x, client->x); y = get_random(info->y, client->y); push_list(&(info->zone[x][y].ressources), data); obs_send_new_item(info->observator, x, y, data); } }