minishell/src/parser/command_list/command_list.c

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   command_list.c                                     :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: khais <marvin@42.fr>                       +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2025/02/24 17:49:46 by khais             #+#    #+#             */
/*   Updated: 2025/02/25 15:08:48 by khais            ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include "command_list.h"
#include "libft.h"
#include "unistd.h"
#include <stdlib.h>

/*
** Match a string to an operator
**
** If the string does not match any operator, return OP_INVALID
*/
static t_operator	match_op(char *op)
{
	if (ft_strcmp("&&", op) == 0)
		return (OP_AND);
	if (ft_strcmp("||", op) == 0)
		return (OP_OR);
	return (OP_INVALID);
}

/*
** Count the number of pipelines in the given wordstream
**
** Pipelines are separated by operators || and &&.
**
** Does not do error checking about repeated operators, or operators in the
** wrong place.
*/
static int	command_list_count_pipelines(t_wordlist *words)
{
	t_wordlist	*current_word;
	int			count;

	current_word = words;
	if (current_word == NULL)
		return (0);
	count = 1;
	while (current_word != NULL)
	{
		if (match_op(current_word->word->word) != OP_INVALID)
			count++;
		current_word = current_word->next;
	}
	return (count);
}

/*
** Allocate memory for a new command_list, given the input word stream.
**
** Handles malloc error.
*/
static t_command_list	*allocate_command_list(t_wordlist *words)
{
	t_command_list	*output;

	if (words == NULL)
		return (NULL);
	output = ft_calloc(1, sizeof(t_command_list));
	if (output == NULL)
		return (NULL);
	output->num_pipelines = command_list_count_pipelines(words);
	output->pipelines
		= ft_calloc(output->num_pipelines, sizeof(t_pipeline *));
	if (output->pipelines == NULL)
		return (free(output), NULL);
	output->operators
		= ft_calloc(output->num_pipelines, sizeof(t_operator));
	if (output->operators == NULL)
		return (free(output->pipelines), free(output), NULL);
	return (output);
}

/*
** Create a new command list from the given wordlist.
*/
t_command_list	*command_list_from_wordlist(t_wordlist *words)
{
	t_command_list	*output;
	t_wordlist		*current_wordlist;
	t_worddesc		*current_word;
	int				idx;

	output = allocate_command_list(words);
	if (output == NULL)
		return (NULL);
	current_wordlist = NULL;
	current_word = wordlist_pop(&words);
	idx = 0;
	while (current_word != NULL)
	{
		if (match_op(current_word->word) == OP_INVALID)
		{
			current_wordlist = wordlist_push(current_wordlist, current_word);
			current_word = wordlist_pop(&words);
		}
		else
		{
			output->pipelines[idx] = pipeline_from_wordlist(current_wordlist);
			output->operators[idx] = match_op(current_word->word);
			current_wordlist = NULL;
			worddesc_destroy(current_word);
			current_word = wordlist_pop(&words);
			idx++;
		}
	}
	if (current_wordlist != NULL)
	{
		output->pipelines[idx] = pipeline_from_wordlist(current_wordlist);
		output->operators[idx] = OP_END;
	}
	return (output);
}

/*
** destroy the given command list and all associated memory
*/
void	command_list_destroy(t_command_list *cmd)
{
	int	i;

	if (cmd == NULL)
		return ;
	i = 0;
	while (i < cmd->num_pipelines)
	{
		pipeline_destroy(cmd->pipelines[i]);
		i++;
	}
	free(cmd->pipelines);
	free(cmd->operators);
	free(cmd);
}