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();
}
