made the _ToEpoch functions in the datetime lib return INTs instead of DOUBLEs

libs/datetime/date_functions.c

@@ -0,0 +1,422 @@
+#include "date_functions.h"
+#include <stdio.h>
+
+GroundValue tmToGroundValue(struct tm t) {
+    GroundStruct timeStruct = groundCreateStruct();
+    groundAddFieldToStruct(&timeStruct, "year", groundCreateValue(INT, t.tm_year + 1900));
+    groundAddFieldToStruct(&timeStruct, "month", groundCreateValue(INT, t.tm_mon + 1));
+    groundAddFieldToStruct(&timeStruct, "day", groundCreateValue(INT, t.tm_mday));
+    groundAddFieldToStruct(&timeStruct, "hour", groundCreateValue(INT, t.tm_hour));
+    groundAddFieldToStruct(&timeStruct, "minute", groundCreateValue(INT, t.tm_min));
+    groundAddFieldToStruct(&timeStruct, "second", groundCreateValue(INT, t.tm_sec));
+    groundAddFieldToStruct(&timeStruct, "weekDay", groundCreateValue(INT, t.tm_wday));
+    groundAddFieldToStruct(&timeStruct, "yearDay", groundCreateValue(INT, t.tm_yday + 1));
+    groundAddFieldToStruct(&timeStruct, "isDaylightSavingsTime", groundCreateValue(BOOL, t.tm_isdst));
+    
+    GroundValue value = groundCreateValue(CUSTOM, &timeStruct);
+    value.type = CUSTOM;
+
+    return value;
+}
+
+GroundValue datetime_Now(GroundScope* scope, List args) {
+    time_t now = time(NULL);
+    struct tm t = {0};
+
+    localtime_r(&now, &t);
+
+    // return a -datetime struct
+    return tmToGroundValue(t);
+}
+
+GroundValue datetime_FromEpochLocal(GroundScope* scope, List args) {
+    struct tm t = {0};
+    time_t ts = args.values[0].data.doubleVal;
+
+    localtime_r(&ts, &t);
+
+    return tmToGroundValue(t);
+}
+
+GroundValue datetime_FromEpochUTC(GroundScope* scope, List args) {
+    struct tm t = {0};
+    time_t ts = args.values[0].data.doubleVal;
+
+    gmtime_r(&ts, &t);
+
+    return tmToGroundValue(t);
+}
+
+GroundValue datetime_ToEpochLocal(GroundScope* scope, List args) {
+    GroundObject obj = *args.values[0].data.customVal;
+
+    // check args
+    GroundObjectField* year = groundFindField(obj, "year");
+    if (year == NULL || year->value.type != INT) ERROR("Object does not have year field as int", "ValueError");
+    GroundObjectField* month = groundFindField(obj, "month");
+    if (month == NULL || month->value.type != INT) ERROR("Object does not have month field as int", "ValueError");
+    GroundObjectField* day = groundFindField(obj, "day");
+    if (day == NULL || day->value.type != INT) ERROR("Object does not have day field as int", "ValueError");
+    GroundObjectField* hour = groundFindField(obj, "hour");
+    if (hour == NULL || hour->value.type != INT) ERROR("Object does not have hour field as int", "ValueError");
+    GroundObjectField* minute = groundFindField(obj, "minute");
+    if (minute == NULL || minute->value.type != INT) ERROR("Object does not have minute field as int", "ValueError");
+    GroundObjectField* second = groundFindField(obj, "second");
+    if (second == NULL || second->value.type != INT) ERROR("Object does not have second field as int", "ValueError");
+    GroundObjectField* weekDay = groundFindField(obj, "weekDay");
+    if (weekDay == NULL || weekDay->value.type != INT) ERROR("Object does not have weekDay field as int", "ValueError");
+    GroundObjectField* yearDay = groundFindField(obj, "yearDay");
+    if (yearDay == NULL || yearDay->value.type != INT) ERROR("Object does not have yearDay field as int", "ValueError");
+    GroundObjectField* isDaylightSavingsTime = groundFindField(obj, "isDaylightSavingsTime");
+    if (isDaylightSavingsTime == NULL || isDaylightSavingsTime->value.type != BOOL) ERROR("Object does not have isDaylightSavingsTime field as bool", "ValueError");
+
+    // construct tm struct from our ground struct
+    struct tm t = {
+        .tm_sec = second->value.data.intVal,
+        .tm_min = minute->value.data.intVal,
+        .tm_hour = hour->value.data.intVal,
+        .tm_mday = day->value.data.intVal,
+        .tm_mon = month->value.data.intVal - 1,
+        .tm_year = year->value.data.intVal - 1900,
+        .tm_wday = 0,
+        .tm_yday = 0,
+        .tm_isdst = -1
+    };
+
+    time_t ts = mktime(&t);
+    return groundCreateValue(INT, (long long)ts);
+}
+
+GroundValue datetime_ToEpochUTC(GroundScope* scope, List args) {
+    GroundObject obj = *args.values[0].data.customVal;
+
+    // check args
+    GroundObjectField* year = groundFindField(obj, "year");
+    if (year == NULL || year->value.type != INT) ERROR("Object does not have year field as int", "ValueError");
+    GroundObjectField* month = groundFindField(obj, "month");
+    if (month == NULL || month->value.type != INT) ERROR("Object does not have month field as int", "ValueError");
+    GroundObjectField* day = groundFindField(obj, "day");
+    if (day == NULL || day->value.type != INT) ERROR("Object does not have day field as int", "ValueError");
+    GroundObjectField* hour = groundFindField(obj, "hour");
+    if (hour == NULL || hour->value.type != INT) ERROR("Object does not have hour field as int", "ValueError");
+    GroundObjectField* minute = groundFindField(obj, "minute");
+    if (minute == NULL || minute->value.type != INT) ERROR("Object does not have minute field as int", "ValueError");
+    GroundObjectField* second = groundFindField(obj, "second");
+    if (second == NULL || second->value.type != INT) ERROR("Object does not have second field as int", "ValueError");
+    GroundObjectField* weekDay = groundFindField(obj, "weekDay");
+    if (weekDay == NULL || weekDay->value.type != INT) ERROR("Object does not have weekDay field as int", "ValueError");
+    GroundObjectField* yearDay = groundFindField(obj, "yearDay");
+    if (yearDay == NULL || yearDay->value.type != INT) ERROR("Object does not have yearDay field as int", "ValueError");
+    GroundObjectField* isDaylightSavingsTime = groundFindField(obj, "isDaylightSavingsTime");
+    if (isDaylightSavingsTime == NULL || isDaylightSavingsTime->value.type != BOOL) ERROR("Object does not have isDaylightSavingsTime field as bool", "ValueError");
+
+    // construct tm struct from our ground struct
+    struct tm t = {
+        .tm_sec = second->value.data.intVal,
+        .tm_min = minute->value.data.intVal,
+        .tm_hour = hour->value.data.intVal,
+        .tm_mday = day->value.data.intVal,
+        .tm_mon = month->value.data.intVal - 1,
+        .tm_year = year->value.data.intVal - 1900,
+        .tm_wday = 0,
+        .tm_yday = 0,
+        .tm_isdst = -1
+    };
+
+    time_t ts = timegm(&t);
+    return groundCreateValue(INT, (long long)ts);
+}
+
+GroundValue formatDatetimeObj(GroundObject obj, char* formatString) {
+    // check args
+    GroundObjectField* year = groundFindField(obj, "year");
+    if (year == NULL || year->value.type != INT) ERROR("Object does not have year field as int", "ValueError");
+    GroundObjectField* month = groundFindField(obj, "month");
+    if (month == NULL || month->value.type != INT) ERROR("Object does not have month field as int", "ValueError");
+    GroundObjectField* day = groundFindField(obj, "day");
+    if (day == NULL || day->value.type != INT) ERROR("Object does not have day field as int", "ValueError");
+    GroundObjectField* hour = groundFindField(obj, "hour");
+    if (hour == NULL || hour->value.type != INT) ERROR("Object does not have hour field as int", "ValueError");
+    GroundObjectField* minute = groundFindField(obj, "minute");
+    if (minute == NULL || minute->value.type != INT) ERROR("Object does not have minute field as int", "ValueError");
+    GroundObjectField* second = groundFindField(obj, "second");
+    if (second == NULL || second->value.type != INT) ERROR("Object does not have second field as int", "ValueError");
+    GroundObjectField* weekDay = groundFindField(obj, "weekDay");
+    if (weekDay == NULL || weekDay->value.type != INT) ERROR("Object does not have weekDay field as int", "ValueError");
+    GroundObjectField* yearDay = groundFindField(obj, "yearDay");
+    if (yearDay == NULL || yearDay->value.type != INT) ERROR("Object does not have yearDay field as int", "ValueError");
+    GroundObjectField* isDaylightSavingsTime = groundFindField(obj, "isDaylightSavingsTime");
+    if (isDaylightSavingsTime == NULL || isDaylightSavingsTime->value.type != BOOL) ERROR("Object does not have isDaylightSavingsTime field as bool", "ValueError");
+
+    // construct tm struct from our ground struct
+    struct tm t = {
+        .tm_sec = second->value.data.intVal,
+        .tm_min = minute->value.data.intVal,
+        .tm_hour = hour->value.data.intVal,
+        .tm_mday = day->value.data.intVal,
+        .tm_mon = month->value.data.intVal - 1,
+        .tm_year = year->value.data.intVal - 1900,
+        .tm_wday = 0,
+        .tm_yday = 0,
+        .tm_isdst = -1
+    };
+
+    mktime(&t); // normalise time
+
+    // create a buffer for the string
+    char* buffer = (char*)malloc(128);
+    strftime(buffer, 128, formatString, &t);
+
+    // return ground version of string
+    return groundCreateValue(STRING, buffer);
+}
+
+GroundValue datetime_Format(GroundScope* scope, List args) {
+    return formatDatetimeObj(
+        *args.values[0].data.customVal,
+        args.values[1].data.stringVal
+    );
+}
+
+GroundValue datetime_FromFormatted(GroundScope* scope, List args) {
+    char* timeString = args.values[0].data.stringVal;
+    char* formatString = args.values[1].data.stringVal;
+
+    struct tm t = {0};
+    t.tm_isdst = -1;
+    char* result = strptime(timeString, formatString, &t);
+
+    if (result == NULL) {
+        ERROR("Time string does not match format!", "ValueError");
+    }
+
+    mktime(&t);
+
+    return tmToGroundValue(t);
+}
+
+GroundValue datetime_ToISO8601UTC(GroundScope* scope, List args) {
+    GroundObject obj = *args.values[0].data.customVal;
+
+    // check args
+    GroundObjectField* year = groundFindField(obj, "year");
+    if (year == NULL || year->value.type != INT) ERROR("Object does not have year field as int", "ValueError");
+    GroundObjectField* month = groundFindField(obj, "month");
+    if (month == NULL || month->value.type != INT) ERROR("Object does not have month field as int", "ValueError");
+    GroundObjectField* day = groundFindField(obj, "day");
+    if (day == NULL || day->value.type != INT) ERROR("Object does not have day field as int", "ValueError");
+    GroundObjectField* hour = groundFindField(obj, "hour");
+    if (hour == NULL || hour->value.type != INT) ERROR("Object does not have hour field as int", "ValueError");
+    GroundObjectField* minute = groundFindField(obj, "minute");
+    if (minute == NULL || minute->value.type != INT) ERROR("Object does not have minute field as int", "ValueError");
+    GroundObjectField* second = groundFindField(obj, "second");
+    if (second == NULL || second->value.type != INT) ERROR("Object does not have second field as int", "ValueError");
+    GroundObjectField* weekDay = groundFindField(obj, "weekDay");
+    if (weekDay == NULL || weekDay->value.type != INT) ERROR("Object does not have weekDay field as int", "ValueError");
+    GroundObjectField* yearDay = groundFindField(obj, "yearDay");
+    if (yearDay == NULL || yearDay->value.type != INT) ERROR("Object does not have yearDay field as int", "ValueError");
+    GroundObjectField* isDaylightSavingsTime = groundFindField(obj, "isDaylightSavingsTime");
+    if (isDaylightSavingsTime == NULL || isDaylightSavingsTime->value.type != BOOL) ERROR("Object does not have isDaylightSavingsTime field as bool", "ValueError");
+
+    // construct tm struct from our ground struct
+    struct tm t = {
+        .tm_sec = second->value.data.intVal,
+        .tm_min = minute->value.data.intVal,
+        .tm_hour = hour->value.data.intVal,
+        .tm_mday = day->value.data.intVal,
+        .tm_mon = month->value.data.intVal - 1,
+        .tm_year = year->value.data.intVal - 1900,
+        .tm_wday = 0,
+        .tm_yday = 0,
+        .tm_isdst = -1
+    };
+
+    time_t ts = mktime(&t);
+    gmtime_r(&ts, &t);
+
+    char* buffer = (char*)malloc(128);
+    strftime(buffer, 128, "%Y-%m-%dT%H:%M:%SZ", &t);
+
+    return groundCreateValue(STRING, buffer);
+}
+
+GroundValue datetime_ToISO8601Local(GroundScope* scope, List args) {
+    GroundObject obj = *args.values[0].data.customVal;
+
+    // check args
+    GroundObjectField* year = groundFindField(obj, "year");
+    if (year == NULL || year->value.type != INT) ERROR("Object does not have year field as int", "ValueError");
+    GroundObjectField* month = groundFindField(obj, "month");
+    if (month == NULL || month->value.type != INT) ERROR("Object does not have month field as int", "ValueError");
+    GroundObjectField* day = groundFindField(obj, "day");
+    if (day == NULL || day->value.type != INT) ERROR("Object does not have day field as int", "ValueError");
+    GroundObjectField* hour = groundFindField(obj, "hour");
+    if (hour == NULL || hour->value.type != INT) ERROR("Object does not have hour field as int", "ValueError");
+    GroundObjectField* minute = groundFindField(obj, "minute");
+    if (minute == NULL || minute->value.type != INT) ERROR("Object does not have minute field as int", "ValueError");
+    GroundObjectField* second = groundFindField(obj, "second");
+    if (second == NULL || second->value.type != INT) ERROR("Object does not have second field as int", "ValueError");
+    GroundObjectField* weekDay = groundFindField(obj, "weekDay");
+    if (weekDay == NULL || weekDay->value.type != INT) ERROR("Object does not have weekDay field as int", "ValueError");
+    GroundObjectField* yearDay = groundFindField(obj, "yearDay");
+    if (yearDay == NULL || yearDay->value.type != INT) ERROR("Object does not have yearDay field as int", "ValueError");
+    GroundObjectField* isDaylightSavingsTime = groundFindField(obj, "isDaylightSavingsTime");
+    if (isDaylightSavingsTime == NULL || isDaylightSavingsTime->value.type != BOOL) ERROR("Object does not have isDaylightSavingsTime field as bool", "ValueError");
+
+    // construct tm struct from our ground struct
+    struct tm t = {
+        .tm_sec = second->value.data.intVal,
+        .tm_min = minute->value.data.intVal,
+        .tm_hour = hour->value.data.intVal,
+        .tm_mday = day->value.data.intVal,
+        .tm_mon = month->value.data.intVal - 1,
+        .tm_year = year->value.data.intVal - 1900,
+        .tm_wday = 0,
+        .tm_yday = 0,
+        .tm_isdst = -1
+    };
+
+    time_t ts = mktime(&t);
+    localtime_r(&ts, &t);
+
+    char* buffer = (char*)malloc(128);
+    strftime(buffer, 128, "%Y-%m-%dT%H:%M:%S%z", &t);
+
+    return groundCreateValue(STRING, buffer);
+}
+
+GroundValue datetime_Diff(GroundScope* scope, List args) {
+    GroundObject obj1 = *args.values[0].data.customVal;
+    GroundObject obj2 = *args.values[1].data.customVal;
+
+    // check first timedate object
+    GroundObjectField* year = groundFindField(obj1, "year");
+    if (year == NULL || year->value.type != INT) ERROR("Object 1 does not have year field as int", "ValueError");
+    GroundObjectField* month = groundFindField(obj1, "month");
+    if (month == NULL || month->value.type != INT) ERROR("Object 1 does not have month field as int", "ValueError");
+    GroundObjectField* day = groundFindField(obj1, "day");
+    if (day == NULL || day->value.type != INT) ERROR("Object 1 does not have day field as int", "ValueError");
+    GroundObjectField* hour = groundFindField(obj1, "hour");
+    if (hour == NULL || hour->value.type != INT) ERROR("Object 1 does not have hour field as int", "ValueError");
+    GroundObjectField* minute = groundFindField(obj1, "minute");
+    if (minute == NULL || minute->value.type != INT) ERROR("Object 1 does not have minute field as int", "ValueError");
+    GroundObjectField* second = groundFindField(obj1, "second");
+    if (second == NULL || second->value.type != INT) ERROR("Object 1 does not have second field as int", "ValueError");
+    GroundObjectField* weekDay = groundFindField(obj1, "weekDay");
+    if (weekDay == NULL || weekDay->value.type != INT) ERROR("Object 1 does not have weekDay field as int", "ValueError");
+    GroundObjectField* yearDay = groundFindField(obj1, "yearDay");
+    if (yearDay == NULL || yearDay->value.type != INT) ERROR("Object 1 does not have yearDay field as int", "ValueError");
+    GroundObjectField* isDaylightSavingsTime = groundFindField(obj1, "isDaylightSavingsTime");
+    if (isDaylightSavingsTime == NULL || isDaylightSavingsTime->value.type != BOOL) ERROR("Object 1 does not have isDaylightSavingsTime field as bool", "ValueError");
+
+    // construct tm struct from our ground struct
+    struct tm t1 = {
+        .tm_sec = second->value.data.intVal,
+        .tm_min = minute->value.data.intVal,
+        .tm_hour = hour->value.data.intVal,
+        .tm_mday = day->value.data.intVal,
+        .tm_mon = month->value.data.intVal - 1,
+        .tm_year = year->value.data.intVal - 1900,
+        .tm_wday = 0,
+        .tm_yday = 0,
+        .tm_isdst = -1
+    };
+    
+    
+    // check second timedate object
+    year = groundFindField(obj2, "year");
+    if (year == NULL || year->value.type != INT) ERROR("Object does not have year field as int", "ValueError");
+    month = groundFindField(obj2, "month");
+    if (month == NULL || month->value.type != INT) ERROR("Object does not have month field as int", "ValueError");
+    day = groundFindField(obj2, "day");
+    if (day == NULL || day->value.type != INT) ERROR("Object does not have day field as int", "ValueError");
+    hour = groundFindField(obj2, "hour");
+    if (hour == NULL || hour->value.type != INT) ERROR("Object does not have hour field as int", "ValueError");
+    minute = groundFindField(obj2, "minute");
+    if (minute == NULL || minute->value.type != INT) ERROR("Object does not have minute field as int", "ValueError");
+    second = groundFindField(obj2, "second");
+    if (second == NULL || second->value.type != INT) ERROR("Object does not have second field as int", "ValueError");
+    weekDay = groundFindField(obj2, "weekDay");
+    if (weekDay == NULL || weekDay->value.type != INT) ERROR("Object does not have weekDay field as int", "ValueError");
+    yearDay = groundFindField(obj2, "yearDay");
+    if (yearDay == NULL || yearDay->value.type != INT) ERROR("Object does not have yearDay field as int", "ValueError");
+    isDaylightSavingsTime = groundFindField(obj2, "isDaylightSavingsTime");
+    if (isDaylightSavingsTime == NULL || isDaylightSavingsTime->value.type != BOOL) ERROR("Object does not have isDaylightSavingsTime field as bool", "ValueError");
+
+    // construct tm struct from our ground struct
+    struct tm t2 = {
+        .tm_sec = second->value.data.intVal,
+        .tm_min = minute->value.data.intVal,
+        .tm_hour = hour->value.data.intVal,
+        .tm_mday = day->value.data.intVal,
+        .tm_mon = month->value.data.intVal - 1,
+        .tm_year = year->value.data.intVal - 1900,
+        .tm_wday = 0,
+        .tm_yday = 0,
+        .tm_isdst = -1
+    };
+
+
+    time_t ts1 = mktime(&t1);
+    time_t ts2 = mktime(&t2);
+
+    return groundCreateValue(INT, ts2 - ts1);
+}
+
+GroundValue datetime_Add(GroundScope* scope, List args) {
+     GroundObject obj = *args.values[0].data.customVal;
+
+     long long secs = args.values[1].data.intVal;
+     long long mins = args.values[2].data.intVal;
+     long long hours = args.values[3].data.intVal;
+     long long days = args.values[4].data.intVal;
+
+    // check args
+    GroundObjectField* year = groundFindField(obj, "year");
+    if (year == NULL || year->value.type != INT) ERROR("Object does not have year field as int", "ValueError");
+    GroundObjectField* month = groundFindField(obj, "month");
+    if (month == NULL || month->value.type != INT) ERROR("Object does not have month field as int", "ValueError");
+    GroundObjectField* day = groundFindField(obj, "day");
+    if (day == NULL || day->value.type != INT) ERROR("Object does not have day field as int", "ValueError");
+    GroundObjectField* hour = groundFindField(obj, "hour");
+    if (hour == NULL || hour->value.type != INT) ERROR("Object does not have hour field as int", "ValueError");
+    GroundObjectField* minute = groundFindField(obj, "minute");
+    if (minute == NULL || minute->value.type != INT) ERROR("Object does not have minute field as int", "ValueError");
+    GroundObjectField* second = groundFindField(obj, "second");
+    if (second == NULL || second->value.type != INT) ERROR("Object does not have second field as int", "ValueError");
+    GroundObjectField* weekDay = groundFindField(obj, "weekDay");
+    if (weekDay == NULL || weekDay->value.type != INT) ERROR("Object does not have weekDay field as int", "ValueError");
+    GroundObjectField* yearDay = groundFindField(obj, "yearDay");
+    if (yearDay == NULL || yearDay->value.type != INT) ERROR("Object does not have yearDay field as int", "ValueError");
+    GroundObjectField* isDaylightSavingsTime = groundFindField(obj, "isDaylightSavingsTime");
+    if (isDaylightSavingsTime == NULL || isDaylightSavingsTime->value.type != BOOL) ERROR("Object does not have isDaylightSavingsTime field as bool", "ValueError");
+
+    // construct tm struct from our ground struct
+    struct tm t = {
+        .tm_sec = second->value.data.intVal,
+        .tm_min = minute->value.data.intVal,
+        .tm_hour = hour->value.data.intVal,
+        .tm_mday = day->value.data.intVal,
+        .tm_mon = month->value.data.intVal - 1,
+        .tm_year = year->value.data.intVal - 1900,
+        .tm_wday = 0,
+        .tm_yday = 0,
+        .tm_isdst = -1
+    };
+
+    time_t base = mktime(&t);
+
+    long long totalSeconds = 
+        secs +
+        mins * 60 +
+        hours * 3600 +
+        days * 86400;
+
+    base += totalSeconds;
+
+    struct tm newT;
+    localtime_r(&base, &newT);
+
+    return tmToGroundValue(newT);
+
+}

