M src/conver.c → src/conver.c

@@ -168,6 +168,39 @@ {
     return version & 0x0F;
 }
 
+conver_stage_t stage(uint16_t version)
+{
+    uint16_t vscore = score(version);
+    if (vscore >= 0x001 && vscore <= 0x400) { return CONVER_STAGE_PROTOTYPE; }
+    if (vscore >= 0x401 && vscore <= 0x800) { return CONVER_STAGE_OPERATIONAL; }
+    if (vscore >= 0x801 && vscore <= 0xC00) { return CONVER_STAGE_CONSOLIDATED; }
+    return CONVER_STAGE_BEDROCK; 
+}
+
+conver_size_t size(uint16_t version)
+{
+    uint16_t meta = metadata(version);
+    if (meta >= 0xC) { return CONVER_SIZE_X; }
+    if (meta >= 0x8) { return CONVER_SIZE_L; }
+    if (meta >= 0x4) { return CONVER_SIZE_M; }
+    return CONVER_SIZE_S;
+}
+
+conver_compatibility_t compatibility(uint16_t version)
+{
+    uint16_t meta = metadata(version);
+    if (meta == 0x0 || meta == 0x1 || meta == 0x4 || meta == 0x5 ||
+        meta == 0x8 || meta == 0x9 || meta == 0xC || meta == 0xD) { return CONVER_COMPAT_PRES; }
+    return CONVER_COMPAT_BREAK;
+}
+
+conver_purpose_t purpose(uint16_t version)
+{
+    uint16_t meta = metadata(version);
+    return (meta % 2) ? CONVER_PURPOSE_ENHANCE : CONVER_PURPOSE_MAINT;
+}
+
+
 char *date(const struct tm d, char *dest, size_t dest_size)
 {
     snprintf(dest, dest_size, "%04d-%02d-%02d", d.tm_year + 1900, d.tm_mon + 1, d.tm_mday);
@@ -222,6 +255,12 @@ printf("-- %s: v%03X-%1X\n", date(r->date, date_str, sizeof(date_str)),  r->score, r->metadata);
     printf("   %s\n", r->comment);
 }
 
+void print_version(uint16_t version)
+{
+    printf("   v%03X-%1X (Stage: %s)\n", score(version), metadata(version), conver_stages[stage(version)]);
+    printf("   Size: %s - Compatibility: %s - Purpose: %s\n", conver_sizes[size(version)], conver_compatibilities[compatibility(version)], conver_purposes[purpose(version)]);
+}
+
 int parse_history() {
     char *contents;
     size_t contents_len = 0;
@@ -263,7 +302,6 @@ if (mktime(&history[count].date) > timestamp) {
                 fprintf(stderr, "%s - Line %d: ", CONVER_HISTORY_FILE, count+1);
                 return print_result(CONVER_ERR_FUTURE_DATE);
             }
-            print_release(&history[count]);
             count++;
             history_size = count;
         }
@@ -453,7 +491,7 @@ return print_result(CONVER_ERR_NO_DRAFT);
     }
     uint16_t draft = strtoul(draft_string, NULL, 16);
     if (!draft) {
-        return print_result(CONVER_ERR_NO_DRAFT);
+        return print_result(CONVER_ERR_INVALID_DRAFT);
     }
     time_t timestamp = time(NULL);
     struct tm *local_time = localtime(&timestamp);
@@ -492,6 +530,51 @@ memset(release, 0, sizeof(release));
     return 0;
 }
 
+int command_status()
+{
+    uint16_t draft = 0;
+    uint16_t release = 0;
+    char *draft_string;
+    char *release_string;
+    size_t draft_len = 0;
+    size_t release_len = 0;
+    int result = fs_read(CONVER_DRAFT_FILE, &draft_string, &draft_len);
+    if (result != CONVER_OK) {
+        return print_result(result);
+    } 
+    if (strlen(draft_string) == 4) {
+        draft = strtoul(draft_string, NULL, 16);
+        if (!draft) {
+            return print_result(CONVER_ERR_INVALID_DRAFT);
+        }
+    }
+    result = fs_read(CONVER_RELEASE_FILE, &release_string, &release_len);
+    if (result != CONVER_OK) {
+        return print_result(result);
+    } 
+    if (strlen(release_string) == 4) {
+        release = strtoul(release_string, NULL, 16);
+        if (!release) {
+            return print_result(CONVER_ERR_INVALID_RELEASE);
+        }
+    }
+    if (!release && !draft)
+    {
+        printf("No current release available.\n");
+        printf("No draft release available.\n");
+    }
+    if (release) {
+        printf("Current Release:\n");
+        print_version(release);
+    }
+    if (draft) {
+        printf("Draft Release:\n");
+        print_version(draft);
+    }
+    return CONVER_OK;
+}
+ 
+
 //// Main
 
 int main(int argc, char *argv[])
