loc.fb

struct Data {
    extension *u8

    files i32
    lines i32
}

func main() i32 {
    var data = Data {
        extension: ".go",
        files: 0,
        lines: 0
    };

    directory(&data, ".");

    printf("Found %d files with the extension '%s'\n", data.files, data.extension);
    printf("Line count: %d\n", data.lines);

    return 0;
}

func directory(data *Data, path *u8) {
    var dir = opendir(path);

    for {
        var entry = readdir(dir);

        if (entry == nil) {
            break;
        }

        var child = combine(path, &entry.name[0]);

        if (entry.type == 4) {
            // Directory
            if (!equals(&entry.name[0], ".") && !equals(&entry.name[0], "..")) {
                directory(data, child);
            }
        }
        else if (entry.type == 8) {
            // File
            file(data, child);
        }

        free(child);
    }

    closedir(dir);
}

func file(data *Data, path *u8) {
    if (endsWith(path, data.extension)) {
        data.files += 1;
        data.lines += getLineCount(path);
    }
}

func getLineCount(path *u8) i32 {
    var lines = 0;
    var stream = fopen(path, "rb");

    var str [1024]u8;

    for {
        var read = fread(&str[0], 1 as u64, 1024 as u64, stream) as i32;

        if (read == 0) {
            break;
        }

        lines += count(&str[0], read, '\n');
    }

    fclose(stream);
    return lines;
}

func count(str *u8, len i32, char u8) i32 {
    var i = 0;
    var count = 0;

    for {
        if (i >= len) {
            break;
        }

        if (str[i] == char) {
            count += 1;
        }

        i += 1;
    }

    return count;
}

func combine(left *u8, right *u8) *u8 {
    var leftLen = length(left);
    var rightLen = length(right);

    var len = leftLen + 1 + rightLen + 1;
    var str = malloc(len as u64) as *u8;

    memcpy(str, left, leftLen as u64);
    str[leftLen] = '/';
    memcpy(&str[leftLen + 1], right, rightLen as u64);
    str[len - 1] = '\0';

    return str;
}

func length(str *u8) i32 {
    var i = 0;

    for {
        var ch = str[i];

        if (ch == '\0') {
            break;
        }

        i += 1;
    }

    return i;
}

func equals(str1 *u8, str2 *u8) bool {
    var i = 0;

    for {
        var ch1 = str1[i];
        var ch2 = str2[i];

        if (ch1 != ch2) {
            return false;
        }

        if (ch1 == '\0' && ch2 == '\0') {
            break;
        }

        i += 1;
    }
    
    return true;
}

func endsWith(str *u8, end *u8) bool {
    var strLen = length(str);
    var endLen = length(end);

    if (endLen > strLen) {
        return false;
    }

    var i = 0;

    for {
        if (i >= endLen) {
            break;
        }

        if (str[strLen - 1 - i] != end[endLen - 1 - i]) {
            return false;
        }

        i += 1;
    }

    return true;
}

// LIBC

struct Dir {}

struct DirEntry {
    ino i64
    off i64
    reclen i16
    type i8
    name [256]u8
}

struct File {}

extern func printf(format *u8, ...) void

extern func malloc(size u64) *void
extern func free(ptr *void) void

extern func memcpy(dest *void, src *void, size u64) void

extern func opendir(name *u8) *Dir
extern func closedir(dir *Dir) i32
extern func readdir(dir *Dir) *DirEntry

extern func fopen(path *u8, mode *u8) *File
extern func fclose(stream *File) i32
extern func fread(ptr *void, size u64, nmemb u64, stream *File) u64