libs/datetime/date_functions.h

@@ -0,0 +1,18 @@
+#pragma once
+#define _XOPEN_SOURCE // to make gcc happy lol
+
+#include <groundext.h>
+#include <groundvm.h>
+#include <time.h>
+
+GroundValue datetime_Now(GroundScope* scope, List args);
+GroundValue datetime_Format(GroundScope* scope, List args);
+GroundValue datetime_FromFormatted(GroundScope* scope, List args);
+GroundValue datetime_ToISO8601UTC(GroundScope* scope, List args);
+GroundValue datetime_ToISO8601Local(GroundScope* scope, List args);
+GroundValue datetime_FromEpochLocal(GroundScope* scope, List args);
+GroundValue datetime_FromEpochUTC(GroundScope* scope, List args);
+GroundValue datetime_ToEpochLocal(GroundScope* scope, List args);
+GroundValue datetime_ToEpochUTC(GroundScope* scope, List args);
+GroundValue datetime_Diff(GroundScope* scope, List args);
+GroundValue datetime_Add(GroundScope* scope, List args);

libs/datetime/datetime.c

@@ -0,0 +1,18 @@
+#include "time_functions.h"
+#include "date_functions.h"
+
+
+void ground_init(GroundScope* scope) {
+    groundAddNativeFunction(scope, "datetime_NowEpoch", datetime_NowEpoch, DOUBLE, 0);
+    groundAddNativeFunction(scope, "datetime_Now", datetime_Now, CUSTOM, 0);
+    groundAddNativeFunction(scope, "datetime_Format", datetime_Format, STRING, 2, CUSTOM, "datetime", STRING, "format");
+    groundAddNativeFunction(scope, "datetime_FromFormatted", datetime_FromFormatted, CUSTOM, 2, STRING, "datetimeString", STRING, "format");
+    groundAddNativeFunction(scope, "datetime_ToISO8601UTC", datetime_ToISO8601UTC, STRING, 1, CUSTOM, "datetime");
+    groundAddNativeFunction(scope, "datetime_ToISO8601Local", datetime_ToISO8601Local, STRING, 1, CUSTOM, "datetime");
+    groundAddNativeFunction(scope, "datetime_FromEpochUTC", datetime_FromEpochUTC, CUSTOM, 1, DOUBLE, "epoch");
+    groundAddNativeFunction(scope, "datetime_FromEpochLocal", datetime_FromEpochLocal, CUSTOM, 1, DOUBLE, "epoch");
+    groundAddNativeFunction(scope, "datetime_ToEpochUTC", datetime_ToEpochUTC, INT, 1, CUSTOM, "datetime");
+    groundAddNativeFunction(scope, "datetime_ToEpochLocal", datetime_ToEpochLocal, INT, 1, CUSTOM, "datetime");
+    groundAddNativeFunction(scope, "datetime_Diff", datetime_Diff, INT, 2, CUSTOM, "datetime1", CUSTOM, "datetime2");
+    groundAddNativeFunction(scope, "datetime_Add", datetime_Add, CUSTOM, 5, CUSTOM, "datetime", INT, "seconds", INT, "minutes", INT, "hours", INT, "days");
+}

