t_lex *parser(t_lex *lex) { t_lex *cursor; t_detail *det_error; t_lex *sep_error; cursor = lex; det_error = NULL; sep_error = NULL; while (cursor && !det_error) { if (!is_sep(cursor->str)) { if ((cursor->lst = str_to_lst(cursor->str)) == NULL) return (free_all(lex)); det_error = check_cmd_syntax(cursor->lst); if (!det_error && !(det_error = check_redir(cursor->lst))) assign_redir(cursor->lst, NULL, &det_error); } else cursor->lst = NULL; cursor = cursor->next; } if (det_error) return (free_all(lex)); sep_error = check_sep_syntax(lex); return (sep_error ? free_all(lex) : lex); }
void read_val(const std::string& val_fn){ std::ifstream fp; std::stringstream ss; std::string s; int nx, ny, nz; nx = n[0]; ny = n[1]; nz = n[2]; fp.open(val_fn.c_str()); if(!fp){std::cerr<<"Cannot open file with grid: "<<val_fn<<"\n"; free_all(); exit(1); } for(int ix = 0; ix < nx+4; ix++){ for(int iy = 0; iy < ny+4; iy++){ getline(fp, s); ss.clear(); ss.str(s); int iz = 0; int tmp; while(ss>>tmp){lays[ix][iy][iz] = tmp; iz++; } if(iz != nz+4){std::cerr<<"Value file %s corrupted: layers"<<val_fn<<" "<<ix<<" "<<iy<<" "<<iz<<"\n"; free_all(); exit(1); } } } for(int ip = 0; ip < 5; ip++){ for(int ix = 0; ix < nx+4; ix++){ for(int iy = 0; iy < ny+4; iy++){ getline(fp, s); ss.clear(); ss.str(s); int iz = 0; while(ss>>p[ip][ix][iy][iz]){ iz++; } if(iz != nz+4){std::cerr<<"Value file "<<val_fn<<" "<<ip<<" "<<ix<<" "<<iy<<" "<<iz<<"\n"; free_all();exit(1);} } } } fp.close(); return; }
static unsigned int __stdcall memory_alloc_test_thread_func(void*) { allocs_info* info = new allocs_info; info->count = 0; info->memory = new char*[loop_count]; std::size_t count = 0; while (count < run_count) { for (std::size_t i = 0; i < loop_count; ++i) { std::size_t size = ::rand() % (8 * 1024); #ifdef LARGE_MEMORY size += 20 * 1024; #endif #if defined(CRT_LFH) || defined(TBBMALLOC) || defined(TCMALLOC) info->memory[i] = new char[size]; #elif defined(MS_CONCURRENCY) info->memory[i] = reinterpret_cast<char*>(Concurrency::Alloc(size)); #elif defined(MY_ALLOCATOR) info->memory[i] = reinterpret_cast<char*>(allocator.alloc(size)); #elif defined(JEMALLOC) info->memory[i] = reinterpret_cast<char*>(je_malloc(size)); #endif ++info->count; SecureZeroMemory(info->memory[i], size); //::memset( info->memory[i], 0xff, size ); } #ifdef OTHER_THREAD_FREE unsigned int id = 0; HANDLE free_thread = reinterpret_cast< HANDLE >(::_beginthreadex(nullptr, 0, memory_free_test_thread_func, info, 0, &id)); if (free_thread != nullptr) { ::WaitForSingleObject(free_thread, INFINITE); ::CloseHandle(free_thread); } else { free_all(info); } #else free_all(info); #endif ++count; } delete[] info->memory; info->memory = nullptr; delete info; return 0; }
void exec_cmd_low_level(t_param *param, t_cmd *cmd) { char *path; char *cmd_path; if (my_strstr(cmd->arg[0], "/") == 0) { while ((path = get_next_path(param->env))) { cmd_path = xsmalloc(my_strlen(path) + my_strlen(cmd->arg[0]) + 2); my_strcpy(cmd_path, path); my_strcat(cmd_path, "/"); my_strcat(cmd_path, cmd->arg[0]); xsfree(path); if (access(cmd_path, F_OK) != -1) execve(cmd_path, (cmd->arg), environ); xsfree(cmd_path); } my_fprintf(2, "%s: command not found\n", cmd->arg[0]); } else { execve(cmd->arg[0], cmd->arg, environ); my_fprintf(2, "%s: can't exec\n", cmd->arg[0]); } free_all(param); exit(1); }
int main(int argc, char * argv[]){ FILE *ifp,*ofp; if(argc > 3 || argc < 2) report_exit("error: command inputfile"); ifp = fopen(argv[1], "r") ; ofp = fopen(argv[2], "w") ; if( InputFile(ifp) != 1 ) report_exit("Error reading file"); char buf[80]; int i; FILE * pFig = fopen("cluster.fig","w"); // start to test preprocess_block(&blockage); preprocess_sinks(&sink); construct_g_all(&blockage,&sink); all_pair_shortest(); cluster_sinks(&blockage,&sink); draw_case(pFig); draw_link_sink(pFig); free_clusters(); free_all(); return 0; }
int main(int ac, char **av) { int v; t_map map; t_graph **pile; if (ac != 2) return (1); if (load_map(&map, av[1]) == -1 || create_graph(&map) == -1 || link_room(&map) == -1) return (1); if ((pile = malloc(sizeof(t_graph *))) == NULL) return (1); *pile = NULL; if ((v = search_path(map.start, map.end, &pile)) == 0) { printf("No solution found\n"); return (1); } else if (v == -1) return (2); set_path(map.end); show_map(&map); free(pile); free_all(&map); return (0); }
int main() { int *result[2] = {NULL}; gather_results(result); free_all(result[0], result[1]); exit(EXIT_SUCCESS); }
/* Simple finalization function */ int finalize(thread_t * thread) { SOCK *sock_obj = THREAD_ARG(thread); unsigned char digest_length = HASH_LENGTH(sock_obj); unsigned char digest[digest_length]; int i; /* Compute final hash digest */ HASH_FINAL(sock_obj, digest); if (req->verbose) { printf("\n"); printf(HTML_HASH); dump_buffer((char *) digest, digest_length); printf(HTML_HASH_FINAL); } printf("%s = ", HASH_LABEL(sock_obj)); for (i = 0; i < digest_length; i++) printf("%02x", digest[i]); printf("\n\n"); DBG("Finalize : [%s]\n", req->url); free_all(thread); return 0; }
int main(int ac, char **av) { int flag_exit; struct sockaddr_in sin; t_init data; g_data = &data; signal(SIGPIPE, SIG_IGN); signal(SIGINT, SIG_IGN); srand(time(NULL)); if (get_option_init(ac, av, &data) == -1 || fillstruct(&sin, &data) == -1) return (-1); if ((bind(data.socket, (const struct sockaddr *) &sin, sizeof(sin))) == -1) return (merror("bind")); else printf(STR_LISTENING, data.port); if ((listen(data.socket, 1000)) == -1) return (merror("listen")); aff_options(&data); flag_exit = 0; signal(SIGINT, ctrl_c); while (flag_exit != -1) flag_exit = monitor(&data); close(data.socket); free_all(&data); printf("Job done !\n"); return (EXIT_SUCCESS); }
int main(int ac, char **av) { t_lapin *lapin; t_bunny_pixelarray *tmp; set_max_heap_size(30); lapin = bunny_malloc(sizeof *lapin); if (lapin == NULL) return (84); lapin->format = parse(ac, av); if (lapin->format == 1) tmp = load_bitmap(av[1]); else if (lapin->format == 2) tmp = load_ftn(av[1]); if (lapin->format == -1) return (1); if (lapin->format != -1 && tmp == NULL) tmp = NULL; lapin->pixelarray_2 = tmp; lapin = set_lapin(lapin); lapin->str = av[1]; if (lapin ) bunny_set_loop_main_function(&refresh_my_game); bunny_loop(lapin->window_1, 250, lapin); free_all(lapin); return (0); }
int main(void) { t_env env; int x; x = -1; init_env(&env); get_player(&env); while (1) { get_map(&env); get_piece(&env); if (contact_play(&env, 0, 0) != 1) { if (play(&env, 0, 0) != 1) { if (simple_play(&env) != 1) { ft_putstr("0 0\n"); break ; } } } free_all(&env); } return (0); }
TBufferManager &TBufferManager::operator=(TBufferManager&& other) { free_all(); // Set input fInputBuffer = other.fInputBuffer; fOutputBuffer = other.fOutputBuffer; fInput = other.fInput; fOutput = other.fOutput; fBufferSize = other.fBufferSize; fSampleRate = other.fSampleRate; // Clear output other.fInputBuffer = nullptr; other.fOutputBuffer = nullptr; other.fInput = 0; other.fOutput = 0; other.fBufferSize = 0; other.fSampleRate = 0; return *this; }
/** * Retourne la valeur de sommet de pile, NE d��pile PAS * param p_var : la pile de variables * return : le sommet de la pile */ int get_sommet_var (Pile_var p_var) { if ( p_var.sp <= p_var.segment ) free_all (EXIT_VAR_OUT); return p_var.mem[p_var.sp]; }
/** * Retourne la valeur plac��e �� l'adresse pass��e en param��tre, NE d��pile PAS * param p_var : la pile de variables * return : la valeur de l'adresse pass�� en param��tre */ int get_from_var (Pile_var p_var, int adresse) { if( adresse > p_var.sp || adresse <= PILE_VAR_VIDE ) free_all (EXIT_VAR_INVALID_ADDRESS); return p_var.mem[adresse]; }
int main(){ Item* listptr; int i; listptr = new_item(0); for (i=1; i < 6; i++){ listptr=insert_front(listptr, i); } for (i=0; i < 6; i++){ printf("i %d Item %d\n", i, get(listptr, i)); } listptr = remove_item(listptr, 3); for (i=0; i <= 5; i++){ printf("i %d Item %d\n", i, get(listptr, i)); } printf("Index for 3 %d\n", get_index(listptr, 3)); for (i=1; i < 6; i++){ listptr=insert_back(listptr, i); } for (i=0; i < 12; i++){ printf("i %d Item %d\n", i, get(listptr, i)); } set_item(listptr, 9, 15); for (i=0; i < 12; i++){ printf("i %d Item %d\n", i, get(listptr, i)); } set_item(listptr, 10, 15); free_all(listptr); }
void exit_normal(t_all *all, int exit_ret) { if (exit_ret != 42) free_all(all); reset_term(all); exit(exit_ret); }
void op_end(void) { if (core.flagmode.noverbose == 0) fprintf(stdout, "%s0x%4.x%s > end\n", RED, core.memory.pc, ENDC); free_all(); exit(EXIT_SUCCESS); }
void imt_cleanup( void ) { DBG("imt: cleanup\n"); #if defined(CONFIG_ION_OMAP) free_all(); #endif }
int main(){ // 创建客户链表头结点 PCUSTOMER_HEAD head = (PCUSTOMER_HEAD) Create_List(LIST_CUSTOMER_HEAD); printf("Read data from the file.\n"); // 从文件中读取数据 if (ReadFromFile(head) == TRUE){ printf("Data read success.\n"); } else{ printf("Data does not exist or read failure.\n"); } // print_customers(head->customers); // 显示主界面 view_main(head); printf("\nSave the data to files.\n"); // 保存数据到文件 if (WriteToFile(head) == TRUE){ printf("Save success.\n"); } else{ printf("Save failure.\n"); } printf("\nRelease of lists\n"); // 释放链表 free_all(head); return 0; }
/* Simple epilog functions. */ int epilog(thread_t * thread) { DBG("Timeout on URL : [%s]\n", req->url); free_all(thread); return 0; }
/* Simple finalization function */ int finalize(thread_t * thread) { SOCK *sock_obj = THREAD_ARG(thread); unsigned char digest[16]; int i; /* Compute final MD5 digest */ MD5_Final(digest, &sock_obj->context); if (req->verbose) { printf("\n"); printf(HTML_MD5); dump_buffer((char *) digest, 16); printf(HTML_MD5_FINAL); } printf("MD5SUM = "); for (i = 0; i < 16; i++) printf("%02x", digest[i]); printf("\n\n"); DBG("Finalize : [%s]\n", req->url); free_all(thread); return 0; }
static void qobject_is_equal_num_test(void) { QNum *u0, *i0, *d0, *dnan, *um42, *im42, *dm42; u0 = qnum_from_uint(0u); i0 = qnum_from_int(0); d0 = qnum_from_double(0.0); dnan = qnum_from_double(NAN); um42 = qnum_from_uint((uint64_t)-42); im42 = qnum_from_int(-42); dm42 = qnum_from_double(-42.0); /* Integers representing a mathematically equal number should * compare equal */ check_equal(u0, i0); /* Doubles, however, are always unequal to integers */ check_unequal(u0, d0); check_unequal(i0, d0); /* Do not assume any object is equal to itself -- note however * that NaN cannot occur in a JSON object anyway. */ g_assert(qobject_is_equal(QOBJECT(dnan), QOBJECT(dnan)) == false); /* No unsigned overflow */ check_unequal(um42, im42); check_unequal(um42, dm42); check_unequal(im42, dm42); free_all(u0, i0, d0, dnan, um42, im42, dm42); }
void ExecuteCommand(nodeT **t,char command,int key) { /* printf("\nExcuteCommand Hit here\n");*/ double i; int h; int count; switch (toupper(command)) { case 'I': InsertNode(t, key);break; case 'D': printf("\n");DeleteNode(t, key);printf("\n"); break; case 'F': printf("\n");FindNode(*t,key);printf("\n"); break; case 'O': printf("\n");ListInOrder(*t); printf("\n");break; case 'P': printf("\n");PreOrderWalk(*t);printf("\n"); break; case 'A': printf("\n");PostOrderWalk(*t);printf("\n"); break; case 'L': printf("\n");NodeLevelOrder(*t);printf("\n"); break; case 'S': printf("\n");i=add(*t);printf("Sum of tree is:%f\n",i); break; case 'N': printf("\n");printf("Min:");Min(*t); printf("\n");break; case 'X': printf("\n");printf("Max:");Max(*t); printf("\n");break; case 'T': printf("\n");h=height(*t); printf("Height:%d\n",h);break; case 'C': printf("\n");count=Count(*t); printf("Number of inputs is:%d\n",count);break; case 'H': printf("\n");HelpCommand(); printf("\n");break; case 'Q': free_all(*t);exit(0); default: printf("Illegal command\n"); break; } }
void uninit_flow(struct flow *flow) { DEBUG_MSG(LOG_DEBUG,"uninit_flow() called for flow %d",flow->id); if (flow->fd != -1) close(flow->fd); if (flow->listenfd_data != -1) close(flow->listenfd_data); #ifdef HAVE_LIBPCAP int rc; if (flow->settings.traffic_dump && flow->pcap_thread) { rc = pthread_cancel(flow->pcap_thread); if (rc) logging(LOG_WARNING, "failed to cancel dump thread: %s", strerror(rc)); /* wait for the dump thread to react to the cancellation request */ rc = pthread_join(flow->pcap_thread, NULL); if (rc) logging(LOG_WARNING, "failed to join dump thread: %s", strerror(rc)); } #endif /* HAVE_LIBPCAP */ free_all(flow->read_block, flow->write_block, flow->addr, flow->error); free_math_functions(flow); }
void parserParser::init()/*{{{*/ { if (lexer != NULL) delete lexer; lexer = new orcaFlexLexer; free_all(); n_tok = 0; }
void syscall_exit(void) { uint16_t arg1; arg1 = core.regs.r1; free_all(); exit(arg1); }
/** * REMPLACE la valeur au sommet * Utilis�� pour les r��sultats (des comparaisons / op��rations). * param *pile : la pile de variables * param element : l'��lement �� remplacer sur le sommet */ void push_sommet_var (Pile_var *p_var, int element) { if (p_var->sp <= p_var->segment) free_all (EXIT_VAR_UNDERFLOW); /* Ajout de la valeur */ p_var->mem[p_var->sp] = element; }
int main(UNUSED int ac, UNUSED char **av, char **env) { t_data data; data.user = NULL; data.old_pwd = NULL; signal(SIGINT, SIG_IGN); init_builtins(&data); copy_env(env, &data); if (start_shell(&data) == -2) { free_all(&data); return (my_getnbr(data.cmd[1])); } free_all(&data); return (0); }
/** * Retourne la valeur de SOUS-sommet de pile, NE d��pile PAS * param p_var : la pile de variables * return : le sous-sommet de la pile */ int get_sous_sommet_var (Pile_var p_var) { /* evite l'acces au secteur de stokage des variables */ if ( p_var.sp + 1 <= p_var.segment ) free_all (EXIT_VAR_OUT); return p_var.mem[p_var.sp - 1 ]; }
static void destroy(GtkWidget* widget, gpointer data) { (void) widget; struct s_env_game* game; game = data; free_all(game); gtk_main_quit(); }