(SOC) Storage Only Commit

(ADD) Name, NameScope, Catlog, Object, String, Attribute, Char, Registry, Utils, Type, <Platform Support>, <Global Constants>, README

(MOD) Array, Var, Status, MemMan, <Common>

Var/include/var.h

@@ -2,18 +2,52 @@
 # define COMPOUND_VAR
 
 # include <stdio.h>
-# include <stdlib.h>
-# include <wchar.h>
-# include <stdint.h>
+
 # include <Compound/common.h>
+# include <Compound/status.h>
+
+# define VAR_IDENTITY_LENGTH    64
+# define VAR_LITERALISE_LENGTH  (VAR_IDENTITY_LENGTH + 16 + 9 + 10)
+# define VAR_LITERALISE_FORMAT  ("%s  @[%p]: %ld")
+# define VAR_IDENTITY_ILLEGAL_CHAR  "!@#$%^*()-=+;\'\"\\|,./<>?[]{}`~ "
+
+static Status IllegalVarIdentity = {
+  .description = "Given identity does not fit the standard of Var Naming "
+                 "convension.",
+  .characteristic = STATUS_ERROR,
+  .prev = &InvalidParameter
+};
+
+// static Status VarIdentityTooLong = {
+//   .description = "Given identity has longer length that the maximum length "
+//                  "limitation.",
+//   .characteristic = STATUS_ERROR,
+//   .prev = &IllegalVarIdentity
+// };
 
 typedef struct {
+
+  /* Data */
   void *addr;
-  size_t sz;
+  size_t size;
+  
+  /* Identification */
+  char *identity;  // Maximum up to VAR_IDENTITY_LENGTH
+  
 } Var;
 
-void var_swap(Var *v1, Var *v2);
+// typedef struct {
+//   union {
+//     /* Self Pointing (Var) */
+//     const Var *__this__;
+//   };
+// } _Var;
 
-int var_literalise(Var v, wchar_t **wbuff);
+Status Var_Create(Var *inst, void *addr, size_t size, char *identity);
+Status Var_CopyOf(Var *inst, Var *other);
+void   Var_Delete(Var *inst);
+Status VarUtils_Literalise(Var *inst, char *buff);
+void   VarUtils_Swap(Var *v1, Var *v2);
+bool   VarUtils_IsIdentityLegal(char *identity);
 
 #endif  /* COMPOUND_VAR */

Var/src/var.c

@@ -1,17 +1,94 @@
 #include <Compound/var.h>
 
-void var_swap(Var *v1, Var *v2)
+Status Var_Create(Var *inst, void *addr, size_t size, char *identity)
 {
-  Var v3 = {
-    .addr = v1->addr,
-    .sz = v1->sz
-  };
+  /* Skip when inst is unavailable. */
+  fails(inst, UnavailableInstance);
+  /* Skip when identity is unavailable. */
+  fails(identity, NullPointerAccounted);
+  /* Skip when identity does not pass the examine. */
+  state(!VarUtils_IsIdentityLegal(identity), IllegalVarIdentity);
+    
+  inst->addr = addr;
+  inst->size = size;
+  *inst->identity = *identity;
   
+  return NormalStatus;
+}
+
+Status Var_CopyOf(Var *inst, Var *other)
+{
+  /* Skip when inst or other is unavailable. */
+  fails(inst, UnavailableInstance);
+  fails(other, NullPointerAccounted);
+  
+  /* Copy and assign. */
+  inst->addr = other->addr;
+  inst->size = other->size;
+  *inst->identity = *other->identity;
+  
+  return NormalStatus;
+}
+
+void Var_Delete(Var *inst)
+{
+  /* Skip when inst or inst->addr is unavailable. */
+  svoid(inst == NULL || inst->addr == NULL);
+
+  inst->addr = NULL;
+  inst->size = 0;
+  *inst->identity = 0;
+}
+
+void VarUtils_Swap(Var *v1, Var *v2)
+{
+  /* Skip when v1 or v2 is unavailable. */
+  svoid(v1 == NULL || v2 == NULL);
+  
+  Var v3 = *v1;
   *v1 = *v2;
   *v2 = v3;
 }
 
-int var_literalise(Var v, wchar_t **wbuff)
+Status VarUtils_Literalise(Var *inst, char *buff)
 {
-  return swprintf(*wbuff, (2*8 + 6), L"@[%p] +%u", v.addr, v.sz);
+  /* Skip when inst is unavailable. */
+  state(inst == NULL, UnavailableInstance);
+  
+  /* Write into buffer. */
+  state(!sprintf(buff, VAR_LITERALISE_FORMAT, inst->identity,
+                inst->addr, inst->size),
+        error(RuntimeError, "Sprintf returned 0 where it should never do."));
+  
+  return NormalStatus;
+}
+
+bool VarUtils_IsIdentityLegal(char *identity)
+{
+  /* Skip when identity is unavailable. */
+  state(identity == NULL, false);
+  
+  const int len = strlen(identity);
+  
+  /* Skip when identity is empty. */
+  state(len == 0, false);
+
+  /* Skip when the first char is not within alphabet. */
+  state(ATRANGE('a', 'z', identity[0])
+        || ATRANGE('A', 'Z', identity[0]), false);
+  
+  /* Skip when the length of identity is greater that VAR_IDENTITY_LENGTH. */
+  state(len > VAR_IDENTITY_LENGTH, false);
+  
+  /* Skip when identity has space and illegal characters in it. */
+  const int illegal_len = strlen(VAR_IDENTITY_ILLEGAL_CHAR);
+  for (register int i = 0; i < len; i++) {
+    for (register int j = 0; j < illegal_len; j++) {
+      if (identity[i] == VAR_IDENTITY_ILLEGAL_CHAR[j]) {
+        return false;
+      }
+    }
+  }
+  
+  return true;
 }