libsheepyCUndefined.c

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2023 Remy Noulin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

#include "../libsheepyObject.h"
#include "libsheepyCUndefined.h"
#include "libsheepyCUndefinedInternal.h"

#define internal static

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

void initiateUndefined(undefinedt *self);
void initiateAllocateUndefined(undefinedt **self);
void finalizeRecycleUndefined(void *arg UNUSED);
void finalizeUndefined(void);
undefinedt* allocUndefined(void);
void cleanUpUndefinedTerminateG(undefinedt **val);
void cleanUpUndefinedFreeLocalG(undefinedt *val);
void cleanUpUndefinedFreeG(undefinedt **val);
void cleanUpUndefinedFinishG(undefinedt **val);
void cleanUpUndefinedSmashG(undefinedt **val);
internal void freeUndefined(undefinedt *self UNUSED);
internal void terminateUndefined(undefinedt **self);
internal char* toStringUndefined(undefinedt *self UNUSED);
internal undefinedt* duplicateUndefined(undefinedt *self UNUSED);
#if (NFreeStackCheck)
internal void finishUndefined(undefinedt **self);
#else
internal void finishUndefined(undefinedt **self);
#endif
undefinedt* duplicateUndefinedG (undefinedt *self);

void initiateUndefined(undefinedt *self) {

  self->type = "undefined";
  if (!undefinedF) {
    isError(undefinedF, malloc(sizeof(undefinedFunctionst))) {
      self->f = NULL;
      return;
    }
    undefinedF->free      = freeUndefined;
    undefinedF->terminate = terminateUndefined;
    undefinedF->toString  = toStringUndefined;
    undefinedF->duplicate = duplicateUndefined;
    undefinedF->smash     = terminateUndefined;
    undefinedF->finish    = finishUndefined;
  }
  self->f = undefinedF;
}

void initiateAllocateUndefined(undefinedt **self) {

  if (self) {
    #if (recycleContainers)
    initAllocateRecycle(undefinedt);
    #else
    isError(*self, malloc(sizeof(undefinedt)))
      return;
    #endif
    if (*self) {
      initiateUndefined(*self);
      if (!(*self)->f) {
        finishUndefined(self);
}
  }
    }
      }

void finalizeRecycleUndefined(void *arg UNUSED) {

  #if (recycleContainers)
  finalizeRecycle
  #endif
  // recycleContainers
}

void finalizeUndefined(void) {

  if (undefinedF) {
    free(undefinedF);
    undefinedF = NULL;
  }
  finalizeRecycleUndefined(NULL);
}

undefinedt* allocUndefined(void) {
  undefinedt *r = NULL;

  initiateAllocateUndefined(&r);
  if (!r) {
    return(NULL);
  }
  return(r);
}

void cleanUpUndefinedTerminateG(undefinedt **val) {

  terminateO(*val);
}

void cleanUpUndefinedFreeLocalG(undefinedt *val) {

  freeO(val);
}

void cleanUpUndefinedFreeG(undefinedt **val) {

  freeO(*val);
}

void cleanUpUndefinedFinishG(undefinedt **val) {

  finishO(*val);
}

void cleanUpUndefinedSmashG(undefinedt **val) {

  smashO(*val);
}

internal void freeUndefined(undefinedt *self UNUSED) {

  return;
}

internal void terminateUndefined(undefinedt **self) {

  finishUndefined(self);
}


internal char* toStringUndefined(undefinedt *self UNUSED) {

  return(strdup("null"));
}

internal undefinedt* duplicateUndefined(undefinedt *self UNUSED) {

  createAllocateUndefined(dup);
  if (!dup) {
    return(NULL);
  }
  return(dup);
}

#if (NFreeStackCheck)
internal void finishUndefined(undefinedt **self) {

  register u64 rsp asm("rsp");
  if ((u64)*self > rsp) {
    logW("Probably trying to free a undefined on stack: "BLD PRIx64 RST" sp: "BLD PRIx64 RST, *self, rsp);
    logBtrace;
  }
  else {
    #if (recycleContainers)
    finishRecycle
    #else
    free(*self);
    #endif
    // recycleContainers
    *self = NULL;
}
  }

#else
// #if NFreeStackCheck
internal void finishUndefined(undefinedt **self) {

  #if (recycleContainers)
  finishRecycle
  #else
  free(*self);
  #endif
  // recycleContainers
  *self = NULL;
}

#endif
// #if NFreeStackCheck

undefinedt* duplicateUndefinedG (undefinedt *self) {

  return(self->f->duplicate(self));
}

void        freeUndefinedG      (undefinedt *self) {self->f->free(self);}