#include <malloc.h>

#include <string.h>

#include <assert.h>

#include "sc.h"

#include "sctracker.h"

memuse_list_t *heapusage = NULL;

memuse_list_t *stackusage = NULL;

funcenum_t *firstenum = NULL;

funcenum_t *lastenum = NULL;

pstruct_t *firststruct = NULL;

pstruct_t *laststruct = NULL;

structarg_t *pstructs_getarg(pstruct_t *pstruct, const char *member)

{

	int i;

	for (i=0; i<pstruct->argcount; i++)

	{

		if (strcmp(pstruct->args[i]->name, member) == 0)

		{

			return pstruct->args[i];

		}

	}

	return NULL;

}

pstruct_t *pstructs_add(const char *name)

{

	pstruct_t *p = (pstruct_t *)malloc(sizeof(pstruct_t));

	memset(p, 0, sizeof(pstruct_t));

	strcpy(p->name, name);

	if (!firststruct)

	{

		firststruct = p;

		laststruct = p;

	} else {

		laststruct->next = p;

		laststruct = p;

	}

	return p;

}

void pstructs_free()

{

	pstruct_t *p, *next;

	p = firststruct;

	while (p)

	{

		while (p->argcount--)

		{

			free(p->args[p->argcount]);

		}

		free(p->args);

		next = p->next;

		free(p);

		p = next;

	}

	firststruct = NULL;

	laststruct = NULL;

}

pstruct_t *pstructs_find(const char *name)

{

	pstruct_t *p = firststruct;

	while (p)

	{

		if (strcmp(p->name, name) == 0)

		{

			return p;

		}

		p = p->next;

	}

	return NULL;

}

structarg_t *pstructs_addarg(pstruct_t *pstruct, const structarg_t *arg)

{

	structarg_t *newarg;

	int i;

	for (i=0; i<pstruct->argcount; i++)

	{

		if (strcmp(pstruct->args[i]->name, arg->name) == 0)

		{

			/* Don't allow dup names */

			return NULL;

		}

	}

	newarg = (structarg_t *)malloc(sizeof(structarg_t));

	memcpy(newarg, arg, sizeof(structarg_t));

	if (pstruct->argcount == 0)

	{

		pstruct->args = (structarg_t **)malloc(sizeof(structarg_t *) * 1);

	} else {

		pstruct->args = (structarg_t **)realloc(

							pstruct->args,

							sizeof(structarg_t *) * (pstruct->argcount + 1));

	}

	newarg->offs = pstruct->argcount * sizeof(cell);

	newarg->index = pstruct->argcount;

	pstruct->args[pstruct->argcount++] = newarg;

	return newarg;

}

void funcenums_free()

{

	funcenum_t *e, *next;

	e = firstenum;

	while (e)

	{

		functag_t *tag, *nexttag;

		tag = e->first;

		while (tag)

		{

			nexttag = tag->next;

			free(tag);

			tag = nexttag;

		}

		next = e->next;

		free(e);

		e = next;

	}

	firstenum = NULL;

	lastenum = NULL;

}

funcenum_t *funcenums_find_byval(int value)

{

	funcenum_t *e = firstenum;

	while (e)

	{

		if (e->value == value)

		{

			return e;

		}

		e = e->next;

	}

	return NULL;

}

funcenum_t *funcenums_add(const char *name)

{

	funcenum_t *e = (funcenum_t *)malloc(sizeof(funcenum_t));

	memset(e, 0, sizeof(funcenum_t));

	if (firstenum == NULL)

	{

		firstenum = e;

		lastenum = e;

	} else {

		lastenum->next = e;

		lastenum = e;

	}

	strcpy(e->name, name);

	e->value = pc_addfunctag((char *)name);

	return e;

}

functag_t *functags_add(funcenum_t *en, functag_t *src)

{

	functag_t *t = (functag_t *)malloc(sizeof(functag_t));

	memcpy(t, src, sizeof(functag_t));

	t->next = NULL;

	if (en->first == NULL)

	{

		en->first = t;

		en->last = t;

	} else {

		en->last->next = t;

		en->last = t;

	}

	return t;

}

/**

 * Creates a new mem usage tracker entry

 */

void _push_memlist(memuse_list_t **head)

{

  memuse_list_t *newlist = (memuse_list_t *)malloc(sizeof(memuse_list_t));

  if (*head != NULL)

  {

    newlist->list_id = (*head)->list_id + 1;

  } else {

    newlist->list_id = 0;

  }

  newlist->prev = *head;

  newlist->head = NULL;

  *head = newlist;

}

