Merge pull request #6 from Demidorn/demi

Demi

Author: Demidorn

.gitignore

@@ -0,0 +1,4 @@
+DL_getline.c
+DL_strtok.c
+.DL_getline.c.swp
+/test

DL_envs.c

@@ -0,0 +1,30 @@
+#include "header.h"
+
+/**
+ * _printenv - prints path to the environment variable
+ *
+ * Return: nothing
+ */
+
+void _printenv(void)
+{
+	char **env = environ;
+	int j;
+	size_t len;
+
+	if (env == NULL)
+	{
+		perror("Error: environ is not available");
+		return;
+	}
+
+	for (j = 0; env[j] != NULL; j++)
+	{
+		len = 0;
+		while (env[j][len] != '\0')
+			len++;
+		write(STDOUT_FILENO, env[j], len);
+		write(STDOUT_FILENO, "\n", 1);
+	}
+
+}

DL_execute.c

@@ -0,0 +1,50 @@
+#include "header.h"
+
+/**
+ * execute_command - function to handle command execution based on user input
+ * @get_address: input line from user
+ * @env: environment variable
+ *
+ * Return: output executed command else -1
+ */
+
+int execute_command(char *get_address, char __attribute__((__unused__)) **env)
+{
+	char *delim = " \n\t\r";
+	char **tokens = NULL, *command_path = NULL;
+	int status = 0, ex = 0;
+
+	tokens = tokenize(get_address, delim);
+	if (!tokens || tokens[0] == NULL)
+	{
+		perror("Error ");
+		return (ex);
+	}
+	if (_strcmp(tokens[0], "exit") == 0)
+	{
+		if (tokens[1] != NULL)
+		{
+			status = atoi(tokens[1]);
+		}
+		free(tokens);
+		free(command_path);
+		exit(status);
+	}
+	if (_strcmp(tokens[0], "env") == 0)
+	{
+		_printenv();
+		free(tokens);
+		free(command_path);
+		return (ex);
+	}
+	command_path = locate_path(tokens[0]);
+	if (!command_path)
+	{
+		perror("command not found");
+		free(tokens);
+		ex = 127;
+		return (ex);
+	}
+	execute_and_wait(command_path, tokens, &ex);
+	return (ex);
+}

DL_getenv.c

@@ -0,0 +1,58 @@
+#include "header.h"
+
+/**
+ * _getenv - gets an env variable from the path
+ * @str: name of the variable to get
+ *
+ * Return: value of the env variable else null
+ */
+
+char *_getenv(const char *str)
+{
+	size_t len;
+	char *value;
+	int l;
+
+	len = _strlen(str);
+
+	if (str == NULL || environ == NULL)
+	{
+		perror("Error: ");
+		return (NULL);
+	}
+
+	for (l = 0; environ[l]; l++)
+	{
+		if (_strncmp(str, environ[l], len) == 0 && environ[l][len] == '=')
+		{
+			value = _strdup(environ[l] + len + 1);
+			if (value == NULL)
+			{
+				perror("Error: ");
+				return (NULL);
+			}
+			return (value);
+		}
+	}
+	return (NULL);
+}
+
+/**
+ * read_input - function that reads a line of input
+ * @get_address: poniter to store input
+ * @length_input: stores length of the input line
+ *
+ * Return: number of characters read otherwise -1 on failure
+ */
+
+ssize_t read_input(char **get_address, size_t *length_input)
+{
+	char *prompt = "$ ";
+	ssize_t read_line;
+	int is_terminal = isatty(0);
+
+	if (is_terminal == 1)
+		write(STDOUT_FILENO, prompt, 2);
+	read_line = getline(get_address, length_input, stdin);
+	return (read_line);
+}

DL_locator.c

@@ -0,0 +1,53 @@
+#include "header.h"
+
+/**
+ * locate_path - checks for path of the variable executed
+ * @com_val: Pointer to string values
+ *
+ * Return: 0 when successful otherwise -1
+ */
+
+char *locate_path(char *com_val)
+{
+	char *read_path, *copy_of_path, *file = NULL;
+	char *token_to_path;
+	size_t length, dir_length;
+	struct stat buff;
+
+	if (stat(com_val, &buff) == 0)
+		return (_strdup(com_val));
+	read_path = _getenv("PATH");
+	if (!read_path)
+		return (NULL);
+	copy_of_path = _strdup(read_path);
+	if (!copy_of_path)
+		return (NULL);
+	token_to_path = strtok(copy_of_path, ":");
+
+	while (token_to_path != NULL)
+	{
+		dir_length = _strlen(token_to_path);
+		length = _strlen(com_val);
+		file = malloc(dir_length + length + 2);
+		if (!file)
+		{
+			free(copy_of_path);
+			return (NULL);
+		}
+		_strcpy(file, token_to_path);
+		_strcat(file, "/");
+		_strcat(file, com_val);
+		if (stat(file, &buff) == 0)
+		{
+			free(copy_of_path);
+			return (file);
+		}
+		else
+		{
+			free(file);
+			token_to_path = strtok(NULL, ":");
+		}
+	}
+	free(copy_of_path);
+	return (NULL);
+}

