simple_shell/alias_handler.c at master · theAstralProgrammer0/simple_shell · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include "shell.h"

/**
 * tokenizeAliasArguments - make alias tokens
 * @argument: alias name-value pair
 *
 * Return: array of alias name and value
*/
char **tokenizeAliasArguments(char *argument)
{
	char **tokens = NULL, *equalToSign = NULL;
	size_t len_name, len_value;

	tokens = (char **)malloc(sizeof(char *) * 2);
	if (!tokens)
	{
		dprintf(2, "Failed to allocate memory for tokens\n");
		exit(EXIT_FAILURE);
	}
	tokens[0] = NULL;
	tokens[1] = NULL;
	equalToSign = strchr(argument, '=');
	if (equalToSign)
	{
		len_name = equalToSign - argument;
		tokens[0] = (char *)malloc(len_name + 1);
		if (!tokens[0])
			exit(EXIT_FAILURE);
		strncpy(tokens[0], argument, len_name);
		tokens[0][len_name] = '\0';
		len_value = strlen(equalToSign + 1);
		tokens[1] = (char *)malloc(len_value + 1);
		if (!tokens[1])
		{
			free(tokens[0]);
			exit(EXIT_FAILURE);
		}
		strncpy(tokens[1], equalToSign + 1, len_value);
		tokens[1][len_value] = '\0';
	}
	else
		tokens[0] = strdup(argument);
	if (!tokens[0] && !tokens[1])
	{
		free(tokens);
		return (NULL);
	}
	return (tokens);
}

/**
 * handleAlias - handle aliases
 * @aliasList: alias list
 * @arguments: command arguments
 *
 * Return: 0
*/
int handleAlias(alias_t *aliasList, char **arguments)
{
	int i;

	if (!arguments[0])
		printAliasList(aliasList);
	for (i = 0; arguments[i]; ++i)
		handleAliasCommands(aliasList, arguments[i]);
	return (0);
}

/**
 * handleAliasCommands - handle alias commands
 * @aliasList: alias list
 * @argument: command arguments
 *
 * Return: 0
*/
int handleAliasCommands(alias_t *aliasList, char *argument)
{
	char **aliasTokens = tokenizeAliasArguments(argument);
	char *name = aliasTokens[0], *value = aliasTokens[1];
	char *chainedValue = NULL;
	alias_node *alias = NULL, *lastAlias = NULL;

	if (value == NULL)
	{
		lastAlias = findLastAlias(aliasList, name);
		printAlias(lastAlias, name);
	}
	else
	{
		alias = findAlias(aliasList, name);
		if (alias == NULL)
			addAlias(aliasList, name, value);
		else
		{
			chainedValue = malloc(strlen(name)
					+ strlen("=")
					+ strlen(value)
					+ 1);
			sprintf(chainedValue, "%s=%s", name, value);
			free(alias->value);
			alias->value = chainedValue;
		}
	}
	freeTokens(aliasTokens);
	aliasTokens = NULL;
	return (0);
}

/**
 * initAliasList - make alias list
 * @aliasList: alias list
 *
 * Return: a pointer to alias list
*/
alias_t *initAliasList(alias_t *aliasList)
{
	if (aliasList != NULL)
		return (aliasList);

	aliasList = (alias_t *)malloc(sizeof(alias_t));
	if (aliasList == NULL)
		return (NULL);

	aliasList->head = NULL;
	aliasList->tail = NULL;
	aliasList->size = 0;
	return (aliasList);
}