README.md

@@ -1,73 +0,0 @@
-# Minimake
-
-Minimake is a small project written in about a week in C99. Its goal was to reproduce the main features of the well known GNU Make utility.
-
-> **Note** This is a school project, therefore it probably won't interest you if you are looking for something useful.
-
-## Build
-
-```sh
-make
-```
-or even better
-```sh
-minimake
-```
-
-## How it works
-
-If you're not familiar with Make, what it does is that it reads a file named
-`Makefile` in the current directory which contains instructions to build a
-project in the form of recipes. It includes support for variables, dependencies
-, implicit rules and more.
-
-Then depending on the user input it automatically executes a recipe with its dependencies.
-
-
-Here is what a basic one can look like
-```make
-BENCH_FLAGS = --all
-
-test_and_bench:
-  bash ./runtests.sh
-  bash ./runbenchs.sh $(BENCH_FLAGS)
-```
-
-But it will more realisticly look like that
-
-```make
-CC = gcc
-CFLAGS = -std=c99 -pedantic -Werror -Wall -Wextra -Wvla
-LDFLAGS=
-
-DBG_CFLAGS = -fsanitize=address -g
-DBG_LDFLAGS= -fsanitize=address
-
-
-SRC_DIR = src
-LIB_SRCS = lines/lines.c hash_maps/hash_maps.c lists/lists.c files/files.c
-MAIN_SRCS = main.c minimake.c
-
-SRCS = $(MAIN_SRCS:%=$(SRC_DIR)/%) $(LIB_SRCS:%=$(SRC_DIR)/%)
-OBJS = $(SRCS:.c=.o)
-
-TARGET= minimake
-DBG_TARGET = minimake-dbg
-
-$(TARGET): $(OBJS)
-	$(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
-	@echo $(OBJS)
-
-debug: CFLAGS += $(DBG_CFLAGS)
-debug: LDFLAGS += $(DBG_LDFLAGS)
-debug: $(OBJS)
-	$(CC) -o $(DBG_TARGET) $^ $(LDFLAGS) $(LDLIBS)
-
-check:
-	dash ./tests/run.sh
-
-clean:
-	$(RM) $(TARGET)
-	$(RM) $(OBJS)
-
-```

micromake/src/Microfile

@@ -0,0 +1,3 @@
+qwertyu:
+cbejw: a bc d
+dmwq    :d   wdwd 

micromake/src/micromake.c

@@ -0,0 +1,119 @@
+#define _POSIX_C_SOURCE 200809L
+#define BUFFER_SIZE 1024
+#define STRING_BUFFER_SIZE 32
+
+#include <ctype.h>
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Helps to match a string (excludes blanks and special characters)
+static int is_char(char c)
+{
+    return c != '\0' && !isblank(c) && c != ':' && c != '=' && c != '#';
+}
+
+// Returns the next word from buf until buf_len,
+// and the numbers of read characters in *read_chars
+// WARNING allocates the result on the heap
+static char *readWord(char *buf, size_t buf_len, size_t *read_chars)
+{
+    size_t i = 0;
+    size_t str_buf_size = STRING_BUFFER_SIZE;
+    char *str_buf = malloc(sizeof(char) * str_buf_size);
+    while (i < buf_len && is_char(buf[i]))
+    {
+        // Reallocate more space if necessary
+        if (i >= str_buf_size - 1)
+        {
+            str_buf_size += STRING_BUFFER_SIZE;
+            str_buf = realloc(str_buf, str_buf_size);
+            if (str_buf == NULL)
+                errx(2, "Could not realloc");
+        }
+
+        str_buf[i] = buf[i];
+        i++;
+    }
+
+    str_buf[i] = '\0';
+    *read_chars = i;
+
+    return str_buf;
+}
+
+int skip_blanks(char *buf, size_t buf_len)
+{
+    size_t i = 0;
+    while (i < buf_len && isblank(buf[i]))
+        i++;
+    return i;
+}
+
+int main(int argc, char **argv)
+{
+    if (argc < 2)
+        errx(2, "Not enough arguments");
+    if (argc > 2)
+        errx(2, "Not enough arguments");
+
+    // Open file
+    FILE *stream = fopen(argv[1], "r");
+    if (stream == 0)
+        errx(2, "Could not open file");
+
+    // Allocate buffer
+    size_t buf_size = BUFFER_SIZE;
+    char *buf = malloc(sizeof(char) * buf_size);
+    if (buf == NULL)
+        errx(2, "Could not allocate more memory");
+
+    // Read
+    ssize_t nread;
+    while ((nread = getline(&buf, &buf_size, stream)) != -1)
+    {
+        size_t u_nread = nread;
+        size_t i = 0;
+        // Skip blanks
+        i += skip_blanks(buf + i, nread - i);
+
+        // Read target name
+        size_t skipped_chars = 0;
+        char *rule_name = readWord(buf + i, nread - i, &skipped_chars);
+        if (skipped_chars != 0)
+            printf("%s:", rule_name);
+        i += skipped_chars;
+
+        // Skip until ':'
+        i += skip_blanks(buf + i, nread - i);
+        if (buf[i] != ':')
+            errx(2, "Unexpected character '%c' after rule declaration '%s'",
+                 buf[i], rule_name);
+        i++;
+
+        // Read deps
+        while (i < u_nread)
+        {
+            // Skip blanks
+            i += skip_blanks(buf + i, nread - i);
+
+            // Read word
+            size_t skipped_chars = 0;
+            char *dep_name = readWord(buf + i, nread - i, &skipped_chars);
+            if (skipped_chars != 0)
+                printf(" %s", dep_name);
+            free(dep_name);
+            i += skipped_chars;
+
+            if (!is_char(buf[i]) && !isblank(buf[i]) && buf[i] != '\0')
+                errx(2, "Unexpected character '%c'", buf[i]);
+        }
+
+        i++;
+        free(rule_name);
+    }
+
+    free(buf);
+    fclose(stream);
+    return 0;
+}