libs/datetime/time_functions.c

@@ -0,0 +1,12 @@
+#include "time_functions.h"
+
+GroundValue datetime_NowEpoch(GroundScope* scope, List args) {
+    // grab time from system clock
+    struct timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+
+    // convert it to secs and return it
+    double secsSinceEpoch = (double)ts.tv_sec + (double)ts.tv_nsec / 1e9;
+
+    return groundCreateValue(DOUBLE, secsSinceEpoch);
+}

libs/datetime/time_functions.h

@@ -0,0 +1,5 @@
+#pragma once
+#include <groundext.h>
+#include <time.h>
+
+GroundValue datetime_NowEpoch(GroundScope* scope, List args);

libs/request/request.c

@@ -1,35 +1,23 @@
 #include <groundext.h>
-#include <curl/curl.h>
 #include <groundvm.h>
+#include <curl/curl.h>
 #include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
+#include <stdbool.h>
 
-bool curl_init = false;
+CURL* curlHandle = NULL;
+
+GroundStruct template;
+
+const char* VALID_REQUEST_TYPES[] = {
+    "GET",
+    "POST"
+};
 
 typedef struct {
     char* data;
     size_t size;
 } ResponseBuffer;
 
-typedef struct {
-    CURL* handle;
-    bool connected;
-    char* url;
-} WebSocketConnection;
-
-// Global storage for WebSocket connections (simple implementation)
-#define MAX_WS_CONNECTIONS 10
-WebSocketConnection ws_connections[MAX_WS_CONNECTIONS] = {0};
-
-void curl_setup() {
-    if (!curl_init) {
-        curl_global_init(CURL_GLOBAL_ALL);
-        curl_init = true;
-    }
-}
-
-// Proper write callback that accumulates data
 size_t write_callback(void* ptr, size_t size, size_t nmemb, void* userdata) {
     size_t total_size = size * nmemb;
     ResponseBuffer* buffer = (ResponseBuffer*)userdata;
@@ -48,295 +36,117 @@ size_t write_callback(void* ptr, size_t size, size_t nmemb, void* userdata) {
     return total_size;
 }
 
-// GET request
-GroundValue get_request(GroundScope* scope, List args) {
-    curl_setup();
-    CURL* handle = curl_easy_init();
+GroundValue ground_request(GroundScope* scope, List args) {
 
-    if (!handle) {
-        ERROR("CURL failed to init", "GenericRequestError");
+    GroundObject obj = *args.values[0].data.customVal;
+
+    // check arg types
+    GroundObjectField* address = groundFindField(obj, "address");
+    if (address == NULL || address->value.type != STRING) {
+        ERROR("Object does not have address field as string", "ValueError");
+    }
+    GroundObjectField* type = groundFindField(obj, "type");
+    if (type == NULL || type->value.type != STRING) {
+        ERROR("Object does not have type field as string", "ValueError");
+    }
+    GroundObjectField* userAgent = groundFindField(obj, "userAgent");
+    if (userAgent == NULL || userAgent->value.type != STRING) {
+        ERROR("Object does not have userAgent field as string", "ValueError");
+    }
+    GroundObjectField* httpHeaders = groundFindField(obj, "httpHeaders");
+    if (httpHeaders == NULL || httpHeaders->value.type != LIST) {
+        ERROR("Object does not have httpHeaders field as list<string>", "ValueError");
+    }
+    GroundObjectField* verbose = groundFindField(obj, "verbose");
+    if (verbose == NULL || verbose->value.type != BOOL) {
+        ERROR("Object does not have verbose field as bool", "ValueError");
     }
 
-    ResponseBuffer buffer = {0};
-    buffer.data = malloc(1);
-    buffer.data[0] = '\0';
-    buffer.size = 0;
-    
-    curl_easy_setopt(handle, CURLOPT_URL, args.values[0].data.stringVal);
-    curl_easy_setopt(handle, CURLOPT_HTTPGET, 1L);
-    curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_callback);
-    curl_easy_setopt(handle, CURLOPT_WRITEDATA, &buffer);
-    curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1L);
-    
-    CURLcode result = curl_easy_perform(handle);
-    
-    if (result != CURLE_OK) {
-        char buf[256];
-        snprintf(buf, sizeof(buf) - 1, "Curl request failed: %s\n", curl_easy_strerror(result));
-        ERROR(buf, "ActionRequestError");
-    }
-    
-    curl_easy_cleanup(handle);
-    
-    GroundValue ret = groundCreateValue(STRING, buffer.data);
-    return ret;
-}
-
-// POST request
-GroundValue post_request(GroundScope* scope, List args) {
-    curl_setup();
-    CURL* handle = curl_easy_init();
-    
-    if (!handle) {
-        ERROR("CURL failed to init", "GenericRequestError");
-    }
-    
-    ResponseBuffer buffer = {0};
-    buffer.data = malloc(1);
-    buffer.data[0] = '\0';
-    buffer.size = 0;
-    
-    curl_easy_setopt(handle, CURLOPT_URL, args.values[0].data.stringVal);
-    curl_easy_setopt(handle, CURLOPT_POST, 1L);
-    curl_easy_setopt(handle, CURLOPT_POSTFIELDS, args.values[1].data.stringVal);
-    curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_callback);
-    curl_easy_setopt(handle, CURLOPT_WRITEDATA, &buffer);
-    curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1L);
-    
-    CURLcode result = curl_easy_perform(handle);
-    
-    if (result != CURLE_OK) {
-        free(buffer.data);
-        char buf[256];
-        snprintf(buf, sizeof(buf) - 1, "Curl request failed: %s\n", curl_easy_strerror(result));
-        curl_easy_cleanup(handle);
-        ERROR(buf, "ActionRequestError");
-    }
-    
-    curl_easy_cleanup(handle);
-    
-    GroundValue ret = groundCreateValue(STRING, buffer.data);
-    return ret;
-}
-
-// ============== WebSocket Functions ==============
-
-// Find an empty slot for a new WebSocket connection
-int find_ws_slot() {
-    for (int i = 0; i < MAX_WS_CONNECTIONS; i++) {
-        if (!ws_connections[i].connected) {
-            return i;
+    // check request type string
+    bool requestTypeOk = false;
+    for (int i = 0; i < sizeof(VALID_REQUEST_TYPES)/sizeof(VALID_REQUEST_TYPES[0]); i++) {
+        if (strcmp(type->value.data.stringVal, VALID_REQUEST_TYPES[i]) == 0) {
+            requestTypeOk = true;
+            break;
         }
     }
-    return -1;
-}
+    if (!requestTypeOk) 
+        ERROR("Invalid request type! Choices: GET, POST", "ValueError");
     
-// WebSocket Connect - returns connection ID as INT
-GroundValue ws_connect(GroundScope* scope, List args) {
-    curl_setup();
 
-    int slot = find_ws_slot();
-    if (slot == -1) {
-        ERROR("Maximum WebSocket connections reached", "OverflowError");
+    ResponseBuffer buffer = {0};
+
+    // set curl params
+    curl_easy_setopt(curlHandle, CURLOPT_URL, address->value.data.stringVal);
+    curl_easy_setopt(curlHandle, CURLOPT_WRITEFUNCTION, write_callback);
+    curl_easy_setopt(curlHandle, CURLOPT_WRITEDATA, (void*)&buffer);
+    curl_easy_setopt(curlHandle, CURLOPT_USERAGENT, userAgent->value.data.stringVal);
+    curl_easy_setopt(curlHandle, CURLOPT_VERBOSE, verbose->value.data.boolVal);
+
+    // append headers to http request
+    struct curl_slist* httpHeaderList = NULL;
+    GroundValue* httpHeaderStrings = httpHeaders->value.data.listVal.values;
+    for (int i = 0; i < httpHeaders->value.data.listVal.size; i++) {
+        httpHeaderList = curl_slist_append(httpHeaderList, httpHeaderStrings[i].data.stringVal);
+    }
+    curl_easy_setopt(curlHandle, CURLOPT_HTTPHEADER, httpHeaderList);
+
+
+    CURLcode curlStatus = curl_easy_perform(curlHandle);
+    curl_slist_free_all(httpHeaderList); // dont want em' memory leaks :P - spooopy
+
+    // check for any curl errors
+    if (curlStatus != CURLE_OK) {
+        char curlErrorMsg[255] = {0};
+
+        snprintf(curlErrorMsg, 255, "%s\n", curl_easy_strerror(curlStatus));
+        ERROR(curlErrorMsg, "CurlError");
     }
 
-    CURL* handle = curl_easy_init();
-    if (!handle) {
-        ERROR("CURL failed to init", "GenericWSError");
-    }
+    // get the http response code
+    long httpCode = 0;
+    curl_easy_getinfo(curlHandle, CURLINFO_RESPONSE_CODE, &httpCode);
 
-    curl_easy_setopt(handle, CURLOPT_URL, args.values[0].data.stringVal);
-    curl_easy_setopt(handle, CURLOPT_CONNECT_ONLY, 2L); // WebSocket mode
-    curl_easy_setopt(handle, CURLOPT_TIMEOUT, 10L);
+    // create return value and return it
+    GroundValue value = groundCreateValue(CUSTOM, &template);
 
-    CURLcode result = curl_easy_perform(handle);
+    GroundObjectField* status = groundFindField(*value.data.customVal, "statusCode");
+    status->value.data.intVal = httpCode;
 
-    if (result != CURLE_OK) {
-        char buf[256];
-        snprintf(buf, sizeof(buf) - 1, "Curl WebSocket failed: %s\n", curl_easy_strerror(result));
-        curl_easy_cleanup(handle);
-        ERROR(buf, "ActionWSError");
-    }
+    GroundObjectField* data = groundFindField(*value.data.customVal, "data");
+    data->value.data.stringVal = buffer.data;
 
-    ws_connections[slot].handle = handle;
-    ws_connections[slot].connected = true;
-    ws_connections[slot].url = strdup(args.values[0].data.stringVal);
+    value.type = CUSTOM;
 
-    return groundCreateValue(INT, (int64_t)slot);
-}
-
-// WebSocket Send - sends a text message, returns bytes sent as INT
-GroundValue ws_send(GroundScope* scope, List args) {
-    int conn_id = (int)args.values[0].data.intVal;
-    if (conn_id < 0 || conn_id >= MAX_WS_CONNECTIONS || !ws_connections[conn_id].connected) {
-        ERROR("Invalid WebSocket connection ID", "GenericWSError");
-    }
-    
-    CURL* handle = ws_connections[conn_id].handle;
-    const char* message = args.values[1].data.stringVal;
-    size_t sent;
-    
-    CURLcode result = curl_ws_send(handle, message, strlen(message), &sent, 0, CURLWS_TEXT);
-    
-    if (result != CURLE_OK) {
-        char buf[256];
-        snprintf(buf, sizeof(buf) - 1, "WebSocket send failed: %s\n", curl_easy_strerror(result));
-        ERROR(buf, "ActionWSError");
-    }
-    
-    return groundCreateValue(INT, (int64_t)sent);
-}
-
-// WebSocket Receive - receives a message (blocking)
-GroundValue ws_receive(GroundScope* scope, List args) {
-    int conn_id = (int)args.values[0].data.intVal;
-    if (conn_id < 0 || conn_id >= MAX_WS_CONNECTIONS || !ws_connections[conn_id].connected) {
-        ERROR("Invalid WebSocket connection ID", "GenericWSError");
-    }
-    
-    CURL* handle = ws_connections[conn_id].handle;
-    char buffer[4096];
-    size_t received;
-    const struct curl_ws_frame* meta;
-    
-    CURLcode result = curl_ws_recv(handle, buffer, sizeof(buffer) - 1, &received, &meta);
-    
-    if (result != CURLE_OK) {
-        if (result == CURLE_AGAIN) {
-            // No data available right now
-            return groundCreateValue(STRING, "");
-        }
-        char buf[256];
-        snprintf(buf, sizeof(buf) - 1, "WebSocket receive failed: %s\n", curl_easy_strerror(result));
-        ERROR(buf, "ActionWSError");
-    }
-    
-    buffer[received] = '\0';
-    
-    // Handle different frame types
-    if (meta->flags & CURLWS_CLOSE) {
-        printf("WebSocket close frame received\n");
-        ws_connections[conn_id].connected = false;
-        return groundCreateValue(STRING, "[CLOSED]");
-    }
-    
-    if (meta->flags & CURLWS_PING) {
-        // Automatically respond to ping with pong
-        curl_ws_send(handle, "", 0, &received, 0, CURLWS_PONG);
-        return groundCreateValue(STRING, "[PING]");
-    }
-    
-    char* data = malloc(received + 1);
-    memcpy(data, buffer, received);
-    data[received] = '\0';
-    
-    return groundCreateValue(STRING, data);
-}
-
-// WebSocket Receive with timeout (non-blocking version)
-GroundValue ws_receive_timeout(GroundScope* scope, List args) {
-    int conn_id = (int)args.values[0].data.intVal;
-    long timeout_ms = (long)args.values[1].data.intVal;
-    
-    if (conn_id < 0 || conn_id >= MAX_WS_CONNECTIONS || !ws_connections[conn_id].connected) {
-        ERROR("Invalid WebSocket connection ID", "GenericWSError");
-    }
-    
-    CURL* handle = ws_connections[conn_id].handle;
-    
-    // Set socket to non-blocking mode
-    curl_easy_setopt(handle, CURLOPT_TIMEOUT_MS, timeout_ms);
-    
-    char buffer[4096];
-    size_t received;
-    const struct curl_ws_frame* meta;
-    
-    CURLcode result = curl_ws_recv(handle, buffer, sizeof(buffer) - 1, &received, &meta);
-    
-    if (result == CURLE_AGAIN || result == CURLE_OPERATION_TIMEDOUT) {
-        return groundCreateValue(STRING, "");
-    }
-    
-    if (result != CURLE_OK) {
-        char buf[256];
-        snprintf(buf, sizeof(buf) - 1, "WebSocket receive failed: %s\n", curl_easy_strerror(result));
-        ERROR(buf, "ActionWSError");
-    }
-    
-    buffer[received] = '\0';
-    
-    if (meta->flags & CURLWS_CLOSE) {
-        ws_connections[conn_id].connected = false;
-        return groundCreateValue(STRING, "[CLOSED]");
-    }
-    
-    if (meta->flags & CURLWS_PING) {
-        curl_ws_send(handle, "", 0, &received, 0, CURLWS_PONG);
-        return groundCreateValue(STRING, "[PING]");
-    }
-    
-    char* data = malloc(received + 1);
-    memcpy(data, buffer, received);
-    data[received] = '\0';
-    
-    return groundCreateValue(STRING, data);
-}
-
-// WebSocket Close - properly close a connection, returns BOOL success
-GroundValue ws_close(GroundScope* scope, List args) {
-    int conn_id = (int)args.values[0].data.intVal;
-    if (conn_id < 0 || conn_id >= MAX_WS_CONNECTIONS || !ws_connections[conn_id].connected) {
-        ERROR("Invalid or already connected websocket", "GenericWSError");
-    }
-    
-    CURL* handle = ws_connections[conn_id].handle;
-    size_t sent;
-    
-    // Send close frame
-    curl_ws_send(handle, "", 0, &sent, 0, CURLWS_CLOSE);
-    
-    // Cleanup
-    curl_easy_cleanup(handle);
-    free(ws_connections[conn_id].url);
-    ws_connections[conn_id].handle = NULL;
-    ws_connections[conn_id].connected = false;
-    ws_connections[conn_id].url = NULL;
-    
-    return groundCreateValue(BOOL, true);
-}
-
-// WebSocket Send Binary data, returns bytes sent as INT
-GroundValue ws_send_binary(GroundScope* scope, List args) {
-    int conn_id = (int)args.values[0].data.intVal;
-    if (conn_id < 0 || conn_id >= MAX_WS_CONNECTIONS || !ws_connections[conn_id].connected) {
-        ERROR("Invalid WebSocket connection ID", "GenericWSError");
-    }
-    
-    CURL* handle = ws_connections[conn_id].handle;
-    const char* data = args.values[1].data.stringVal;
-    size_t sent;
-    
-    CURLcode result = curl_ws_send(handle, data, strlen(data), &sent, 0, CURLWS_BINARY);
-    
-    if (result != CURLE_OK) {
-        char buf[256];
-        snprintf(buf, sizeof(buf) - 1, "WebSocket binary send failed: %s\n", curl_easy_strerror(result));
-        ERROR(buf, "ActionWSError");
-    }
-    
-    return groundCreateValue(INT, (int64_t)sent);
+    return value;
 }
 
 void ground_init(GroundScope* scope) {
-    // HTTP Functions
-    groundAddNativeFunction(scope, "request_Get", get_request, STRING, 1, STRING, "url");
-    groundAddNativeFunction(scope, "request_Post", post_request, STRING, 2, STRING, "url", STRING, "data");
+    // init libcurl
+    curl_global_init(CURL_GLOBAL_ALL);
+    curlHandle = curl_easy_init();
 
-    // WebSocket Functions
-    groundAddNativeFunction(scope, "ws_Connect", ws_connect, INT, 1, STRING, "url");
-    groundAddNativeFunction(scope, "ws_Send", ws_send, INT, 2, INT, "conn_id", STRING, "message");
-    groundAddNativeFunction(scope, "ws_Receive", ws_receive, STRING, 1, INT, "conn_id");
-    groundAddNativeFunction(scope, "ws_ReceiveTimeout", ws_receive_timeout, STRING, 2, INT, "conn_id", INT, "timeout_ms");
-    groundAddNativeFunction(scope, "ws_Close", ws_close, BOOL, 1, INT, "conn_id");
-    groundAddNativeFunction(scope, "ws_SendBinary", ws_send_binary, INT, 2, INT, "conn_id", STRING, "data");
+    groundAddValueToScope(scope, "requestInitSuccess", groundCreateValue(BOOL, curlHandle != NULL));
+    if (curlHandle == NULL) {
+        return;
+    } 
+
+    // create struct
+    template = groundCreateStruct();
+    groundAddFieldToStruct(&template, "statusCode", groundCreateValue(INT, 200));
+    groundAddFieldToStruct(&template, "data", groundCreateValue(STRING, ""));
+    groundAddFieldToStruct(&template, "ok", groundCreateValue(BOOL, 1));
+
+    // create struct that users can pass to this library
+    GroundStruct requestStruct = groundCreateStruct();
+    groundAddFieldToStruct(&requestStruct, "address", groundCreateValue(STRING, ""));
+    groundAddFieldToStruct(&requestStruct, "type", groundCreateValue(STRING, "GET"));
+    groundAddFieldToStruct(&requestStruct, "userAgent", groundCreateValue(STRING, "Ground/1.0"));
+    groundAddFieldToStruct(&requestStruct, "httpHeaders", groundCreateValue(LIST, 0));
+    groundAddFieldToStruct(&requestStruct, "verbose", groundCreateValue(BOOL, 0));
+
+    groundAddValueToScope(scope, "request", groundCreateValue(STRUCTVAL, requestStruct));
+
+    // create functions
+    groundAddNativeFunction(scope, "request_Request", ground_request, CUSTOM, 1, CUSTOM, "requestInfo");
 }

src/interpreter.c

@@ -15,6 +15,8 @@ int currentInstruction = 0;
 
 bool isMainScopeGlobal = true;
 
+char* getFileContents(const char* filename);
+
 [[noreturn]] void customError(GroundArg type, GroundArg what, GroundInstruction* where, int whereLine, int exitCode) {
     printf("Ground runtime error:\n  ErrorType: ");
     printGroundArg(&type);
@@ -1896,38 +1898,35 @@ GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scop
             }
             
             if (!found) {
-                snprintf(path, sizeof(path), "./%s.grnd", libName);
+                snprintf(path, sizeof(path), "%s.grnd", libName);
                  if (access(path, F_OK) == 0) found = 1;
             }
 
             if (!found) {
                 char errorMsg[1100];
-                snprintf(errorMsg, sizeof(errorMsg), "Could not find library: %s.grnd", libName);
+                snprintf(errorMsg, sizeof(errorMsg), "Could not find library: %s", libName);
                 runtimeError(FIXME, errorMsg, in, currentInstruction);
             }
 
-            FILE* f = fopen(path, "r");
-            if (!f) {
-                runtimeError(FIXME, "Failed to open file", in, currentInstruction);
-            }
-            fseek(f, 0, SEEK_END);
-            long fsize = ftell(f);
-            fseek(f, 0, SEEK_SET);
+            char* fileContents = getFileContents(path);
 
-            char* content = malloc(fsize + 1);
-            if (!content) {
-                fclose(f);
-                runtimeError(FIXME, "Failed to allocate memory for file content", in, currentInstruction);
-            }
-            fread(content, 1, fsize, f);
-            fclose(f);
-            content[fsize] = 0;
+            GroundProgram program = parseFile(fileContents);
+            free(fileContents);
 
-            GroundProgram program = parseFile(content);
-            free(content);
+            GroundScope newScope = {
+                    .variables = scope->variables,
+            .labels = malloc(sizeof(GroundLabel*)),
+            .isMainScope = false
+            };
+
+            *newScope.labels = NULL;
+
+            int ci = currentInstruction;
+            
+            interpretGroundProgram(&program, &newScope);
+
+            currentInstruction = ci;
 
-            interpretGroundProgram(&program, scope);
-            freeGroundProgram(&program);
             break;
         }
 

src/types.c

@@ -87,11 +87,14 @@ GroundValue copyGroundValue(const GroundValue* gv) {
         case CHAR: newGv.data.charVal = gv->data.charVal; break;
         case BOOL: newGv.data.boolVal = gv->data.boolVal; break;
         case STRING:
+            /*
             if (gv->data.stringVal != NULL) {
                 newGv.data.stringVal = strdup(gv->data.stringVal);
             } else {
                 newGv.data.stringVal = NULL;
             }
+            */
+            newGv.data.stringVal = gv->data.stringVal;
             break;
         case LIST: {
             List newList = createList();
@@ -258,7 +261,8 @@ void printGroundValue(GroundValue* gv) {
 
 void freeGroundValue(GroundValue* gv) {
     if (gv->type == STRING && gv->data.stringVal != NULL) {
-        free(gv->data.stringVal);
+        // leak some memory for now
+        // free(gv->data.stringVal);
         gv->data.stringVal = NULL;
     }
     if (gv->type == LIST && gv->data.listVal.values != NULL) {