fpa1_syn.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_tgs.h"
#include "vpa1_rdf.h"

#include "fpa1_rdf.h"
#include "fpa1_syn.h"
#include "fpa1_tgs.h"

#include "pa1_mem.h"

#include "fpa1_BlockAlloc.h"

/*---local typedef structs for this file-------------------------------------*/

/*---constant definitions for this file--------------------------------------*/


/*---local (static) variable declarations for this file----------------------*/

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

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

fpa1_syntaxList* fpa1_synGetAllTags( vpa1_filePos filePosLimit )
{
   int tag;
   vpa1_filePos curFilePosition, nextTagPosition;
   fpa1_syntaxList *tempPtr;

   fpa1_syntaxList *compListPtr = NULL;

   tag = 1;

   /* save current file position */
   curFilePosition = fpa1_rdfGetCurrentFilePosition();

   while ((tag > 0) && (curFilePosition < filePosLimit))
   {
      /* Go through all tags until there are no more */
      tag = fpa1_rdfGetTag();
      nextTagPosition = fpa1_rdfGetNextTagPosn();

      /* run of unknown components has been broken */
      tempPtr = fpa1_synCreateListItem( tag, curFilePosition, nextTagPosition );

      if (tempPtr != NULL)
      {
         /* get primative data */
         if (tempPtr->tag < CONT_SPEC_TAGS)
         {
            fpa1_parseData(tempPtr);
         }

         compListPtr = fpa1_synAddItemToList( compListPtr, tempPtr);
      }

      /* set up current file position variable */
      curFilePosition = nextTagPosition;
      fpa1_rdfSetNewFilePosition( curFilePosition );
   }

   return compListPtr;
}

fpa1_syntaxList* fpa1_synAddItemToStartOfList( fpa1_syntaxList *listPtr,
   fpa1_syntaxList *compToAdd )
{
   fpa1_syntaxList *lastItemPtr;

   if (listPtr != NULL)
   {
      if (compToAdd != NULL)
      {
         lastItemPtr = compToAdd;
         /* get last item and tack list onto to end of it */
         while (lastItemPtr->next != NULL)
            lastItemPtr = lastItemPtr->next;

         lastItemPtr->next = listPtr;

         return compToAdd;
      }
      else
      {
         return listPtr;
      }
   }
   else
   {
      return compToAdd;
   }
} /* fpa1_synAddItemToStartOfList */

fpa1_syntaxList* fpa1_synAddItemToList( fpa1_syntaxList *firstComp,
   fpa1_syntaxList *compToAdd )
{
   /* Possibly a bit over the top */
   fpa1_syntaxList *tempPtr = firstComp;

   if (tempPtr != NULL)
   {
      while ((tempPtr->next != NULL))
      {
         tempPtr = tempPtr->next;
      }

      tempPtr->next = compToAdd;

      return firstComp;
   }
   else
   {
      return compToAdd;
   }
} /* fpa1_synAddItemToList */

fpa1_syntaxList* fpa1_synCreateListItem( int tag,
   vpa1_filePos tagPosition,
   vpa1_filePos nextTagPosition )
{
   fpa1_syntaxList *tempPtr;

   /*tempPtr = (fpa1_syntaxList *) pa1_malloc( sizeof( fpa1_syntaxList ) );*/
   tempPtr = fpa1_getTagItem();

   if (tempPtr != NULL)
   {
      /* next points to tags on the same level i.e. tags */
      /* within sequences or sets                        */
      tempPtr->next = NULL;

      /* children points to tags NOT on same level */
      /* i.e. sequences within sequences           */
      tempPtr->children = NULL;
      tempPtr->tag = tag;
      tempPtr->tagPosition = tagPosition;
      tempPtr->nextTagPosition = nextTagPosition;
      tempPtr->childCount[0] = 0;
      tempPtr->childCount[1] = 0;
      tempPtr->childCount[2] = 0;
      tempPtr->dataTotal = 0;

      /* printf("\nCreate %p posn %d tag %d\n", tempPtr, tagPosition, tag ); */
   }

   return tempPtr;
} /* fpa1_synCreateListItem() */

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

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

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

      /* printf("\nFree %p posn %d tag %d\n", firstComp,
                                              firstComp->tagPosition,
                                              firstComp->tag ); */

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

      /*pa1_free( (void *) firstComp);*/
   }

   return nextComp;
} /* fpa1_synFreeFirstItem() */

void fpa1_synFreeList( fpa1_syntaxList *firstComp )
{
   while (firstComp != NULL)
   {
      firstComp = fpa1_synFreeFirstItem( firstComp );
   }
} /* fpa1_synFreeList() */

fpa1_syntaxList* fpa1_synGetUnknowns( vpa1_filePos startPosition,
   vpa1_filePos endPosition,
   fpa1_syntaxList *inputPtr )
{
   fpa1_syntaxList *tempPtr;
   fpa1_syntaxList *unknownPtr = NULL;

   while (inputPtr != NULL)
   {
      /* we have a list! */
      if (inputPtr->tagPosition == startPosition)
      {
         /* tag contiguous with last tag - move on to the next one */
         startPosition = inputPtr->nextTagPosition;
         inputPtr = inputPtr->next;
      }
      else
      {
         /* found a gap in tag list - create an "unknown" item */

         /* set up position */
         fpa1_rdfSetNewFilePosition( startPosition );

         /* create item - unknown tag goes from current position to start */
         tempPtr = fpa1_synCreateListItem( fpa1_rdfGetTag(),
               startPosition,
               inputPtr->tagPosition );

         /* get primative data */
         if (tempPtr->tag < CONT_SPEC_TAGS)
         {
            fpa1_parseData(tempPtr);
         }

         unknownPtr = fpa1_synAddItemToList( unknownPtr, tempPtr );

         /* reset start position */
         startPosition = inputPtr->tagPosition;
      }
   }

   /* test for unknown "end" section */
   if (startPosition != endPosition)
   {
      /* create unknown "end" item */
      fpa1_rdfSetNewFilePosition( startPosition );

      /* create item - unknown tag goes from current position to start */
      tempPtr = fpa1_synCreateListItem( fpa1_rdfGetTag(),
            startPosition,
            endPosition );

      /* get primative data */
      if (tempPtr->tag < CONT_SPEC_TAGS)
      {
         fpa1_parseData(tempPtr);
      }

      unknownPtr = fpa1_synAddItemToList( unknownPtr, tempPtr );
   }

   return unknownPtr;
} /* fpa1_synGetUnknowns () */