Ejemplo n.º 1
0
SWITCH_DECLARE_CONSTRUCTOR CoreSession::CoreSession(char *nuuid, CoreSession *a_leg)
{
	switch_channel_t *other_channel = NULL;

	init_vars();

	if (a_leg && a_leg->session) {
		other_channel = switch_core_session_get_channel(a_leg->session);
	}

	if (!strchr(nuuid, '/') && (session = switch_core_session_force_locate(nuuid))) {
		uuid = strdup(nuuid);
		channel = switch_core_session_get_channel(session);
		allocated = 1;
    } else {
		cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
		if (switch_ivr_originate(a_leg ? a_leg->session : NULL, &session, &cause, nuuid, 60, NULL, NULL, NULL, NULL, NULL, SOF_NONE, NULL) 
			== SWITCH_STATUS_SUCCESS) {
			channel = switch_core_session_get_channel(session);
			allocated = 1;
			switch_set_flag(this, S_HUP);
			uuid = strdup(switch_core_session_get_uuid(session));
			switch_channel_set_state(switch_core_session_get_channel(session), CS_SOFT_EXECUTE);
			switch_channel_wait_for_state(channel, other_channel, CS_SOFT_EXECUTE);
		}
	}
}
Ejemplo n.º 2
0
int main(int argc, char *argv[]) {
	GtkWidget *window;
	GtkWidget *darea;

	init_vars();

	gtk_init(&argc, &argv);

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

	darea = gtk_drawing_area_new();
	gtk_container_add(GTK_CONTAINER(window), darea);

	g_signal_connect(G_OBJECT(darea), "draw", G_CALLBACK(on_draw_event), NULL);
	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);

	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_window_set_default_size(GTK_WINDOW(window), 325, 250);
	gtk_window_set_title(GTK_WINDOW(window), "Spectrum");

	g_timeout_add(400, (GSourceFunc) time_handler, (gpointer) window);

	gtk_widget_show_all(window);

	gtk_main();

	cairo_surface_destroy(glob.image);
	cairo_surface_destroy(glob.surface);

	return 0;
}
Ejemplo n.º 3
0
int main(int argc, char **argv) {
   //
   // variables
   //
   struct fab_vars v;
   init_vars(&v);
   //
   // command line args
   //
   if (argc != 3) {
      printf("command line: array_states_png.c in.array out.png\n");
      exit(-1);
      }
   //
   // read array
   //
   fab_read_array(&v,argv[1]);
   //
   // shade states
   //
   fab_shade_states(&v);
   //
   // write PNG
   //
   fab_write_png(&v,argv[2]);
   }
Ejemplo n.º 4
0
// set up default entries and initialise variables
void corn_init() {
  // set "constants"
  INBUF_START = (address)(memory_start + sizeof(struct sys_const) + sizeof(struct sys_var));
  INBUF_END = INBUF_START + INBUF_BYTES;

  DSTACK_START = INBUF_END;
  DSTACK_END = DSTACK_START + DSTACK_WORDS * WORDSIZE;

  RSTACK_START = DSTACK_END;
  RSTACK_END = RSTACK_START + RSTACK_WORDS * WORDSIZE;

  SCRATCH_START = RSTACK_END;
  SCRATCH_END = SCRATCH_START + SCRATCH_BYTES;

  POOL_START = SCRATCH_END;
  POOL_END = POOL_START + POOL_BYTES;

  // set "variables"

  HEAP_NEXT = POOL_START;
  POOL_HEAD = 0;
  DICT_HEAD = 0;

  // Add dummy entry to heap
  padd(INBUF_START,0);

  reset_working_data();

  init_vars();
  init_prims();
  init_defs();

  reset_working_data();
}
Ejemplo n.º 5
0
long my_ferry_start()
{
	//Handle if ferry gets a start request after already starting
	if(ferry_active == 1)
	{
		printk("%s: Ferry has already been started\n", __FUNCTION__);		
		return 1;
	}

	printk("%s: Ferry started!\n", __FUNCTION__);

	//Initialize mutex
	mutex_init(&lock);	
	
	//Initialize all variables
	init_vars();		

	//Initialize proc entry
	proc_entry = create_proc_entry(PROC_NAME, 0444, NULL);

	//begin ferry thread
	ferry_thread = kthread_run(begin_ferry, NULL, "ferry_thread");

	return 0;
}
Ejemplo n.º 6
0
int main (int argc, char ** argv)
{
    int err;

    MPI_Init (&argc, &argv);
    MPI_Comm_rank (comm, &rank);
    MPI_Comm_size (comm, &size);

    init_vars();
    adios_init_noxml (comm);
    err = adios_read_init_method(ADIOS_READ_METHOD_BP, comm, "verbose=2");
    if (err) {
        printE ("%s\n", adios_errmsg());
    }

    if (!err)
        err = declare_group ();
    if (!err)
        err = write_file ("reuse_dim.bp");
    if (!err)
        err = read_file ("reuse_dim.bp");

    adios_finalize (rank);
    fini_vars();
    MPI_Finalize ();
    return err;
}
Ejemplo n.º 7
0
int main(int argc, char **argv) {
   //
   // variables
   //
   struct fab_vars v;
   init_vars(&v);
   int threshold;
   //
   // command line args
   //
   if (argc != 4) {
      printf("command line: array_slice in.array out.array threshold\n");
      exit(-1);
      }
   //
   // read lattice
   //
   fab_read_array(&v,argv[1]);
   //
   // threshold
   //
   sscanf(argv[3],"%d",&threshold);
   fab_threshold(&v,threshold);
   //
   // write state slice
   //
   fab_write_array(&v,argv[2]);
   }
