t_list_str      *shunting_yard(char *str, t_list_str **operator_stack, t_list_str **input, char **av)
{
int           i;
    int           j;
  char          *nbr;

  i = 0;
  p = 0;
  while (str[i] != '')
    {
      if (str[i] > 47 && str[i] < 58 && str[i] != '')
        {
          nbr = grab_nbr(str, i, size_nbr(str, i));
          put_in_stack(nbr, input, "NB");
          i = i + size_nbr(str, i);
        }
      else
        {
          nbr = malloc(sizeof(char) * 2);
          nbr[1] = '';
          nbr[0] = str[i];
          if (*operator_stack == NULL)
            put_in_stack(nbr, operator_stack, "OP");
          else if (give_priority(nbr, av) == 6)
            go_to_opening_parentis(operator_stack, input, av);
          else if (check_precedence(nbr, (*operator_stack)->data, av) == 1)
            put_in_stack(nbr, operator_stack, "OP");
          else if (check_precedence(nbr, (*operator_stack)->data, av) == 0)
            put_operator_input(nbr, *operator_stack, *input, av);
          else
            put_in_stack(nbr, operator_stack, "OP");
          i = i + 1;
          // my_print_strlist(*operator_stack);
          printf("n");
          // my_print_strlist(*input);
        }
    }
}
int             put_in_stack(char *nbr, t_list_str **stack, char *type)
{
  t_list_str    *temp;

  temp = malloc(sizeof(t_list_str));
  if (temp == NULL)
    return (84);
  temp->data = my_strdup(nbr);
  temp->type = my_strdup(type);
  temp->next = *stack;
  *stack = temp;
  return (0);
}
int             go_to_opening_parentis(t_list_str **operator_stack, t_list_str **input_for_comput, char **av)
{
  t_list_str    *temp;
  char          c[2];

  c[1] = '';
  temp = *operator_stack;
  while (temp->data[0] != av[2][0])
    {
      put_in_stack(temp->data, input_for_comput, "OP");
      temp = temp->next;
    }
  if (temp->next != NULL)
    *operator_stack = temp->next;
  else
    *operator_stack = NULL;
  return (0);
}

int             put_operator_input(char *c, t_list_str *operator_stack, t_list_str *input, char **av)
{
  while (check_precedence(c, operator_stack->data, av) != 1)
    {
      put_in_stack(operator_stack->data, &input, "OP");
      operator_stack = operator_stack->next;
    }
  if (operator_stack != NULL)
    put_in_stack(c, &operator_stack, "0P");
  return (0);
}
int     size_nbr(char *str, int i)
{
  int   size;

  size = 0;
  while (str[i] > 47 && str[i] < 58 && str[i] != '')
    {
      size = size + 1;
      i = i + 1;
    }
  printf("size%dn",size);
  return (size);
}
char    *grab_nbr(char *str, int i , int size)
{
  char  *nbr;
  int   j;

  j = 0;
  nbr = malloc(sizeof(char) * (size + 1));
  if (nbr == NULL)
    return (NULL);
  nbr[size] = '';
  while (str[i] > 47 && str[i] < 58 && str[i] != '')
    {
      nbr[j] = str[i];
      j = j + 1;
      i = i + 1;
    }
  return (nbr);
}

int     give_priority(char *c, char **av)
{
  // if (c[0] == '!')
  //return (1);
  if (c[0] == av[2][2]) // '+'
    return (1);
  if (c[0] == av[2][3]) // '-'
    return (1);
  if (c[0] == av[2][4])
    return (2);
  if (c[0] == av[2][5])
    return (3);
  if (c[0] == av[2][6]) //
    return (4);
  if (c[0] == av[2][0]) // '('
    return (5);
  if (c[0] == av[2][1]) // ')'
    return (6);
}

int     check_precedence(char *c, char *data, char **av)
{
  int   priority_c;
  int   priority_data;

  priority_c = give_priority(c, av);
  priority_data = give_priority(data, av);

  if ((priority_data <= priority_c && priority_c != 6 || priority_data == 5))
    return (1);
  if (priority_data > priority_c)
    return (0);
}

t_list_str              *link_input_operator(t_list_str **input_for_comput, t_list_str **operator_stack)
{
  t_list_str    *temp;

  temp = NULL;
  temp = *operator_stack;
  while (temp != NULL)
    {
      put_in_stack(temp->data, input_for_comput, "OP");
      temp = temp->next;
    }
}