/*

  Copyright 2009 by James Dean Palmer and others.

  Please report all bugs and problems to "bugs@ging3r.org".

*/

#ifndef GINGER_H

#define GINGER_H

//#define GC_DEBUG

/// Section 0: Includes

/// This is the primary reference used internally by Ginger.  It can hold

/// immediate (chars, fixed ints, symbols, etc.) and non-immediates (a pointer

/// etc.)

#define GIN_OBJ void*

} Frame_Narg;

typedef struct {

  GIN_OBJ type_index;

  GIN_OBJ left;

  GIN_OBJ right;

} GingerDictionaryCell;

typedef struct {

  GIN_OBJ type_index;

  GIN_OBJ root;

} GingerDictionary;

  GIN_OBJ unmake;

} GingerClassDefinition;

/// for them.

typedef struct {

/// This is the primary object type.

typedef struct {

  GIN_OBJ type_index;

  union {

    void*  f0;

  };

  union {

    void* f1;

  };

  union {

    void* f2;

    long  str_length;

  };

} GingerObject;

typedef struct {

  GIN_OBJ type_index;

  double value;

} GingerFlonum;

typedef struct {

  GIN_OBJ type_index;

  long value;

} GingerInteger;

typedef struct {

  GIN_OBJ type_index;

  unsigned long length;

  unsigned long value[];

} GingerBinary;

typedef struct {

  GIN_OBJ type_index;

  long length;

  GIN_OBJ *value;

} GingerVector;

typedef struct {

  GIN_OBJ type_index;

  GIN_OBJ index;  // Always NIM

  //  GIN_OBJ make;

  //  GIN_OBJ unmake;

  GIN_OBJ(*c_make) ();

  void(*c_unmake) (GIN_OBJ);

} GingerType;

typedef struct {

  short num_bytes;

  short visited;

} GCFastAllocHeader;

typedef struct GCSysAllocHeader_t {

  short num_bytes;

  short visited;

  short requires_cleanup;

  struct GCSysAllocHeader_t* next;

} GCSysAllocHeader;

typedef struct GarbageCollector_t {

  // not set until collection starts

  int   alpha_remaining_bytes;

  void (*collection_callback)(struct GarbageCollector_t* data);

  // their cleanup method called.

  GCSysAllocHeader* pending_cleanup;

  // during collections and are only freed at the end of the program.

  GCSysAllocHeader* persistent_list;

/// Section 2: Macro definitions

///

#define GIN_GC_INIT mm = gc_new(1024*1024*GIN_GC_MB); gc_set_collection_callback(mm, collect);

#define GIN_ALLOCATE(v, type, size) safe_allocate = (GIN_OBJ)gc_allocate(mm, size); \

v = (type)safe_allocate;

#define GIN_ALLOCATE_WITH_CLEANUP(v, type, size) safe_allocate = (GIN_OBJ)gc_allocate_system(mm, size); \

v = (type)safe_allocate; \

gc_mark_as_requiring_cleanup(mm, v);

/// CALL_ALLOCATE.  Then you copy any parameters.  Then use CALL.

#define CALL_ALLOCATE(function) \

position_ ## seed : \

  result0 = frame->next_frame->result; \

  frame->next_frame->previous_frame = 0; \

  ENDDEBUG \

  ALLOCATE_FRAME___ ## function (frame->next_frame) \

  frame->next_frame->previous_lexical_frame = previous_lframe; \

  frame->next_frame->previous_frame = frame; \

position_ ## seed : \

  result0 = frame->next_frame->result; \

  frame->next_frame->previous_frame = 0; \

// 1. if it's not a function and has no args, return the value.

// 2. if it's not a function and has args - we need to determine the method to call. then do 3.

// 3. if it is a function, use the signature to properly order the arguments and make the call.

  if ((varn == GIN_NULL) && !(GIN_IS_FUNCTION(function))) result0 = function; \

  else { \

  if (!GIN_IS_FUNCTION(function)) { \

position_ ## seed : \

  result0 = frame->next_frame->result; \

  frame->next_frame->previous_frame = 0; \

  frame->next_frame = 0; \

}

#define GLOBALS int next_seed = 5000; \

GIN_OBJ calln_temp; \

GarbageCollector* mm; \

int gin_argc; \

char **gin_argv; \

int gin_debug_max_depth = -1; \

int debug_depth = 0; \

int debug_depth_iterator = 0; \

#define END_CODE end_code_return: return frame->result;  \

} \

  gin_argc = argc; \

  gin_argv = argv; \

  GIN_GC_INIT; \

  frame = 0; \

  frame->result = 0; \

  frame->next_frame = 0;  \

  ginExec(0, GIN_NULL); \

  GIN_OBJ main_fn; \

  ginExec(main_fn, GIN_NULL); \

  return 0; \

}

#define END_FUNCTION() frame = frame->previous_frame; \

  goto *(frame->next_frame->return_address);

// pointers (non-immediates) and certain useful primitives

// (immediates).  The following describes how the bit string

// works:

#define GIN_TYPE_BOOL GIN_IM_FROM_INT(13)

#define GIN_TYPE_NULL GIN_IM_FROM_INT(14)

#define GIN_TYPE_CHAR GIN_IM_FROM_INT(15)

/*

#define GIN_TYPE_STR8 1

 v = safe_pair;

#define GIN_NEW_FIXNUM(v,a) v=GIN_IM_FROM_INT(a);

/* #define GIN_NEW_INTEGER_FROM_INT(v, a) GIN_ALLOCATE_WITH_CLEANUP(v, GingerInteger*, sizeof(GingerInteger)); \ */

/* mpz_init_set_si(((GingerInteger*)v)->value, a); */

/* #define GIN_NEW_INTEGER_FROM_STR(v, a) GIN_ALLOCATE_WITH_CLEANUP(v, GingerInteger*, sizeof(GingerInteger)); \ */

/* mpz_init ((((GingerInteger*)v)->value));  */

/* mpz_init_set_str((((GingerInteger*)v)->value), a, 10); */

#define GIN_NEW_FN(v,a,frame) GIN_ALLOCATE(v, void*, sizeof(GingerObject)); \

#define GIN_NEW_EMPTY_STR8(v) GIN_ALLOCATE(v, void*, sizeof(GingerObject)); \

((GingerObject*)v)->type_index = GIN_TYPE_STR8; \

((GingerObject*)v)->str_length = 0;

((GingerObject*)v)->type_index = GIN_TYPE_STR16; \

((GingerObject*)v)->str16_value = a;

#define GIN_NEW_SYM(v,a) v=GIN_IM_FROM_SYM(a);

#define GIN_NEW_LABEL(v,a) v=GIN_IM_FROM_LABEL(a);

#define GIN_NEW_BOOL(v,a) v=GIN_IM_FROM_BOOL(a);

#define GIN_NEW_OBJ(v,a) v=a;

((GingerFlonum*)v)->type_index = GIN_TYPE_FLONUM; \

((GingerFlonum*)v)->value = a;

#define GIN_NEW_NIM(v) GIN_ALLOCATE(v, void*, sizeof(GingerObject));

((GingerObject*)v)->type_index = GIN_TYPE_STRING_STREAM; \

GIN_NIM_SET_STRING_STREAM_LENGTH(v,strlen(s)); \

GIN_NIM_SET_STRING_STREAM_POSITION(v,0);                        \

memcpy(((GingerObject*)v)->str8_value, s, strlen(s)+1);

#define GIN_NEW_EMPTY_STRING_STREAM(v,m) GIN_ALLOCATE(v, void*, sizeof(GingerObject)); \

((GingerObject*)v)->type_index = GIN_TYPE_STRING_STREAM; \

GIN_NIM_SET_STRING_STREAM_LENGTH(v,0); \

GIN_NIM_SET_STRING_STREAM_POSITION(v,0);              \

((GingerObject*)v)->str8_value[0] = 0;

// GC_DEFAULT_FAST_PAGE_SIZE

//

// 5 MB default fast memory page size.  Two of these will be

// frequent data collections with no other impact besides

// the use of the memory itself.  Smaller allocations are certainly

// viable when memory is tight.

// GC_FAST_HEAP_THRESHOLD

//

// This is also the size limit of how many bytes may need to be

// copied over per single long-lived object.  Larger sizes will

// are usually short-lived.  If they're more often long-lived,

// the program will run slower due to frequent recopying.

// fast_heap_page_size - the heap threshold vs the page size

// should be a fraction of (a guess here:) 1/100 or smaller.

#if !defined(GC_FAST_HEAP_THRESHOLD)

extern void gc_mark_as_requiring_cleanup(GarbageCollector *mm, void *m);

extern void* gc_get_next_pending_cleanup(GarbageCollector *mm);

extern void gc_analyze(GarbageCollector* mm, void* addr);

extern GIN_OBJ ginExec (GIN_OBJ fn, GIN_OBJ args);

extern void GIN_display(GIN_OBJ x, GIN_OBJ out, int was_not_cdr);

extern GIN_OBJ gin_getenv(GIN_OBJ name, GIN_OBJ default_value);

extern GIN_OBJ gin_file_exists(GIN_OBJ filename);

/// Section 4: Global variables

///