DL_main.c

@@ -0,0 +1,39 @@
+#include "header.h"
+
+/**
+ * main - Entry point of the program that displays a prompt
+ * whenever the function is called upon.
+ * @argc: Number of commandline arguments.
+ * @argv: Pointer array of strings containing commandline arguments.
+ * @env: An array of strings containing environment variables.
+ *
+ * Return: 0 when successfull.
+ */
+
+int main(int argc, char __attribute__((__unused__)) *argv[], char **env)
+{
+	char *get_address = NULL;
+	size_t length_input = 0;
+	ssize_t read_line;
+	int string_line;
+
+	(void)argc;
+
+	while (1)
+	{
+		read_line = read_input(&get_address, &length_input);
+		if (read_line == -1)
+		{
+			free(get_address);
+			exit(127);
+		}
+		if (get_address[0] != '\0')
+		{
+			string_line = execute_command(get_address, env);
+			if (string_line != 0)
+				return (string_line);
+		}
+		/*free(get_address);*/
+	}
+	return (0);
+}

DL_pid.c

@@ -0,0 +1,40 @@
+#include "header.h"
+
+/**
+ * execute_and_wait - executes a command and waits for its completion
+ * @command_path: path command to execute
+ * @tokens: array of commandline arguments
+ * @e_status: pointer to store exit status of the command
+ *
+ * Return: 0 when succeful else 1
+ */
+
+int execute_and_wait(char *command_path, char **tokens, int *e_status)
+{
+	pid_t pid;
+	int status;
+
+	pid = fork();
+	if (pid == -1)
+	{
+		perror("Error");
+		return (-1);
+	}
+	if (pid == 0)
+	{
+		execve(command_path, tokens, environ);
+		perror("Execve");
+		exit(2);
+	}
+	else
+	{
+		wait(&status);
+		if (WIFEXITED(status))
+			*e_status = WEXITSTATUS(status);
+		else
+			*e_status = -1;
+		free(command_path);
+		free(tokens);
+	}
+	return (0);
+}

DL_stringHandlers1.c

@@ -0,0 +1,106 @@
+#include "header.h"
+
+/**
+ * int_to_string - converts integer to string
+ * @result: array to hold string
+ * @value: integer value to be converted
+ *
+ * Return: converted string
+ */
+
+void int_to_string(int value, char *result)
+{
+	int temp, position, d, num = 0;
+
+	if (value == 0)
+	{
+		result[0] = '0';
+		result[1] = '\0';
+		return;
+	}
+	temp = value;
+
+	while (temp != 0)
+	{
+		temp /= 10;
+		num++;
+	}
+	position = num;
+	result[position] = '\0';
+
+	while (value != 0)
+	{
+		position--;
+		d = value % 10;
+		result[position] = '0' + d;
+		value /= 10;
+	}
+}
+
+/**
+ * _strcmp - compares two strings
+ * @s1: First string
+ * @s2: Second string
+ * Return: The value
+ */
+
+int _strcmp(char *s1, char *s2)
+{
+	int i = 0;
+
+	while (s1[i] != '\0')
+	{
+		if (s1[i] != s2[i])
+			break;
+		i++;
+	}
+	return (s1[i] - s2[i]);
+}
+
+/**
+ * _strcat - concantnates two strings
+ * @dest: Destination string
+ * @src: Source string
+ * Return: Result of two strings together
+ */
+
+char *_strcat(char *dest, const char *src)
+{
+	int i = 0, j;
+
+	while (dest[i] != '\0')
+	{
+		i++;
+	}
+	for (j = 0; src[j] != 0; j++)
+	{
+		dest[i] = src[j];
+		i++;
+	}
+	dest[i] = '\0';
+	return (dest);
+}
+
+/**
+ * _strncmp - compares amount of characters of two strings
+ * @s1: first string
+ * @s2: second string
+ * @s: amount of characters to compare
+ * Return: 0 (successful) otherwise 1
+ */
+int _strncmp(const char *s1, const char *s2, size_t s)
+{
+	size_t j;
+
+	if (s1 == NULL)
+		return (-1);
+
+	for (j = 0; j < s && s2[j]; j++)
+	{
+		if (s1[j] != s2[j])
+		{
+			return (1);
+		}
+	}
+	return (0);
+}