#include "tokens.h"

Include dependency graph for stack_control.c:

Functions
void	add_node (t_token *head, char str)

void	print_stack (t_token **stack)

void	free_stack (t_token **stack)

int	calc_stack_size (t_token *stack)

char **	list_to_array (t_token *head)

Function Documentation

◆ add_node()

void add_node	(	t_token **	head,
		char *	str
	)

Definition at line 15 of file stack_control.c.

{
    t_token *new_node;  
    t_token *curr_node;
 
    new_node = (t_token *)malloc(sizeof(t_token));
    if (!new_node)
        return ;
    new_node->data = str;
    new_node->next = NULL;
    if (*head == NULL)
    {
        *head = new_node;
        return ;
    }
    curr_node = *head;
    while (curr_node->next != NULL)
        curr_node = curr_node->next;
    curr_node->next = new_node;
}

References s_token::data, and s_token::next.

Referenced by build_linked_list().

Here is the caller graph for this function:

◆ calc_stack_size()

int calc_stack_size ( t_token * stack )

Definition at line 65 of file stack_control.c.

{
    int         size;
    t_token     *current;
 
    size = 0;
    current = stack;
    while (current != NULL)
    {
        size++;
        current = current->next;
    }
    return (size);
}

References s_token::next.

Referenced by list_to_array().

Here is the caller graph for this function:

◆ free_stack()

void free_stack ( t_token ** stack )

Definition at line 51 of file stack_control.c.

{
    t_token *current;
    t_token *next;
 
    current = *stack;
    while (current != NULL)
    {
        next = current->next;
        free(current);
        current = next;
    }
}

References s_token::next.

◆ list_to_array()

char ** list_to_array ( t_token * head )

Definition at line 80 of file stack_control.c.

{
    int         count;
    int         i;
    char        **arr;
    t_token     *current;
 
    current = head;
    count = calc_stack_size(current);
    arr = (char **)malloc((count + 1) * sizeof(char *));
    if (!arr)
        return (NULL);
    current = head;
    i = 0;
    while (i < count)
    {
        arr[i] = ft_strdup(current->data);
        current = current->next;
        i++;
    }
    arr[count] = NULL;
    return (arr);
}

References calc_stack_size(), s_token::data, ft_strdup(), and s_token::next.

Here is the call graph for this function:

◆ print_stack()

void print_stack ( t_token ** stack )

Definition at line 36 of file stack_control.c.

{
    t_token *current_node;
    int     i;
 
    i = 0;
    current_node = *stack;
    while (current_node != NULL)
    {
        ft_printf("input[%d] ->  %s \n", i, current_node->data);
        current_node = current_node->next;
        i++;
    }
}

References s_token::data, ft_printf(), and s_token::next.