From 6ce80f5e4205c0fb80e7e1fbf0efcf251cf5c876 Mon Sep 17 00:00:00 2001
From: Javier Izquierdo Hernandez <javizqh@gmail.com>
Date: Tue, 16 May 2023 12:21:07 +0200
Subject: [PATCH 1/3] Changing typedefs

---
 src/builtin/mash_math.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/builtin/mash_math.c b/src/builtin/mash_math.c
index 8b9a017..1063a68 100644
--- a/src/builtin/mash_math.c
+++ b/src/builtin/mash_math.c
@@ -54,14 +54,16 @@ enum math_size {
   MAX_OPERAND_SIZE = 32
 };
 
-typedef struct token {
+struct token {
   char data[MAX_OPERAND_SIZE];
   double value;
   int type;
   int priority;
   int symbol_priority;
   struct token * next;
-} Token;
+};
+
+typedef struct token Token;
 
 Token * 
 newToken() {

From 5fb616605a5c308d375441bd0c028885316bbacb Mon Sep 17 00:00:00 2001
From: Javier Izquierdo Hernandez <javizqh@gmail.com>
Date: Tue, 16 May 2023 12:21:53 +0200
Subject: [PATCH 2/3] Indenting correctly mash math

---
 src/builtin/mash_math.c | 775 +++++++++++++++++++++-------------------
 1 file changed, 401 insertions(+), 374 deletions(-)

diff --git a/src/builtin/mash_math.c b/src/builtin/mash_math.c
index 1063a68..b33607f 100644
--- a/src/builtin/mash_math.c
+++ b/src/builtin/mash_math.c
@@ -20,24 +20,26 @@
 #include "builtin/export.h"
 #include "builtin/mash_math.h"
 
-char * math_use = "math expression";
-char * math_description = "Write result of the arithmetic expression.";
-char * math_help = 
-"    Display the result of the arithmetic expression, followed by a\n"
-"    newline, on the standard output.\n\n"
-"    Exit Status:\n"
-"    Returns success unless an error in the expression is found.\n";
-
-static int 
-help() {
+char *math_use = "math expression";
+char *math_description = "Write result of the arithmetic expression.";
+char *math_help =
+    "    Display the result of the arithmetic expression, followed by a\n"
+    "    newline, on the standard output.\n\n"
+    "    Exit Status:\n"
+    "    Returns success unless an error in the expression is found.\n";
+
+static int
+help()
+{
 	printf("math: %s\n", math_use);
 	printf("    %s\n\n%s", math_description, math_help);
 	return EXIT_SUCCESS;
 }
 
-static int 
-usage() {
-  fprintf(stderr,"Usage: %s\n",math_use);
+static int
+usage()
+{
+	fprintf(stderr, "Usage: %s\n", math_use);
 	return EXIT_FAILURE;
 }
 
@@ -45,130 +47,139 @@ usage() {
 static int error_in_operations = 0;
 
 enum lexer_type {
-  MATH_SYMBOL = 1,
-  MATH_NUMBER,
-  MATH_VARIABLE
+	MATH_SYMBOL = 1,
+	MATH_NUMBER,
+	MATH_VARIABLE
 };
 
 enum math_size {
-  MAX_OPERAND_SIZE = 32
+	MAX_OPERAND_SIZE = 32
 };
 
 struct token {
-  char data[MAX_OPERAND_SIZE];
-  double value;
-  int type;
-  int priority;
-  int symbol_priority;
-  struct token * next;
+	char data[MAX_OPERAND_SIZE];
+	double value;
+	int type;
+	int priority;
+	int symbol_priority;
+	struct token *next;
 };
 
 typedef struct token Token;
 
-Token * 
-newToken() {
-  Token *token = (Token *) malloc(sizeof(Token));
+Token *
+newToken()
+{
+	Token *token = (Token *)malloc(sizeof(Token));
 
 	// Check if malloc failed
 	if (token == NULL) {
 		err(EXIT_FAILURE, "malloc failed");
 	}
 	memset(token, 0, sizeof(Token));
-  token->value = 1;
-  token->type = 0;
-  token->priority = 0;
-  token->symbol_priority = 0;
-  token->next = NULL;
+	token->value = 1;
+	token->type = 0;
+	token->priority = 0;
+	token->symbol_priority = 0;
+	token->next = NULL;
 
 	return token;
 }
 
-Token * 
-add_token(Token * prev_token, int priority) {
-  Token *new_token = newToken();
-  prev_token->next = new_token;
-  new_token->priority = priority;
+Token *
+add_token(Token *prev_token, int priority)
+{
+	Token *new_token = newToken();
+
+	prev_token->next = new_token;
+	new_token->priority = priority;
 	return new_token;
 }
 
-void 
-free_all_tokens(Token * first_token) {
-  Token * token = first_token;
-  Token * to_free = token;
-  while (to_free)
-  {
-    token = token->next;
-    free(to_free);
-    to_free = token;
-  }
-  return;
+void
+free_all_tokens(Token *first_token)
+{
+	Token *token = first_token;
+	Token *to_free = token;
+
+	while (to_free) {
+		token = token->next;
+		free(to_free);
+		to_free = token;
+	}
+	return;
 }
 
-static int 
-is_symbol(char c) {
-  return c == '+' || c == '-' || c == '*' || c == '/' || c == '^'; 
+static int
+is_symbol(char c)
+{
+	return c == '+' || c == '-' || c == '*' || c == '/' || c == '^';
 }
 
-static double 
-get_number(char *number) {
-  double num = 0;
-  for (; *number != '\0'; number++)
-  {
-    if (*number >= '0' && *number <= '9')
-    {
-      num = num * 10 + (*number - '0');
-    } else {
-      return -1;
-    }
-  }
-  return num;
+static double
+get_number(char *number)
+{
+	double num = 0;
+
+	for (; *number != '\0'; number++) {
+		if (*number >= '0' && *number <= '9') {
+			num = num * 10 + (*number - '0');
+		} else {
+			return -1;
+		}
+	}
+	return num;
 }
 
-static Token * 
-tokenize(char * expression) {
-  Token * first_token = newToken();
-  Token * current_token = first_token;
-  int total_priority = 0;
-  char * line = expression;
-
-  for (; *expression != '\0' ; expression++)
-  {
-    if (*expression >= '0' && *expression <= '9') {
-      if (current_token->type != MATH_NUMBER && current_token->type) {
-        current_token = add_token(current_token, total_priority);
-        current_token->type = MATH_NUMBER;
-      }
-      strncat(current_token->data, expression, 1);
-      current_token->type = MATH_NUMBER;
-    } else if ((*expression >= 'a' && *expression <= 'z') ||
-      (*expression >= 'A' && *expression <= 'Z')) 
-    {
-      if (current_token->type != MATH_VARIABLE && current_token->type) {
-        current_token = add_token(current_token, total_priority);
-        current_token->type = MATH_VARIABLE;
-      }
-      strncat(current_token->data, expression, 1);
-      current_token->type = MATH_VARIABLE;
-    } else if (is_symbol(*expression)) {
-      if (!current_token->type) {
-        if (*expression != '-' && *expression != '+') {
-          fprintf(stderr,
+static Token *
+tokenize(char *expression)
+{
+	Token *first_token = newToken();
+	Token *current_token = first_token;
+	int total_priority = 0;
+	char *line = expression;
+
+	for (; *expression != '\0'; expression++) {
+		if (*expression >= '0' && *expression <= '9') {
+			if (current_token->type != MATH_NUMBER
+			    && current_token->type) {
+				current_token =
+				    add_token(current_token, total_priority);
+				current_token->type = MATH_NUMBER;
+			}
+			strncat(current_token->data, expression, 1);
+			current_token->type = MATH_NUMBER;
+		} else if ((*expression >= 'a' && *expression <= 'z') ||
+			   (*expression >= 'A' && *expression <= 'Z')) {
+			if (current_token->type != MATH_VARIABLE
+			    && current_token->type) {
+				current_token =
+				    add_token(current_token, total_priority);
+				current_token->type = MATH_VARIABLE;
+			}
+			strncat(current_token->data, expression, 1);
+			current_token->type = MATH_VARIABLE;
+		} else if (is_symbol(*expression)) {
+			if (!current_token->type) {
+				if (*expression != '-' && *expression != '+') {
+					fprintf(stderr,
 						"mash: error: math: incorrect character '%c' at the beginning of expression '%s'\n",
 						*expression, line);
-          free_all_tokens(first_token);
-          return NULL;
-        }
-        current_token->type = MATH_NUMBER;
-      }
-      current_token = add_token(current_token, total_priority);
-      current_token->type = MATH_SYMBOL;
-      strncat(current_token->data, expression, 1);
-    } else if (*expression == '(') {
+					free_all_tokens(first_token);
+					return NULL;
+				}
+				current_token->type = MATH_NUMBER;
+			}
+			current_token =
+			    add_token(current_token, total_priority);
+			current_token->type = MATH_SYMBOL;
+			strncat(current_token->data, expression, 1);
+		} else if (*expression == '(') {
 			if (!current_token->type) {
 				current_token->priority++;
 			}
 			total_priority++;
-    } else if (*expression == ')') {
+		} else if (*expression == ')') {
 			if (!current_token->type) {
 				fprintf(stderr,
 					"mash: error: math: incorrect character '%c' in expression '%s'\n",
@@ -176,289 +187,305 @@ tokenize(char * expression) {
 				free_all_tokens(first_token);
 				return NULL;
 			}
-      total_priority--;
-    } else if (*expression != ' ' && *expression != '\t') {
-      fprintf(stderr,
+			total_priority--;
+		} else if (*expression != ' ' && *expression != '\t') {
+			fprintf(stderr,
 				"mash: error: math: incorrect character '%c' in expression '%s'\n",
 				*expression, line);
-      free_all_tokens(first_token);
-      return NULL;
-    }
-  }
-  if (total_priority != 0) {
-    fprintf(stderr,"mash: error: math: incorrect expression '%s'\n", line);
-    free_all_tokens(first_token);
-    return NULL;
-  }
-  if (current_token->type == MATH_SYMBOL) {
-    fprintf(stderr,
+			free_all_tokens(first_token);
+			return NULL;
+		}
+	}
+	if (total_priority != 0) {
+		fprintf(stderr,
+			"mash: error: math: incorrect expression '%s'\n", line);
+		free_all_tokens(first_token);
+		return NULL;
+	}
+	if (current_token->type == MATH_SYMBOL) {
+		fprintf(stderr,
 			"mash: error: math: incorrect symbol '%s' at the end of expression\n",
 			line);
-    free_all_tokens(first_token);
-    return NULL;
-  }
-  return first_token;
+		free_all_tokens(first_token);
+		return NULL;
+	}
+	return first_token;
 }
 
-static int 
-substitute_values(Token * first_token) {
-  Token * token, * prev_token, * to_free;
-  char * variable;
-  double value;
-  int prev_is_symbol = -1;
-  for (token = first_token; token; token = token->next)
-  {
-    switch (token->type)
-    {
-    case MATH_NUMBER:
-      if (!prev_is_symbol) {
-        fprintf(stderr,"mash: error:");
-        return -1;
-      }
-      prev_is_symbol = 0;
-      if ((value = get_number(token->data)) < 0) {
-        return -1;
-      }
-      token->value *= value; 
-      break;
-    case MATH_VARIABLE:
-      if (!prev_is_symbol) {
-        return -1;
-      }
-      prev_is_symbol = 0;
-      variable = get_env_by_name(token->data);
-      if (variable == NULL) {
-        fprintf(stderr, "mash: error: var %s does not exist\n", token->data);
-        return -1;
-      }
-
-      if (*variable == '-') {
-        token->value *= -1;
-        variable++;
-        strcpy(token->data,variable);
-        variable--;
-      } else if (*variable == '+') {
-        variable++;
-        strcpy(token->data,variable);
-        variable--;
-      } else {
-        strcpy(token->data,variable);
-      }
-
-      free(variable);
-      if ((value = get_number(token->data)) < 0) {
-        return -1;
-      }
-      token->value *= value;
-      token->type = MATH_NUMBER;
-      break;
-    default:
-      if (prev_is_symbol > 0) {
-        prev_is_symbol = 1;
-        if (*token->data == '-') {
-          to_free = token;
-          token->next->value *= -1;
-          prev_token->next = token->next;
-          token = prev_token;
-          free(to_free);
-        } else if (*token->data == '+') {
-          to_free = token;
-          prev_token->next = token->next;
-          token = prev_token;
-          free(to_free);
-        } else {
-          return -1;
-        }
-        break;
-      }
-      prev_is_symbol = 1;
-      if (strcmp(token->data, "*") == 0 || strcmp(token->data, "/") == 0) {
-        token->symbol_priority = 1;
-      } else if (strcmp(token->data, "^") == 0) {
-        token->symbol_priority = 2;
-      }
-      break;
-    }
-    prev_token = token;
-  }
-  return 0;
+static int
+substitute_values(Token *first_token)
+{
+	Token *token, *prev_token, *to_free;
+	char *variable;
+	double value;
+	int prev_is_symbol = -1;
+
+	for (token = first_token; token; token = token->next) {
+		switch (token->type) {
+		case MATH_NUMBER:
+			if (!prev_is_symbol) {
+				fprintf(stderr, "mash: error:");
+				return -1;
+			}
+			prev_is_symbol = 0;
+			if ((value = get_number(token->data)) < 0) {
+				return -1;
+			}
+			token->value *= value;
+			break;
+		case MATH_VARIABLE:
+			if (!prev_is_symbol) {
+				return -1;
+			}
+			prev_is_symbol = 0;
+			variable = get_env_by_name(token->data);
+			if (variable == NULL) {
+				fprintf(stderr,
+					"mash: error: var %s does not exist\n",
+					token->data);
+				return -1;
+			}
+
+			if (*variable == '-') {
+				token->value *= -1;
+				variable++;
+				strcpy(token->data, variable);
+				variable--;
+			} else if (*variable == '+') {
+				variable++;
+				strcpy(token->data, variable);
+				variable--;
+			} else {
+				strcpy(token->data, variable);
+			}
+
+			free(variable);
+			if ((value = get_number(token->data)) < 0) {
+				return -1;
+			}
+			token->value *= value;
+			token->type = MATH_NUMBER;
+			break;
+		default:
+			if (prev_is_symbol > 0) {
+				prev_is_symbol = 1;
+				if (*token->data == '-') {
+					to_free = token;
+					token->next->value *= -1;
+					prev_token->next = token->next;
+					token = prev_token;
+					free(to_free);
+				} else if (*token->data == '+') {
+					to_free = token;
+					prev_token->next = token->next;
+					token = prev_token;
+					free(to_free);
+				} else {
+					return -1;
+				}
+				break;
+			}
+			prev_is_symbol = 1;
+			if (strcmp(token->data, "*") == 0
+			    || strcmp(token->data, "/") == 0) {
+				token->symbol_priority = 1;
+			} else if (strcmp(token->data, "^") == 0) {
+				token->symbol_priority = 2;
+			}
+			break;
+		}
+		prev_token = token;
+	}
+	return 0;
 }
 
-static double 
-calculate(char symbol, double op_1, double op_2) {
-  switch (symbol)
-  {
-  case '*':
-    return op_1 * op_2;
-    break;
-  case '+':
-    return op_1 + op_2;
-    break;
-  case '-':
-    return op_1 - op_2;
-    break;
-  case '/':
-    if (op_2 == 0) {
-      error_in_operations = 1;
-      return 0;
-    }
-    return op_1 / op_2;
-    break;
-  case '^':
-    return pow(op_1, op_2);
-    break;
-  }
-  return 0;
+static double
+calculate(char symbol, double op_1, double op_2)
+{
+	switch (symbol) {
+	case '*':
+		return op_1 * op_2;
+		break;
+	case '+':
+		return op_1 + op_2;
+		break;
+	case '-':
+		return op_1 - op_2;
+		break;
+	case '/':
+		if (op_2 == 0) {
+			error_in_operations = 1;
+			return 0;
+		}
+		return op_1 / op_2;
+		break;
+	case '^':
+		return pow(op_1, op_2);
+		break;
+	}
+	return 0;
 }
 
-static double 
-do_operations(Token * start_token) {
-  // num sim1 num2 sim2 num3 sim3 num4
-  // If sim2 == * and sim1 == 1 replace num2 with (num2 sim2 num3)
-  // Do the operations here
-  // Symbol priority ^; * /; + -
-  Token * op_1, * op_2, * symbol;
-  Token * prev_symbol = NULL;
-  Token * token = start_token;
-  Token * prev_op = token;
-  int symbol_p = -1;
-  double result = 0;
-
-  if (start_token->next == NULL) {
-    result = start_token->value;
-    free(start_token);
-    return result;
-  }
-
-  for (; token; token = token->next) {
-    if (token->type != MATH_SYMBOL) {
-      if (token->next == NULL)
-      {
-        if (prev_symbol) {
-          token = add_token(prev_symbol, 0);
-        } else {
-          token = newToken();
-        }
-        token->next = NULL;
-        token->value = calculate(*symbol->data,op_1->value,op_2->value);
-        if (start_token == op_1) {
-          free(symbol);
-          free(op_1);
-          free(op_2);
-          break;
-        } 
-        token = start_token;      
-        free(symbol);
-        free(op_1);
-        free(op_2);
-        symbol_p = -1;
-      }
-      prev_op = token;
-      continue;
-    }
-    if (symbol_p == -1) {
-      symbol_p = token->symbol_priority;
-      symbol = token;
-      op_1 = prev_op;
-      op_2 = token->next;
-      continue;
-    }
-    
-    if (token->symbol_priority > symbol_p) {
-      prev_symbol = symbol;
-      symbol_p = token->symbol_priority;
-      symbol = token;
-      op_1 = prev_op;
-      op_2 = token->next;
-    } else {
-      // Do operation
-      if (prev_symbol) {
-        token = add_token(prev_symbol, 0);
-      } else {
-        token = newToken();
-      }
-      token->next = op_2->next;
-      token->value = calculate(*symbol->data,op_1->value,op_2->value);
-      if (start_token != op_1) {
-        token = start_token;
-        prev_op = start_token;   
-      } else {
-        start_token = token;
-        prev_op = token;
-      }
-      free(symbol);
-      free(op_1);
-      free(op_2);
-      symbol_p = -1;
-      prev_symbol = NULL;
-    }
-  }
-  result = token->value;
-  free(token);
-  return result;
+static double
+do_operations(Token *start_token)
+{
+	// num sim1 num2 sim2 num3 sim3 num4
+	// If sim2 == * and sim1 == 1 replace num2 with (num2 sim2 num3)
+	// Do the operations here
+	// Symbol priority ^; * /; + -
+	Token *op_1, *op_2, *symbol;
+	Token *prev_symbol = NULL;
+	Token *token = start_token;
+	Token *prev_op = token;
+	int symbol_p = -1;
+	double result = 0;
+
+	if (start_token->next == NULL) {
+		result = start_token->value;
+		free(start_token);
+		return result;
+	}
+
+	for (; token; token = token->next) {
+		if (token->type != MATH_SYMBOL) {
+			if (token->next == NULL) {
+				if (prev_symbol) {
+					token = add_token(prev_symbol, 0);
+				} else {
+					token = newToken();
+				}
+				token->next = NULL;
+				token->value =
+				    calculate(*symbol->data, op_1->value,
+					      op_2->value);
+				if (start_token == op_1) {
+					free(symbol);
+					free(op_1);
+					free(op_2);
+					break;
+				}
+				token = start_token;
+				free(symbol);
+				free(op_1);
+				free(op_2);
+				symbol_p = -1;
+			}
+			prev_op = token;
+			continue;
+		}
+		if (symbol_p == -1) {
+			symbol_p = token->symbol_priority;
+			symbol = token;
+			op_1 = prev_op;
+			op_2 = token->next;
+			continue;
+		}
+
+		if (token->symbol_priority > symbol_p) {
+			prev_symbol = symbol;
+			symbol_p = token->symbol_priority;
+			symbol = token;
+			op_1 = prev_op;
+			op_2 = token->next;
+		} else {
+			// Do operation
+			if (prev_symbol) {
+				token = add_token(prev_symbol, 0);
+			} else {
+				token = newToken();
+			}
+			token->next = op_2->next;
+			token->value =
+			    calculate(*symbol->data, op_1->value, op_2->value);
+			if (start_token != op_1) {
+				token = start_token;
+				prev_op = start_token;
+			} else {
+				start_token = token;
+				prev_op = token;
+			}
+			free(symbol);
+			free(op_1);
+			free(op_2);
+			symbol_p = -1;
+			prev_symbol = NULL;
+		}
+	}
+	result = token->value;
+	free(token);
+	return result;
 }
 
-static double 
-operate(Token * start_token) {
-  // Operate on the highest priority token
-  Token * high_priority_token;
-  Token * sp_token;
-  Token * token = start_token;
-  Token * prev_token = token;
-  int priority = token->priority;
-  for (; token; token = token->next) {
-    if (token->priority > priority) {
-      high_priority_token = add_token(prev_token, priority);
-      for ( sp_token = token; sp_token; sp_token = sp_token->next) {
-        if (sp_token->priority < token->priority) {
-          break;
-        }
-      }
-      high_priority_token->type = MATH_NUMBER;
-      high_priority_token->value = operate(token);
-      high_priority_token->next = sp_token;
-      token = high_priority_token;
-    } else if (token->priority < priority) {
-      prev_token->next = NULL;
-      return do_operations(start_token);
-    }
-    prev_token = token;
-  }  
-  return do_operations(start_token);
+static double
+operate(Token *start_token)
+{
+	// Operate on the highest priority token
+	Token *high_priority_token;
+	Token *sp_token;
+	Token *token = start_token;
+	Token *prev_token = token;
+	int priority = token->priority;
+
+	for (; token; token = token->next) {
+		if (token->priority > priority) {
+			high_priority_token = add_token(prev_token, priority);
+			for (sp_token = token; sp_token;
+			     sp_token = sp_token->next) {
+				if (sp_token->priority < token->priority) {
+					break;
+				}
+			}
+			high_priority_token->type = MATH_NUMBER;
+			high_priority_token->value = operate(token);
+			high_priority_token->next = sp_token;
+			token = high_priority_token;
+		} else if (token->priority < priority) {
+			prev_token->next = NULL;
+			return do_operations(start_token);
+		}
+		prev_token = token;
+	}
+	return do_operations(start_token);
 }
 
-int 
-math(int argc, char* argv[]) {
-  argc--; argv++;
-  double result;
-
-  if (argc != 1) {
-    return usage();
-  }
-
-  if (strcmp(argv[0], "--help") == 0) {
-    return help();
-  }
-
-  Token * first_token = tokenize(argv[0]);
-  if (first_token == NULL) {
-    return EXIT_FAILURE;
-  }
-
-  if (substitute_values(first_token) != 0) {
-    fprintf(stderr,"mash: error: math: incorrect expression '%s'\n", argv[0]);
-    free_all_tokens(first_token);
-    return EXIT_FAILURE;
-  }
-
-  result = operate(first_token);
-
-  if (error_in_operations) {
-    error_in_operations = 0;
-    fprintf(stderr,"mash: error: math: division by 0 in '%s'\n", argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  printf("%d\n",(int)result);
-  return EXIT_SUCCESS;
-}
\ No newline at end of file
+int
+math(int argc, char *argv[])
+{
+	argc--;
+	argv++;
+	double result;
+
+	if (argc != 1) {
+		return usage();
+	}
+
+	if (strcmp(argv[0], "--help") == 0) {
+		return help();
+	}
+
+	Token *first_token = tokenize(argv[0]);
+
+	if (first_token == NULL) {
+		return EXIT_FAILURE;
+	}
+
+	if (substitute_values(first_token) != 0) {
+		fprintf(stderr,
+			"mash: error: math: incorrect expression '%s'\n",
+			argv[0]);
+		free_all_tokens(first_token);
+		return EXIT_FAILURE;
+	}
+
+	result = operate(first_token);
+
+	if (error_in_operations) {
+		error_in_operations = 0;
+		fprintf(stderr, "mash: error: math: division by 0 in '%s'\n",
+			argv[0]);
+		return EXIT_FAILURE;
+	}
+
+	printf("%d\n", (int)result);
+	return EXIT_SUCCESS;
+}

From 9970c3261d7d457bd578ded5990cfd8e791fea82 Mon Sep 17 00:00:00 2001
From: Javier Izquierdo Hernandez <javizqh@gmail.com>
Date: Tue, 16 May 2023 18:34:16 +0200
Subject: [PATCH 3/3] Solving bug when calling from different dir

---
 Makefile                 |   3 +-
 build/.keep              |   1 -
 include/builtin/source.h |   4 ++
 install                  |   6 +-
 src/builtin/source.c     | 115 ++++++++++++++++++++++++++++++++++++---
 src/show_prompt.c        |   6 +-
 uninstall                |   2 +-
 7 files changed, 122 insertions(+), 15 deletions(-)
 delete mode 100644 build/.keep
 mode change 100644 => 100755 uninstall

diff --git a/Makefile b/Makefile
index 7fc5456..5a86d43 100644
--- a/Makefile
+++ b/Makefile
@@ -66,7 +66,8 @@ all: $(OUTPUT) $(MAIN)
 
 $(MAIN): $(OBJECTS) 
 	$(CXX) $(CXXFLAGS) $(INCLUDES) -o $(OUTPUTMAIN) $(OBJECTS) $(LFLAGS) $(LIBS)
-	# @./indent.sh */builtin/*.[ch]
+	@./indent.sh */builtin/*.[ch]
+	@./indent.sh */*.[c]
 
 # this is a suffix replacement rule for building .o's from .c's
 # it uses automatic variables $<: the name of the prerequisite of
diff --git a/build/.keep b/build/.keep
deleted file mode 100644
index 8b13789..0000000
--- a/build/.keep
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/include/builtin/source.h b/include/builtin/source.h
index b5d7870..f297fce 100644
--- a/include/builtin/source.h
+++ b/include/builtin/source.h
@@ -36,3 +36,7 @@ int add_source(char *source_file_name, int error_fd);
 int exec_sources();
 
 int read_source_file(char *filename);
+
+int find_path_srcfile(char *filename);
+
+int file_exists(char *path);
diff --git a/install b/install
index af655af..68cae1e 100755
--- a/install
+++ b/install
@@ -1,12 +1,12 @@
 #!/bin/bash
 
-NAME="Mash" 
+NAME="mash" 
 
 mkdir build/
 make
-chmod +x build/main
+chmod +x build/mash
 
-echo -e '#!/bin/bash\nOLDDIR="$PWD"\ncd "'$PWD'"\n ./build/main $@\nP_STATUS=$(echo $?)\ncd "$OLDDIR"\nexit $P_STATUS' > /usr/bin/$NAME
+cp $PWD/build/mash /usr/bin/mash
 #cp CLI/$NAME.1.gz /usr/share/man/man1/$NAME.1.gz
 
 chmod +x /usr/bin/$NAME
diff --git a/src/builtin/source.c b/src/builtin/source.c
index 54e7596..ae1b7e8 100644
--- a/src/builtin/source.c
+++ b/src/builtin/source.c
@@ -63,7 +63,6 @@ source(int argc, char *argv[], int stdout_fd, int stderr_fd)
 {
 	argc--;
 	argv++;
-	struct stat buffer;
 
 	out_fd = stdout_fd;
 	err_fd = stderr_fd;
@@ -74,12 +73,7 @@ source(int argc, char *argv[], int stdout_fd, int stderr_fd)
 	if (strcmp(argv[0], "--help") == 0) {
 		return help();
 	}
-	// Check if file exists
-	if (stat(argv[0], &buffer) < 0) {
-		dprintf(err_fd, "Mash: source: %s no such file in directory\n",
-			argv[0]);
-		return EXIT_FAILURE;
-	}
+
 	return add_source(argv[0], stderr_fd);
 }
 
@@ -114,7 +108,26 @@ int
 add_source(char *source_file_name, int error_fd)
 {
 	int index;
-	struct source_file *source_file = new_source_file(source_file_name);
+
+	char *source_name = malloc(MAX_FILE_LENGTH);
+
+	if (source_name == NULL) {
+		err(EXIT_FAILURE, "malloc failed");
+	}
+	memset(source_name, 0, MAX_FILE_LENGTH);
+
+	strcpy(source_name, source_file_name);
+
+	if (!find_path_srcfile(source_name)) {
+		dprintf(err_fd, "Mash: source: %s no such file in directory\n",
+			source_file_name);
+		free(source_name);
+		return EXIT_FAILURE;
+	}
+
+	struct source_file *source_file = new_source_file(source_name);
+
+	free(source_name);
 
 	for (index = 0; index < MAX_SOURCE_FILES; index++) {
 		if (sources[index] == NULL) {
@@ -164,3 +177,89 @@ read_source_file(char *filename)
 	free(buf);
 	return 1;
 }
+
+int
+find_path_srcfile(char *filename)
+{
+	int i;
+	char *cwd;
+	char *cwd_ptr;
+
+	char *path, *orig_path;
+	char *path_ptr;
+	int path_len = 0;
+	char path_tok[MAX_PATH_LOCATIONS][MAX_ENV_SIZE];
+	char *token;
+
+	// Check if the first character is /
+	if (*filename == '/' && file_exists(filename)) {
+		return 1;
+	}
+	// CHECK IN CWD
+	cwd = malloc(MAX_ENV_SIZE);
+
+	if (cwd == NULL) {
+		err(EXIT_FAILURE, "malloc failed");
+	}
+	memset(cwd, 0, MAX_ENV_SIZE);
+	// Copy the path
+	if (getcwd(cwd, MAX_ENV_SIZE) == NULL) {
+		free(cwd);
+		return 0;
+	}
+	cwd_ptr = cwd;
+
+	strcat(cwd_ptr, "/");
+	strcat(cwd_ptr, filename);
+
+	if (file_exists(cwd_ptr)) {
+		strcpy(filename, cwd_ptr);
+		free(cwd);
+		return 1;
+	}
+	free(cwd);
+
+	// SEARCH IN PATH
+	// First get the path from env PATH
+	path = malloc(MAX_PATH_SIZE);
+
+	if (path == NULL) {
+		err(EXIT_FAILURE, "malloc failed");
+	}
+	memset(path, 0, MAX_PATH_SIZE);
+	// Copy the path
+	orig_path = getenv("PATH");
+	if (orig_path == NULL || strlen(orig_path) > MAX_PATH_SIZE - 1) {
+		free(path);
+		return 0;
+	}
+	strcpy(path, orig_path);
+	path_ptr = path;
+
+	// Then separate the path by : using strtok
+	while ((token = strtok_r(path_ptr, ":", &path_ptr))) {
+		strcpy(path_tok[path_len], token);
+		path_len++;
+	}
+	// Loop through the path until we find an exec
+
+	for (i = 0; i < path_len; i++) {
+		strcat(path_tok[i], "/");
+		strcat(path_tok[i], filename);
+		if (file_exists(path_tok[i])) {
+			strcpy(filename, path_tok[i]);
+			free(path);
+			return 1;
+		}
+	}
+	free(path);
+	return 0;
+}
+
+int
+file_exists(char *path)
+{
+	struct stat buf;
+
+	return (stat(path, &buf) == 0);
+}
diff --git a/src/show_prompt.c b/src/show_prompt.c
index df74436..179bf02 100644
--- a/src/show_prompt.c
+++ b/src/show_prompt.c
@@ -48,7 +48,11 @@ prompt(char *line)
 		if (syntax_mode == BASIC_SYNTAX) {
 			printf("$ ");
 		} else {
-			parse_prompt(prompt, line);
+			if (prompt) {
+				parse_prompt(prompt, line);
+			} else {
+				printf("$ ");
+			}
 		}
 		fflush(stdout);
 	}
diff --git a/uninstall b/uninstall
old mode 100644
new mode 100755
index 546631a..8c98303
--- a/uninstall
+++ b/uninstall
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-NAME="Mash" 
+NAME="mash" 
 
 make clean