/**

 * Pops a heap list but does not free it.

 */

memuse_list_t *_pop_save_memlist(memuse_list_t **head)

{

  memuse_list_t *oldlist = *head;

  *head = (*head)->prev;

  return oldlist;

}

/**

 * Marks a memory usage on a memory list

 */

int _mark_memlist(memuse_list_t *head, int type, int size)

{

  memuse_t *use;

  if (type==MEMUSE_STATIC && size==0)

  {

    return 0;

  }

  use=head->head;

  if (use && (type==MEMUSE_STATIC) 

      && (use->type == type))

  {

    use->size += size;

  } else {

    use=(memuse_t *)malloc(sizeof(memuse_t));

    use->type=type;

    use->size=size;

    use->prev=head->head;

    head->head=use;

  }

  return size;

}

void _reset_memlist(memuse_list_t **head)

{

  memuse_list_t *curlist = *head;

  memuse_list_t *tmplist;

  while (curlist) {

    memuse_t *curuse = curlist->head;

    memuse_t *tmpuse;

    while (curuse) {

      tmpuse = curuse->prev;

      free(curuse);

      curuse = tmpuse;

    }

    tmplist = curlist->prev;

    free(curlist);

    curlist = tmplist;

  }

  *head = NULL;

}

/**

 * Wrapper for pushing the heap list

 */

void pushheaplist()

{

  _push_memlist(&heapusage);

}

/**

 * Wrapper for popping and saving the heap list

 */

memuse_list_t *popsaveheaplist()

{

  return _pop_save_memlist(&heapusage);

}

/**

 * Wrapper for marking the heap

 */

int markheap(int type, int size)

{

  return _mark_memlist(heapusage, type, size);

}

/**

 * Wrapper for pushing the stack list

 */

void pushstacklist()

{

  _push_memlist(&stackusage);

}

/**

 * Wrapper for marking the stack

 */

int markstack(int type, int size)

{

  return _mark_memlist(stackusage, type, size);

}

/**

 * Generates code to free all heap allocations on a tracker

 */

void _heap_freeusage(memuse_list_t *heap, int dofree)

{

  memuse_t *cur=heap->head;

  memuse_t *tmp;

  while (cur)

  {

    if (cur->type == MEMUSE_STATIC)

	{

      modheap((-1)*cur->size*sizeof(cell));

    } else {

      modheap_i();

    }

    if (dofree)

    {

      tmp=cur->prev;

      free(cur);

      cur=tmp;

    } else {

      cur=cur->prev;

    }

  }

  if (dofree)

  {

    heap->head=NULL;

  }

}

void _stack_genusage(memuse_list_t *stack, int dofree)

{

  memuse_t *cur = stack->head;

  memuse_t *tmp;

  while (cur)

  {

    if (cur->type == MEMUSE_DYNAMIC)

	{

      /* no idea yet */

      assert(0);

	} else {

      modstk(cur->size * sizeof(cell));

	}

	if (dofree)

	{

      tmp = cur->prev;

      free(cur);

      cur = tmp;

	} else {

      cur = cur->prev;

	}

  }

  if (dofree)

  {

    stack->head = NULL;

  }

}

/**

 * Pops a heap list and frees it.

 */

void popheaplist()

{

  memuse_list_t *oldlist;

  assert(heapusage!=NULL);

  _heap_freeusage(heapusage, 1);

  assert(heapusage->head==NULL);

  oldlist=heapusage->prev;

  free(heapusage);

  heapusage=oldlist;

}

void genstackfree(int stop_id)

{

  memuse_list_t *curlist = stackusage;

  while (curlist && curlist->list_id > stop_id)

  {

    _stack_genusage(curlist, 0);

    curlist = curlist->prev;

  }

}

void genheapfree(int stop_id)

{

  memuse_list_t *curlist = heapusage;

  while (curlist && curlist->list_id > stop_id)

  {

    _heap_freeusage(curlist, 0);

    curlist = curlist->prev;

  }

}

void popstacklist(int codegen)

{

  memuse_list_t *oldlist;

  assert(stackusage != NULL);

  if (codegen)

  {

    _stack_genusage(stackusage, 1);

    assert(stackusage->head==NULL);

  }

  oldlist = stackusage->prev;

  free(stackusage);

  stackusage = oldlist;

}

void resetstacklist()

{

  _reset_memlist(&stackusage);

}

void resetheaplist()

{

  _reset_memlist(&heapusage);

}