fpa1_BlockAlloc.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 * Copyright © 2000 Koninklijke Philips Electronics N.V
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 * 
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 * 
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>

#include "vpa1_sys.h"
#include "vpa1_tgs.h"
#include "fpa1_syn.h"
#include "pa1_mem.h"
#include "mh5debug.h"
#include "fpa1_BlockAlloc.h"

/*---constant definitions for this file--------------------------------------*/
/* Number of syntaxListItems in each memory block */
#define ASN_MEM_BLOCK 0x100

/*---local typedef structs for this file-------------------------------------*/
struct fpa1_synBlock
{
   struct fpa1_synBlock *next;
   unsigned short count;
   unsigned short check;
   fpa1_syntaxList items[ASN_MEM_BLOCK];
};
typedef struct fpa1_synBlock fpa1_syntaxBlock;


/*---local (static) variable declarations for this file----------------------*/
static fpa1_syntaxBlock *current_blk = NULL;
static fpa1_syntaxBlock *first_block = NULL;

/*---local function definitions----------------------------------------------*/

/*---global function definitions---------------------------------------------*/

fpa1_syntaxList* fpa1_getTagItem(void)
{
   fpa1_syntaxList *newItem;

   if (current_blk->count == ASN_MEM_BLOCK)
   {
      if (current_blk->next == NULL)
      {
         fpa1_syntaxBlock *new_block;
         new_block = (fpa1_syntaxBlock *) pa1_malloc( sizeof(fpa1_syntaxBlock));
         if (new_block != NULL)
         {
            memset( new_block, 0, sizeof(fpa1_syntaxBlock));
            current_blk->next = new_block;
            TRACE(TMEMORY, ("new_blk=%p", new_block))
         }
         else
         {
            return NULL;
         }
      }
      current_blk = current_blk->next;
   }

   /* get next structure from the list */
   newItem = &(current_blk->items[current_blk->count]);
   current_blk->count++;

   newItem->data.intData = 0;
   newItem->dataType = 0;

   return newItem;
}

int fpa1_freeUnusedData(void)
{
   fpa1_syntaxBlock *temp_block;
   int i;
   temp_block = first_block;
   /* free strings on previous blocks */
   while (temp_block != current_blk)
   {
      TRACE(TMEMORY, ("temp_blk=%p, cnt=%d, chk=%d", temp_block, temp_block->count, temp_block->check))
      for (i = 0; i != ASN_MEM_BLOCK; i++)
      {
         if (temp_block->items[i].data.stringData.data != NULL)
         {
            STR_DataFree( temp_block->items[i].data.stringData.data,
               temp_block->items[i].data.stringData.len );
            temp_block->items[i].data.stringData.data = NULL;
            temp_block->items[i].data.stringData.len = 0;
         }
      }
      temp_block->count = 0;
      temp_block->check = 0;
      temp_block = temp_block->next;
   }
   /* free strings on current block */
   for (i = 0; i != temp_block->count; i++)
   {
      if (temp_block->items[i].data.stringData.data != NULL)
      {
         STR_DataFree( temp_block->items[i].data.stringData.data,
            temp_block->items[i].data.stringData.len );
         temp_block->items[i].data.stringData.data = NULL;
         temp_block->items[i].data.stringData.len = 0;
      }
   }
   TRACE(TMEMORY, ("temp_blk=%p, cnt=%d, chk=%d", temp_block, temp_block->count, temp_block->check))
   temp_block->count = 0;
   temp_block->check = 0;
   current_blk = temp_block;
   temp_block = temp_block->next;
   while (temp_block != NULL)
   {
      if (temp_block->check != 8)
      {
         TRACE(TMEMORY, ("temp_blk=%p chk=%d", temp_block, temp_block->check))
         temp_block->check++;
         current_blk = temp_block;
         temp_block = temp_block->next;
      }
      else
      {
         TRACE(TMEMORY, ("free blk=%p", temp_block))
         if (current_blk->next == temp_block)
         {
            current_blk->next = NULL;
         }
         current_blk = temp_block->next;
         pa1_free(temp_block);
         temp_block = current_blk;
      }
   }
   current_blk = first_block;
   return 0;
}

fpa1_syntaxList* fpa1_delFirstItem(fpa1_syntaxList *firstComp)
{
   fpa1_syntaxList *nextComp = firstComp;

   if (nextComp != NULL)
   {
      /* are there any children */
      if (firstComp->children != NULL)
      {
         fpa1_delList(firstComp->children);
         firstComp->children = NULL;
      }

      /* get next item in list - for return */
      nextComp = nextComp->next;

      //TRACE(TMEMORY,("Free %p posn %d tag %d", firstComp, firstComp->tagPosition, firstComp->tag ))

      /* clean up structure pointers */
      firstComp->next = NULL;
   }
   return nextComp;
}

int fpa1_delList(fpa1_syntaxList *firstComp)
{
   while (firstComp != NULL)
   {
      firstComp = fpa1_synFreeFirstItem( firstComp );
   }

   return 0;
}

int  ASN1_MemInit(void)
{
   assert( first_block == NULL );
   first_block = (fpa1_syntaxBlock *) pa1_malloc( sizeof(fpa1_syntaxBlock));
   if (first_block != NULL)
   {
      memset( first_block, 0, sizeof(fpa1_syntaxBlock));
   }
   current_blk = first_block;
   TRACE(TMEMORY, ("first_blk=%p", first_block))
   return (first_block == NULL) ? 0 : 1;
}

void ASN1_MemExit(void)
{
   fpa1_syntaxBlock *temp_block;
   temp_block = first_block;
   while (temp_block != NULL)
   {
      current_blk = temp_block->next;
      pa1_free(temp_block);
      temp_block = current_blk;
   }
   first_block = NULL;
}