microshell/microshell.c

@@ -0,0 +1,30 @@
+#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main(int argc, char **argv)
+{
+    if (argc < 2)
+        err(1, "Not enough args");
+
+    int id = fork();
+    if (id < 0)
+        err(1, "Cannot fork");
+
+    if (id == 0)
+    {
+        int res = 0;
+        wait(&res);
+        // printf("%d\n", res);
+        return res;
+    }
+    else
+    {
+        int res = execl("/bin/sh", "supershell", "-c", argv[1], NULL);
+        printf("process exit status: %d\n", res);
+        // exit(res);
+        return res;
+    }
+}

minimake/src/minimake.c

@@ -8,7 +8,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/stat.h>
 #include <unistd.h>
 
 #include "files/files.h"
@@ -18,14 +17,14 @@
 
 // Static variables
 
-static char *program_name;
+char *program_name;
 
-static struct hash_map *variables = NULL;
+struct hash_map *variables = NULL;
-static struct hash_map *rules = NULL;
+struct hash_map *rules = NULL;
 
 // Keeps track of variables and rules order
-static struct list *variables_list = NULL;
+struct list *variables_list = NULL;
-static struct list *rules_list = NULL;
+struct list *rules_list = NULL;
 
 // ==== Misc ====
 
@@ -338,7 +337,6 @@ size_t expand_variable(struct line *line, size_t index, char **value)
 
             // Get corresponding value
             *value = get_variable_value(var_name, line->number);
-            free(var_name);
         }
 
         return 2;
@@ -462,34 +460,9 @@ void make_parse(char *path)
 
 // ==== Runtime ====
 
-// Return 1 if rule is up to date, 0 otherwise
-static int uptodate(struct rule *rule)
-{
-    struct stat path_stat;
-
-    if (lstat(rule->name, &path_stat) != 0) // target doesn't exists
-        return 0;
-
-    struct list *dependencies = rule->dependencies;
-    while (dependencies != NULL)
-    {
-        char *depname = dependencies->data;
-        if (lstat(depname, &path_stat) != 0) // Dependecy doesn't exists
-            return 0;
-    }
-    return 1;
-}
-
 // Expands and run a specified rule
 static int run_rule(struct rule *rule)
 {
-    // Check if p to date
-    if (uptodate(rule))
-    {
-        printf("%s: '%s' is up to date.", program_name, rule->name);
-        return 0;
-    }
-
     struct list *commands = rule->recipe;
     struct list *dependencies = rule->dependencies;
 

simple_ls/simple_ls.c

@@ -0,0 +1,37 @@
+#include <dirent.h>
+#include <err.h>
+#include <stdio.h>
+
+static void simple_ls(char *path)
+{
+    if (path == NULL)
+        errx(1, "Internal error: Passed NULL path");
+
+    DIR *dir = opendir(path);
+    if (dir == NULL)
+        errx(1, "Internal error: cannot open directory");
+
+    struct dirent *element;
+    while ((element = readdir(dir)))
+    {
+        puts(element->d_name);
+    }
+
+    int res = closedir(dir);
+    if (res == -1)
+        errx(1, "Could not close dir");
+}
+
+int main(int argc, char **argv)
+{
+    if (argc < 2)
+        simple_ls(".");
+    else
+    {
+        for (int i = 1; i < argc; i++)
+        {
+            simple_ls(argv[i]);
+        }
+    }
+    return 0;
+}