Ejemplo n.º 8
0
void my_sort_list(t_list **begin, int (*cmp)(), int w)
{
  t_list *prev;
  t_list *next;
  t_list *curr;
  t_list *first;
  int c;
  c = my_list_size(*begin);
  while (c != 0)
  {
    init_vars(&curr, begin , &prev);
    while (curr->next != NULL)
    {
      next = curr->next;
      if (cmp((w == 0) ? curr->fword : curr->wword, (w == 0) ? next->fword : next->wword ) > 0)
      {
	curr->next = next->next;
	next->next = curr;
	save_back(&prev, &next);
	curr = next;
      }
      (prev == NULL) ? savFirst(&first, &curr, 1) : savFirst(&first, &curr, 0);
      prev = curr;
      curr = curr->next;
    }
    *begin = first;
    c--;
  }
}
static int quickdnr(VideoFilter *f, VideoFrame *frame, int field)
{
    (void)field;
    ThisFilter *tf = (ThisFilter *)f;
    int thr1[3], thr2[3], height[3];
    uint8_t *avg[3], *buf[3];
    int i, y;

    TF_VARS;

    TF_START;

    if (!init_avg(tf, frame))
        return 0;

    init_vars(tf, frame, thr1, thr2, height, avg, buf);

    for (i = 0; i < 3; i++)
    {
        int sz = height[i] * frame->pitches[i];
        for (y = 0; y < sz; y++)
        {
            if (abs(avg[i][y] - buf[i][y]) < thr1[i])
                buf[i][y] = avg[i][y] = (avg[i][y] + buf[i][y]) >> 1;
            else
                avg[i][y] = buf[i][y];
        }
    }
Ejemplo n.º 10
0
void		show_tab(int *tab, int tab_size)
{
  t_vars	v;
  int		nline;

  nline = 1;
  v.space = tab_size + 2;
  init_vars(&v);
  while (v.i < tab_size)
    {
      v.j = 0;
      my_put_nbr(nline++);
      my_putchar('.');
      v.k = (nline > 10) ? 1 : 0;
      while (v.k++ < v.space)
	my_putchar(' ');
      while (v.j < tab[v.i])
	{
	  my_putchar('|');
	  v.j++;
	}
      my_putchar('\n');
      v.i++;
      v.space--;
    }
}
Ejemplo n.º 11
0
main(int argc, char **argv) {
   //
   // local vars
   //
   struct fab_vars v;
   init_vars(&v);
   //
   // command line args
   //
   if ((argc < 3) || (argc > 3)) {
      printf("command line: png_drl in.png out.drl\n");
      printf("   in.png = input PNG file\n");
      printf("   out.drl = output Excellon file\n");
      exit(-1);
      }
   //
   // read PNG
   //
   fab_read_png(&v,argv[1]);
   //
   // copy image to array
   //
   fab_png_array(&v);
   //
   // write array to Excellon
   //
   fab_write_drl(&v,argv[2]);
   //
   // exit
   //
   exit(0);
   }
Ejemplo n.º 12
0
int
main(int argc, char *argv[])
{
    CATCHALL(die);

    setlocale(LC_ALL, "");

    initscr();

    /*
     * We use COLOR_GREEN because COLOR_BLACK is wired to the wrong thing.
     */
    start_color();
    init_pair(RED_ON_WHITE, COLOR_RED, COLOR_WHITE);
    init_pair(BLUE_ON_WHITE, COLOR_BLUE, COLOR_WHITE);
    init_pair(BLACK_ON_WHITE, COLOR_BLACK, COLOR_WHITE);

#ifndef COLOR_PAIR
    letters[0] = OR_COLORS('h', RED_ON_WHITE);	/* hearts */
    letters[1] = OR_COLORS('s', BLACK_ON_WHITE);	/* spades */
    letters[2] = OR_COLORS('d', RED_ON_WHITE);	/* diamonds */
    letters[3] = OR_COLORS('c', BLACK_ON_WHITE);	/* clubs */
#if USE_CP437
    glyphs[0] = PC_COLORS('\003', RED_ON_WHITE);	/* hearts */
    glyphs[1] = PC_COLORS('\006', BLACK_ON_WHITE);	/* spades */
    glyphs[2] = PC_COLORS('\004', RED_ON_WHITE);	/* diamonds */
    glyphs[3] = PC_COLORS('\005', BLACK_ON_WHITE);	/* clubs */
#endif
#endif

#if USE_CP437
    if (tigetstr("smpch"))
	suits = glyphs;
#endif /* USE_CP437 */

    cbreak();

    if (argc == 2)
	srand((unsigned) atoi(argv[1]));
    else
	srand((unsigned) time((time_t *) 0));

    init_vars();

    do {
	deal_number++;
	shuffle(deck_size);
	deal_cards();
	display_cards(deal_number);
	play_game();
    }
    while
	((deck_size = collect_discards()) != 0);

    game_finished(deal_number);

    die(SIGINT);
    /*NOTREACHED */
}
Ejemplo n.º 13
0
const char*
request_get_url_path()
{
	if (!path)
		init_vars();

	return path;
}
Ejemplo n.º 14
0
const char*
request_get_path_variable(const char* key)
{
	if (!varTable)
		init_vars();

	return g_hash_table_lookup(varTable, key);
}
Ejemplo n.º 15
0
int main(int argc, char *argv[])
{
    (void) signal(SIGINT, die);
    initscr();

    /*
     * We use COLOR_GREEN because COLOR_BLACK is wired to the wrong thing.
     */
    start_color();
    init_pair(RED_ON_WHITE,    COLOR_RED,   COLOR_WHITE);
    init_pair(BLUE_ON_WHITE,   COLOR_BLUE,  COLOR_WHITE);
    init_pair(BLACK_ON_WHITE,  COLOR_BLACK, COLOR_WHITE);

#ifndef COLOR_PAIR
    letters[0] = 'h' | COLOR_PAIR(RED_ON_WHITE);	/* hearts */
    letters[1] = 's' | COLOR_PAIR(BLACK_ON_WHITE);	/* spades */
    letters[2] = 'd' | COLOR_PAIR(RED_ON_WHITE);	/* diamonds */
    letters[3] = 'c' | COLOR_PAIR(BLACK_ON_WHITE);	/* clubs */
#if defined(__i386__) && defined(A_ALTCHARSET)
    glyphs[0]  = '\003' | A_ALTCHARSET | COLOR_PAIR(RED_ON_WHITE);	/* hearts */
    glyphs[1]  = '\006' | A_ALTCHARSET | COLOR_PAIR(BLACK_ON_WHITE);	/* spades */
    glyphs[2]  = '\004' | A_ALTCHARSET | COLOR_PAIR(RED_ON_WHITE);	/* diamonds */
    glyphs[3]  = '\005' | A_ALTCHARSET | COLOR_PAIR(BLACK_ON_WHITE);	/* clubs */
#endif
#endif

#if defined(__i386__) && defined(A_ALTCHARSET)
    if (tigetstr("smpch"))
	suits = glyphs;
#endif /* __i386__ && A_ALTCHARSET */

    cbreak();

    if (argc == 2)
	srand((unsigned)atoi(argv[1]));
    else
	srand((unsigned)time((time_t *)0));

    init_vars();

    do{
	deal_number++;
	shuffle(deck_size);
	deal_cards();
	display_cards(deal_number);
	play_game();
    }
    while
	((deck_size=collect_discards()) != 0);

    game_finished(deal_number);

    die(SIGINT);
    /*NOTREACHED*/
}
Ejemplo n.º 16
0
void run_ecc_tests() {
    int i = 0;

    init_vars();
    while(ecc_functions[i] != NULL) {
        (*ecc_functions[i])();
        printf("OK\n");
        i++;
        numTests++;
    }
}
Ejemplo n.º 17
0
uni::uni(int i_size)
{
 	init_vars();
  //init unicode member
  	if (i_size > 0)
	{
	
	//LogMsg("Created string of %d bytes.",i_size);
	this->us_data = (unsigned short*) malloc(2*i_size);
 	memset(us_data,0,2*i_size);
	}
}
Ejemplo n.º 18
0
SWITCH_DECLARE_CONSTRUCTOR CoreSession::CoreSession(switch_core_session_t *new_session)
{
	init_vars();

	if (new_session) {
		session = new_session;
		channel = switch_core_session_get_channel(session);
		allocated = 1;
		switch_core_session_read_lock_hangup(session);
		uuid = strdup(switch_core_session_get_uuid(session));
	}
}
Ejemplo n.º 19
0
void camera_init(int *fd, camera_buffer *camera_buffers, int camera_count){
	int i;
	const char *dev_names[MAX_DEV_COUNT]={"/dev/video0","/dev/video4","/dev/video2","/dev/video3"};
	if(camera_count>MAX_DEV_COUNT){
		fprintf(stderr,"error: camera_count must equal or less than %d\n",MAX_DEV_COUNT);
		exit(EXIT_FAILURE);
	}
	init_vars(fd,camera_buffers,camera_count);
	for (i=0;i<camera_count;i++){
		open_device(&fd[i],dev_names[i]);
		init_device(fd[i],&camera_buffers[i],dev_names[i]);
		start_capturing(fd[i],&camera_buffers[i]);
	}
}
Ejemplo n.º 20
0
int main(int argc, char *argv[], char *envp[])
{
    (void) envp;

    // TODO bring in good malloc/free and implement sbrk()!
    //static char arena[1024*1024];
    //init_malloc( arena, sizeof(arena) );

    printf("Phantom Simple Unix Box Shell is running, pid %d\n", getpid());

#if 0
    printf("ac = %d\n", argc );
    char **avp = argv;
    while( *avp )
    {
        printf("arg = %p\n", *avp );
        printf("arg = '%s'\n", *avp++ );
    }
#endif


    init_vars();
    init_statements();
    init_arguments(argc,argv);

    if(af_script_file_name != NULL)
    {
        run_script(af_script_file_name);
        if(af_exit_after_script) exit(0);
    }

    setvbuf( stdin, 0, _IONBF, 0 );
    //setvbuf( stdout, 0, _IONBF, 0 );

    char buf[1024];

    for(;;) {

        printf("> ");

        getline(buf, sizeof(buf));
        if(strlen(buf) > 0) {
            parse_string(buf);
        }
        buf[0] = '\0';
    }

    return 0;
}
Ejemplo n.º 21
0
uni::uni(const char st_source[])
{
 init_vars();
  //convert source to unicode
  
 set(st_source);
 //let's also store a copy in our own st_data for no good reason
 if (st_source)
 {
 
 st_data = (CHAR*) malloc(strlen(st_source)+1);
 strcpy(st_data, st_source);
 }

}
Ejemplo n.º 22
0
main(int argc, char **argv) {
   //
   // local vars
   //
   struct fab_vars v;
   init_vars(&v);
   float xmin,ymin,force,velocity;
   //
   // command line args
   //
   if (!((argc == 3) || (argc == 4) || (argc == 5) || (argc == 7))) {
      printf("command line: path_camm in.path out.camm [force [velocity [xmin ymin]]]\n");
      printf("   in.path = input path file\n");
      printf("   out.camm = output Roland vinylcutter file\n");
      printf("   force = cutting force (optional, grams, default 45)\n");
      printf("   velocity = cutting speed (optional, cm/s, default 2)\n");
      printf("   xmin = left position (optional, mm, default path value)\n");
      printf("   ymin = bottom position (optional, mm, default path value)\n");
      exit(-1);
      }
   if (argc == 3) {
      force = 45;
      velocity = 2;
      }
   else if (argc == 4) {
      sscanf(argv[3],"%f",&force);
      velocity = 2;
      }
   else if (argc == 5) {
      sscanf(argv[3],"%f",&force);
      sscanf(argv[4],"%f",&velocity);
      }
   //
   // read path
   //
   fab_read_path(&v,argv[1]);
   //
   // origin
   //
   if (argc == 7) {
      sscanf(argv[5],"%lf",&v.xmin);
      sscanf(argv[6],"%lf",&v.ymin);
      }
   //
   // write .epi
   //
   fab_write_camm(&v,argv[2],force,velocity);
   }
Ejemplo n.º 23
0
// 08111368
void flashback_2() {
	prev_quest_mode = 1;
	init_vars();
	bag_809A2DC();
	sub_809A2A4();
	if (questlog_active_at_cursor()) {
		sub_8111274(flashback_cursor, 0);
		hm_phase_1 = &hmp1_8111038;
		set_callback2(&c2_080572A8);
	} else {
		sub_8111274(flashback_cursor, 1);
		warp_in_metadata();
		hm_phase_1 = &hmp1_8111000;
		set_callback2(&c2_0805726C);
	}
}
Ejemplo n.º 24
0
int main(int argc, char **argv) {
   //
   // local vars
   //
   struct fab_vars v;
   init_vars(&v);
   float units,resolution;
   //
   // command line args
   //
   if (!((argc == 3) || (argc == 4) || (argc == 5))) {
      printf("command line: stl_path in.stl out.path [units [resolution]]]\n");
      printf("   in.stl = input binary STL file\n");
      printf("   out.png = output PNG file\n");
      printf("   units = file units (optional, mm/unit, default 1)\n");
      printf("   resolution = image resolution (optional, pixels/mm, default 10)\n");
      exit(-1);
      }
   if (argc == 3) {
      units = 1;
      resolution = 10;
      }
   else if (argc == 4) {
      sscanf(argv[3],"%f",&units);
      resolution = 10;
      }
   else if (argc == 5) {
      sscanf(argv[3],"%f",&units);
      sscanf(argv[4],"%f",&resolution);
      }
   //
   //  read .stl
   //
   fab_read_stl(&v,argv[1]);
   //
   // convert mesh to path
   //
   fab_mesh_path(&v,units,resolution);
   //
   //  write .path
   //
   fab_write_path(&v,argv[2]);
   //
   // return
   //
   return(0);
   }
Ejemplo n.º 25
0
int main(int argc, char **argv)
#endif
{
#ifdef MEMORY_DEBUG
	elm_init();
#endif //MEMORY_DEBUG
	gargc=argc;
	gargv=argv;

	// do basic initialization
#ifdef	OLC
	olc_init();
#endif	//OLC
	init_logging("log");

	check_log_level_on_command_line();
	create_tcp_out_mutex();
	init_translatables();
#ifdef	FSAA
	init_fsaa_modes();
#endif	/* FSAA */
	init_vars();

	ENTER_DEBUG_MARK("init stuff");

	init_stuff();

	LEAVE_DEBUG_MARK("init stuff");

	start_rendering();
#ifdef MEMORY_DEBUG
	elm_cleanup();
#endif //MEMORY_DEBUG
#ifdef	OLC
	olc_shutdown();
#endif	//OLC

#ifndef WINDOWS
	// attempt to restart if requested
	if(restart_required > 0){
		LOG_INFO("Restarting %s\n", *argv);
		execv(*argv, argv);
	}
#endif  //WINDOWS

	return 0;
}
Ejemplo n.º 26
0
int main(int argc, char *argv[])
{
  GSList *words, *letters, *constraints, *ll;
  GPtrArray *dictionary;
  gchar *grid;
  struct wordvar *w;

  if (argc != 3) {
    printf("usage: %s grid dictionary\n", argv[0]);
    exit (-1);
  }
  
  words = letters = constraints = NULL;

  grid = read_grid(argv[1], &words, &letters, &constraints);
  dictionary = read_words(argv[2]);
  init_vars(words, letters, dictionary);

  printf("%s\n", grid);

  w = words->data;
  printf("Initial %d\n", w->possible_values->len);

  for (ll = constraints; ll != NULL; ll = ll->next) {
    struct constraint *c = ll->data;
    put_constraint_on_queue(c);
  }

  run_constraints();

  printf("First %d\n", w->possible_values->len);

  for (ll = constraints; ll != NULL; ll = ll->next) {
    struct constraint *c = ll->data;
    put_constraint_on_queue(c);
  }


  total = 0;
  find_solution(words, letters, grid, 0);
  printf("total %d\n", total);


  return (0);
}
Ejemplo n.º 27
0
/*!*****************************************************************************
 *******************************************************************************
\note  go_cart_target_wait
\date  
   
\remarks 

       go to the given cartesian target

 *******************************************************************************
 Function Parameters: [in]=input,[out]=output

 \param[in]     ctar :  cartesian states
 \param[in]     stat :  1/0 for active target or not
 \param[in]       mt :  movement time

 ******************************************************************************/
int
go_cart_target_wait(SL_Cstate *ctar,int *stat, double mt)
{

  int i,j;
  double last_time;
  double last_draw_time;
  double aux;

  special_flag = TRUE;

  /* initialize some variables */
  init_vars();

  /* assign the target variables */
  for (i=1; i<=n_endeffs; ++i) {
    for (j= _X_; j<= _Z_; ++j) {
      cstatus[(i-1)*6+j] = stat[(i-1)*6+j];
      aux = ctar[i].x[j];
      ctarget[i].x[j] = aux;
    }
  }
  
  /* the movement time */
  tau = mt;

  if (!setTaskByName("Goto Cart Task")) {
    special_flag = FALSE;
    return FALSE;
  }

  last_time = last_draw_time = task_servo_time;
  while (strcmp(current_task_name,NO_TASK) != 0) {
    if (task_servo_time - last_time > 2*mt) {
      printf("time out in go_cart_target_wait\n");
      special_flag = FALSE;
      return FALSE;
    }
    taskDelay(ns2ticks(10000000)); // wait 10ms
  }
  
  return TRUE;

}
Ejemplo n.º 28
0
Archivo: env.cpp Proyecto: Horsell/42
t_env		*init_glfw_env(void)
{
	t_env	*e;

	if (!(e = (t_env*)malloc(sizeof(t_env))))
		return (NULL);
	init_vars(e);
	glfwSetErrorCallback(error_callback);
	if (!glfwInit())
		return (NULL);
	e->window = glfwCreateWindow(640, 480, "Arkanoid", NULL, NULL);
	if (!e->window)
	{
		glfwTerminate();
		return (NULL);
	}
	glfwMakeContextCurrent(e->window);
	return (e);
}
Ejemplo n.º 29
0
int main(int argc, char *argv[])
{
    (void) signal(SIGINT, die);
    initscr();

    /*
     * We use COLOR_GREEN because COLOR_BLACK is wired to the wrong thing.
     */
    start_color();
    init_pair(COLOR_RED,     COLOR_RED,   COLOR_WHITE);
    init_pair(COLOR_BLUE,    COLOR_BLUE,  COLOR_WHITE);
    init_pair(COLOR_GREEN,   COLOR_BLACK, COLOR_WHITE);

#if defined(__i386__) && defined(A_ALTCHARSET)
    if (tigetstr("smpch"))
	suits = glyphs;
#endif /* __i386__ && A_ALTCHARSET */

    cbreak();

    if (argc == 2)
	srand((unsigned)atoi(argv[1]));
    else
	srand((unsigned)time((time_t *)0));

    init_vars();

    do{
	deal_number++;
	shuffle(deck_size);
	deal_cards();
	display_cards(deal_number);
	play_game();
    }
    while
	((deck_size=collect_discards()) != 0);

    game_finished(deal_number);

    die(SIGINT);
    /*NOTREACHED*/
   return 1;
}
int		redir_left(t_vars *v)
{
  t_vars	*redir;
  t_redir	*r_l;
  int		exe;

  r_l = my_xmalloc(sizeof(*r_l));
  redir = my_xmalloc(sizeof(*redir));
  init_vars(redir);
  init_redir_simp(v, r_l, '<');
  if (!check_nb(r_l) || !check_redir_left(redir, r_l))
    {
      redir = free_t_vars(redir);
      r_l = free_redirs_vars(r_l);
      return (EXIT_FAILURE);
    }
  exe = do_r_l(redir, r_l);
  redir = free_t_vars(redir);
  r_l = free_redirs_vars(r_l);
  return (exe);
}