@@ -517,6 +600,10 @@ }
             if ((strcmp(arg, "release") == 0))
             {
                 return command_release();
+            }
+            if ((strcmp(arg, "status") == 0))
+            {
+                return command_status();
             }
         }
     }

M src/conver.h → src/conver.h

@@ -18,7 +18,7 @@ #include <ctype.h>
 #include <time.h>
 #include <stdbool.h>
 
-typedef enum {
+typedef enum conver_result_t {
     CONVER_OK                   = 0,
     CONVER_ERR_OPEN             = 1,  
     CONVER_ERR_WRITE            = 2,  
@@ -28,14 +28,15 @@ CONVER_ERR_STAT             = 5,
     CONVER_ERR_MKDIR            = 6,
     CONVER_ERR_INVALID_VALUE    = 7,
     CONVER_ERR_NO_DRAFT         = 8,
-    CONVER_ERR_INVALID_RELEASE  = 9,
-    CONVER_ERR_INVALID_DATE     = 10,
-    CONVER_ERR_PAST_DATE        = 11,
-    CONVER_ERR_FUTURE_DATE      = 12,
-    CONVER_ERR_LOW_SCORE        = 13,
+    CONVER_ERR_INVALID_DRAFT    = 9,
+    CONVER_ERR_INVALID_RELEASE  = 10,
+    CONVER_ERR_INVALID_DATE     = 11,
+    CONVER_ERR_PAST_DATE        = 12,
+    CONVER_ERR_FUTURE_DATE      = 13,
+    CONVER_ERR_LOW_SCORE        = 14,
 } conver_result_t;
 
-char *conver_errors[14] = {
+char *conver_errors[15] = {
     "Success",
     "Unable to open file.",
     "Unable to write file", 
@@ -44,12 +45,65 @@ "Unable to allocate memory for file",
     "Unable to get file/directory information",
     "Unable to create directory",
     "Invalid value",
-    "No draft version configured. Please run: conver draft",
+    "No draft version configured. Please run conver draft",
+    "Invalid draft version. Please re-run conver draft to fix."
     "Invalid release",
     "Invalid date",
     "Date is in the past",
     "Date is in the future",
     "Specified score is too low",
+};
+
+typedef enum conver_stage_t
+{
+    CONVER_STAGE_PROTOTYPE      = 0,
+    CONVER_STAGE_OPERATIONAL    = 1,
+    CONVER_STAGE_CONSOLIDATED   = 2,
+    CONVER_STAGE_BEDROCK        = 3,
+} conver_stage_t;
+
+char *conver_stages[4] = {
+    "Prototype",
+    "Operational",
+    "Consolidated",
+    "Bedrock",
+};
+
+typedef enum conver_size_t 
+{
+    CONVER_SIZE_S       = 0,
+    CONVER_SIZE_M       = 1,
+    CONVER_SIZE_L       = 2,
+    CONVER_SIZE_X       = 3,
+} conver_size_t;
+
+char *conver_sizes[4] = {
+    "Small",
+    "Medium",
+    "Large",
+    "Extra Large",
+};
+
+typedef enum conver_compatibility_t
+{
+    CONVER_COMPAT_PRES  = 0,
+    CONVER_COMPAT_BREAK = 1,
+} conver_compatibility_t;
+
+char *conver_compatibilities[2] = {
+    "Preserving",
+    "Breaking",
+};
+
+typedef enum conver_purpose_t
+{
+    CONVER_PURPOSE_MAINT    = 0,
+    CONVER_PURPOSE_ENHANCE  = 1,
+} conver_purpose_t;
+
+char *conver_purposes[2] = {
+    "Maintenance",
+    "Enhancement",
 };
 
 typedef struct {