fpa1_tgs.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_rdf.h"
#include "vpa1_sys.h"
#include "vpa1_tgs.h"

#include "fpa1_act.h"
#include "fpa1_app.h"
#include "fpa1_boo.h"
#include "fpa1_but.h"
#include "fpa1_cho.h"
#include "fpa1_col.h"
#include "fpa1_con.h"
#include "fpa1_dsp.h"
#include "fpa1_grp.h"
#include "fpa1_iac.h"
#include "fpa1_ing.h"
#include "fpa1_int.h"
#include "fpa1_lnk.h"
#include "fpa1_lst.h"
#include "fpa1_obj.h"
#include "fpa1_pos.h"
#include "fpa1_prg.h"
#include "fpa1_rdf.h"
#include "fpa1_sce.h"
#include "fpa1_seq.h"
#include "fpa1_set.h"
#include "fpa1_stm.h"
#include "fpa1_str.h"
#include "fpa1_syn.h"
#include "fpa1_tgs.h"
#include "fpa1_tok.h"
#include "fpa1_txt.h"
#include "fpa1_var.h"
#include "fpa1_vis.h"

#include "pa1_mem.h"
#include "glue_debug.h"

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

/*---constant definitions for this file--------------------------------------*/
#define NORM_APPLICATION           (APPLICATION - CONT_SPEC_TAGS)
#define NORM_SCENE                 (SCENE - CONT_SPEC_TAGS)
#define NORM_STDID                 (STDID - CONT_SPEC_TAGS)
#define NORM_STDVER                (STDVER - CONT_SPEC_TAGS)
#define NORM_OBJINFO               (OBJINFO - CONT_SPEC_TAGS)
#define NORM_STARTUP               (STARTUP - CONT_SPEC_TAGS)
#define NORM_CLOSEDOWN             (CLOSEDOWN - CONT_SPEC_TAGS)
#define NORM_GCPRIO                (GCPRIO - CONT_SPEC_TAGS)
#define NORM_ITEMS                 (ITEMS - CONT_SPEC_TAGS)
#define NORM_RESIDENT              (RESIDENT - CONT_SPEC_TAGS)
#define NORM_REMOTE                (REMOTE - CONT_SPEC_TAGS)
#define NORM_INTERCHAN             (INTERCHAN - CONT_SPEC_TAGS)
#define NORM_PALETTE               (PALETTE - CONT_SPEC_TAGS)
#define NORM_FONT                  (FONT - CONT_SPEC_TAGS)
#define NORM_CSHAPE                (CSHAPE - CONT_SPEC_TAGS)
#define NORM_BOOLVAR               (BOOLVAR - CONT_SPEC_TAGS)
#define NORM_INTVAR                (INTVAR - CONT_SPEC_TAGS)
#define NORM_OCTVAR                (OCTVAR - CONT_SPEC_TAGS)
#define NORM_OBJVAR                (OBJVAR - CONT_SPEC_TAGS)
#define NORM_CONTVAR               (CONTVAR - CONT_SPEC_TAGS)
#define NORM_LINK                  (LINK - CONT_SPEC_TAGS)
#define NORM_STREAM                (STREAM - CONT_SPEC_TAGS)
#define NORM_BITMAP                (BITMAP - CONT_SPEC_TAGS)
#define NORM_LINEART               (LINEART - CONT_SPEC_TAGS)
#define NORM_DYNAMICLINEART        (DYNAMICLINEART - CONT_SPEC_TAGS)
#define NORM_RECT                  (RECT - CONT_SPEC_TAGS)
#define NORM_HOTSPOT               (HOTSPOT - CONT_SPEC_TAGS)
#define NORM_SWITCH                (SWITCH - CONT_SPEC_TAGS)
#define NORM_PUSH                  (PUSH - CONT_SPEC_TAGS)
#define NORM_TEXT                  (TEXT - CONT_SPEC_TAGS)
#define NORM_ENTRY                 (ENTRY - CONT_SPEC_TAGS)
#define NORM_HYPER                 (HYPER - CONT_SPEC_TAGS)
#define NORM_SLIDER                (SLIDER - CONT_SPEC_TAGS)
#define NORM_TGROUP                (TGROUP - CONT_SPEC_TAGS)
#define NORM_LGROUP                (LGROUP - CONT_SPEC_TAGS)
#define NORM_SPAWNCLOSE            (SPAWNCLOSE - CONT_SPEC_TAGS)
#define NORM_RESTART               (RESTART - CONT_SPEC_TAGS)
#define NORM_DEFATTS               (DEFATTS - CONT_SPEC_TAGS)
#define NORM_CHARSET               (CHARSET - CONT_SPEC_TAGS)
#define NORM_BACKCOL               (BACKCOL - CONT_SPEC_TAGS)
#define NORM_TCHOOK                (TCHOOK - CONT_SPEC_TAGS)
#define NORM_TCOL                  (TCOL - CONT_SPEC_TAGS)
#define NORM_DEFFONT               (DEFFONT - CONT_SPEC_TAGS)
#define NORM_FONTATTS              (FONTATTS - CONT_SPEC_TAGS)
#define NORM_INTPRGCHOOK           (INTPRGCHOOK - CONT_SPEC_TAGS)
#define NORM_STREAMCHOOK           (STREAMCHOOK - CONT_SPEC_TAGS)
#define NORM_BITMAPCHOOK           (BITMAPCHOOK - CONT_SPEC_TAGS)
#define NORM_LINEARTCHOOK          (LINEARTCHOOK - CONT_SPEC_TAGS)
#define NORM_BUTTONREFCOL          (BUTTONREFCOL - CONT_SPEC_TAGS)
#define NORM_HIGHREFCOL            (HIGHREFCOL - CONT_SPEC_TAGS)
#define NORM_SLIDEREFCOL           (SLIDEREFCOL - CONT_SPEC_TAGS)
#define NORM_INEVENT               (INEVENT - CONT_SPEC_TAGS)
#define NORM_SCENECOORDS           (SCENECOORDS - CONT_SPEC_TAGS)
#define NORM_ASPECT                (ASPECT - CONT_SPEC_TAGS)
#define NORM_MOVING                (MOVING - CONT_SPEC_TAGS)
#define NORM_NEXTSCN               (NEXTSCN - CONT_SPEC_TAGS)
#define NORM_INITACTIVE            (INITACTIVE - CONT_SPEC_TAGS)
#define NORM_CHOOK                 (CHOOK - CONT_SPEC_TAGS)
#define NORM_OCONTENT              (OCONTENT - CONT_SPEC_TAGS)
#define NORM_SHARED                (SHARED - CONT_SPEC_TAGS)
#define NORM_CONTSIZE              (CONTSIZE - CONT_SPEC_TAGS)
#define NORM_CONTPRIO              (CONTPRIO - CONT_SPEC_TAGS)
#define NORM_LINKCOND              (LINKCOND - CONT_SPEC_TAGS)
#define NORM_EFFECT                (EFFECT - CONT_SPEC_TAGS)
#define NORM_NAME                  (NAME - CONT_SPEC_TAGS)
#define NORM_INITAVAIL             (INITAVAIL - CONT_SPEC_TAGS)
#define NORM_PRGCONTAG             (PRGCONTAG - CONT_SPEC_TAGS)
#define NORM_OVALUE                (OVALUE - CONT_SPEC_TAGS)
#define NORM_OBJREF                (OBJREF - CONT_SPEC_TAGS)
#define NORM_CONTREF               (CONTREF - CONT_SPEC_TAGS)
#define NORM_MOVEMENTTABLE         (MOVEMENTTABLE - CONT_SPEC_TAGS)
#define NORM_TGITEMS               (TGITEMS - CONT_SPEC_TAGS)
#define NORM_NOTOKEN               (NOTOKEN - CONT_SPEC_TAGS)
#define NORM_POSITIONS             (POSITIONS - CONT_SPEC_TAGS)
#define NORM_WRAP                  (WRAP - CONT_SPEC_TAGS)
#define NORM_MULTIPLE              (MULTIPLE - CONT_SPEC_TAGS)
#define NORM_OBOXSIZE              (OBOXSIZE - CONT_SPEC_TAGS)
#define NORM_OPOSITION             (OPOSITION - CONT_SPEC_TAGS)
#define NORM_OPALREF               (OPALREF - CONT_SPEC_TAGS)
#define NORM_TILING                (TILING - CONT_SPEC_TAGS)
#define NORM_OTRANS                (OTRANS - CONT_SPEC_TAGS)
#define NORM_BBBOX                 (BBBOX - CONT_SPEC_TAGS)
#define NORM_OLWIDTH               (OLWIDTH - CONT_SPEC_TAGS)
#define NORM_OLSTYLE               (OLSTYLE - CONT_SPEC_TAGS)
#define NORM_ORLCOLOUR             (ORLCOLOUR - CONT_SPEC_TAGS)
#define NORM_ORFCOLOUR             (ORFCOLOUR - CONT_SPEC_TAGS)
#define NORM_OFONT                 (OFONT - CONT_SPEC_TAGS)
#define NORM_HJUST                 (HJUST - CONT_SPEC_TAGS)
#define NORM_VJUST                 (VJUST - CONT_SPEC_TAGS)
#define NORM_LINEOR                (LINEOR - CONT_SPEC_TAGS)
#define NORM_STARTCORN             (STARTCORN - CONT_SPEC_TAGS)
#define NORM_TEXTWRAP              (TEXTWRAP - CONT_SPEC_TAGS)
#define NORM_MULTIPLEX             (MULTIPLEX - CONT_SPEC_TAGS)
#define NORM_STORAGE               (STORAGE - CONT_SPEC_TAGS)
#define NORM_LOOPING               (LOOPING - CONT_SPEC_TAGS)
#define NORM_AUDIO                 (AUDIO - CONT_SPEC_TAGS)
#define NORM_VIDEO                 (VIDEO - CONT_SPEC_TAGS)
#define NORM_RTGRAPHICS            (RTGRAPHICS - CONT_SPEC_TAGS)
#define NORM_COMPTAG               (COMPTAG - CONT_SPEC_TAGS)
#define NORM_OVOLUME               (OVOLUME - CONT_SPEC_TAGS)
#define NORM_TERMIN                (TERMIN - CONT_SPEC_TAGS)
#define NORM_ENGRESP               (ENGRESP - CONT_SPEC_TAGS)
#define NORM_ORIENTATION           (ORIENTATION - CONT_SPEC_TAGS)
#define NORM_MAXVAL                (MAXVAL - CONT_SPEC_TAGS)
#define NORM_MINVAL                (MINVAL - CONT_SPEC_TAGS)
#define NORM_INITVAL               (INITVAL - CONT_SPEC_TAGS)
#define NORM_INITPOR               (INITPOR - CONT_SPEC_TAGS)
#define NORM_STEPSIZE              (STEPSIZE - CONT_SPEC_TAGS)
#define NORM_SLSTYLE               (SLSTYLE - CONT_SPEC_TAGS)
#define NORM_INPUTTYPE             (INPUTTYPE - CONT_SPEC_TAGS)
#define NORM_CHARLIST              (CHARLIST - CONT_SPEC_TAGS)
#define NORM_OBSCURED              (OBSCURED - CONT_SPEC_TAGS)
#define NORM_MAXLEN                (MAXLEN - CONT_SPEC_TAGS)
#define NORM_OLABEL                (OLABEL - CONT_SPEC_TAGS)
#define NORM_BSTYLE                (BSTYLE - CONT_SPEC_TAGS)
#define NORM_ACTIVATE              (ACTIVATE - CONT_SPEC_TAGS)
#define NORM_ADD                   (ADD - CONT_SPEC_TAGS)
#define NORM_ADDITEM               (ADDITEM - CONT_SPEC_TAGS)
#define NORM_APPEND                (APPEND - CONT_SPEC_TAGS)
#define NORM_BRINGTOFRONT          (BRINGTOFRONT - CONT_SPEC_TAGS)
#define NORM_CALL                  (CALL - CONT_SPEC_TAGS)
#define NORM_CALLACTIONSLOT        (CALLACTIONSLOT - CONT_SPEC_TAGS)
#define NORM_CLEAR                 (CLEAR - CONT_SPEC_TAGS)
#define NORM_CLONE                 (CLONE - CONT_SPEC_TAGS)
#define NORM_CLOSECONNECTION       (CLOSECONNECTION - CONT_SPEC_TAGS)
#define NORM_DEACTIVATE            (DEACTIVATE - CONT_SPEC_TAGS)
#define NORM_DELITEM               (DELITEM - CONT_SPEC_TAGS)
#define NORM_DESELECT              (DESELECT - CONT_SPEC_TAGS)
#define NORM_DESELECTITEM          (DESELECTITEM - CONT_SPEC_TAGS)
#define NORM_DIVIDE                (DIVIDE - CONT_SPEC_TAGS)
#define NORM_DRAWARC               (DRAWARC - CONT_SPEC_TAGS)
#define NORM_DRAWLINE              (DRAWLINE - CONT_SPEC_TAGS)
#define NORM_DRAWOVAL              (DRAWOVAL - CONT_SPEC_TAGS)
#define NORM_DRAWPOLYGON           (DRAWPOLYGON - CONT_SPEC_TAGS)
#define NORM_DRAWPOLYLINE          (DRAWPOLYLINE - CONT_SPEC_TAGS)
#define NORM_DRAWRECTANGLE         (DRAWRECTANGLE - CONT_SPEC_TAGS)
#define NORM_DRAWSECTOR            (DRAWSECTOR - CONT_SPEC_TAGS)
#define NORM_FORK                  (FORK - CONT_SPEC_TAGS)
#define NORM_GETAVAILABILITYSTATUS (GETAVAILABILITYSTATUS - CONT_SPEC_TAGS)
#define NORM_GETBOXSIZE            (GETBOXSIZE - CONT_SPEC_TAGS)
#define NORM_GETCELLITEM           (GETCELLITEM - CONT_SPEC_TAGS)
#define NORM_GETCURSORPOSITION     (GETCURSORPOSITION - CONT_SPEC_TAGS)
#define NORM_GETENGINESUPPORT      (GETENGINESUPPORT - CONT_SPEC_TAGS)
#define NORM_GETENTRYPOINT         (GETENTRYPOINT - CONT_SPEC_TAGS)
#define NORM_GETFILLCOLOUR         (GETFILLCOLOUR - CONT_SPEC_TAGS)
#define NORM_GETFIRSTITEM          (GETFIRSTITEM - CONT_SPEC_TAGS)
#define NORM_GETHIGHLIGHTSTATUS    (GETHIGHLIGHTSTATUS - CONT_SPEC_TAGS)
#define NORM_GETINTERACTIONSTATUS  (GETINTERACTIONSTATUS - CONT_SPEC_TAGS)
#define NORM_GETITEMSTATUS         (GETITEMSTATUS - CONT_SPEC_TAGS)
#define NORM_GETLABEL              (GETLABEL - CONT_SPEC_TAGS)
#define NORM_GETLASTANCHORFIRED    (GETLASTANCHORFIRED - CONT_SPEC_TAGS)
#define NORM_GETLINECOLOUR         (GETLINECOLOUR - CONT_SPEC_TAGS)
#define NORM_GETLINESTYLE          (GETLINESTYLE - CONT_SPEC_TAGS)
#define NORM_GETLINEWIDTH          (GETLINEWIDTH - CONT_SPEC_TAGS)
#define NORM_GETLISTITEM           (GETLISTITEM - CONT_SPEC_TAGS)
#define NORM_GETLISTSIZE           (GETLISTSIZE - CONT_SPEC_TAGS)
#define NORM_GETOVERWRITEMODE      (GETOVERWRITEMODE - CONT_SPEC_TAGS)
#define NORM_GETPORTION            (GETPORTION - CONT_SPEC_TAGS)
#define NORM_GETPOSITION           (GETPOSITION - CONT_SPEC_TAGS)
#define NORM_GETRUNNINGSTATUS      (GETRUNNINGSTATUS - CONT_SPEC_TAGS)
#define NORM_GETSELECTIONSTATUS    (GETSELECTIONSTATUS - CONT_SPEC_TAGS)
#define NORM_GETSLIDERVALUE        (GETSLIDERVALUE - CONT_SPEC_TAGS)
#define NORM_GETTEXTCONTENT        (GETTEXTCONTENT - CONT_SPEC_TAGS)
#define NORM_GETTEXTDATA           (GETTEXTDATA - CONT_SPEC_TAGS)
#define NORM_GETTOKENPOSITION      (GETTOKENPOSITION - CONT_SPEC_TAGS)
#define NORM_GETVOLUME             (GETVOLUME - CONT_SPEC_TAGS)
#define NORM_LAUNCH                (LAUNCH - CONT_SPEC_TAGS)
#define NORM_LOCKSCREEN            (LOCKSCREEN - CONT_SPEC_TAGS)
#define NORM_MODULO                (MODULO - CONT_SPEC_TAGS)
#define NORM_MOVE                  (MOVE - CONT_SPEC_TAGS)
#define NORM_MOVETO                (MOVETO - CONT_SPEC_TAGS)
#define NORM_MULTIPLY              (MULTIPLY - CONT_SPEC_TAGS)
#define NORM_OPENCONNECTION        (OPENCONNECTION - CONT_SPEC_TAGS)
#define NORM_PRELOAD               (PRELOAD - CONT_SPEC_TAGS)
#define NORM_PUTBEFORE             (PUTBEFORE - CONT_SPEC_TAGS)
#define NORM_PUTBEHIND             (PUTBEHIND - CONT_SPEC_TAGS)
#define NORM_QUIT                  (QUIT - CONT_SPEC_TAGS)
#define NORM_READPERSISTENT        (READPERSISTENT - CONT_SPEC_TAGS)
#define NORM_RUN                   (RUN - CONT_SPEC_TAGS)
#define NORM_SCALEBITMAP           (SCALEBITMAP - CONT_SPEC_TAGS)
#define NORM_SCALEVIDEO            (SCALEVIDEO - CONT_SPEC_TAGS)
#define NORM_SCROLLITEMS           (SCROLLITEMS - CONT_SPEC_TAGS)
#define NORM_SELECT                (SELECT - CONT_SPEC_TAGS)
#define NORM_SELECTITEM            (SELECTITEM - CONT_SPEC_TAGS)
#define NORM_SENDEVENT             (SENDEVENT - CONT_SPEC_TAGS)
#define NORM_SENDTOBACK            (SENDTOBACK - CONT_SPEC_TAGS)
#define NORM_SETBOXSIZE            (SETBOXSIZE - CONT_SPEC_TAGS)
#define NORM_SETCACHEPRIORITY      (SETCACHEPRIORITY - CONT_SPEC_TAGS)
#define NORM_SETCOUNTERENDPOSITION (SETCOUNTERENDPOSITION - CONT_SPEC_TAGS)
#define NORM_SETCOUNTERPOSITION    (SETCOUNTERPOSITION - CONT_SPEC_TAGS)
#define NORM_SETCOUNTERTRIGGER     (SETCOUNTERTRIGGER - CONT_SPEC_TAGS)
#define NORM_SETCURSORPOSITION     (SETCURSORPOSITION - CONT_SPEC_TAGS)
#define NORM_SETCURSORSHAPE        (SETCURSORSHAPE - CONT_SPEC_TAGS)
#define NORM_SETDATA               (SETDATA - CONT_SPEC_TAGS)
#define NORM_SETENTRYPOINT         (SETENTRYPOINT - CONT_SPEC_TAGS)
#define NORM_SETFILLCOLOUR         (SETFILLCOLOUR - CONT_SPEC_TAGS)
#define NORM_SETFIRSTITEM          (SETFIRSTITEM - CONT_SPEC_TAGS)
#define NORM_SETFONTREF            (SETFONTREF - CONT_SPEC_TAGS)
#define NORM_SETHIGHLIGHTSTATUS    (SETHIGHLIGHTSTATUS - CONT_SPEC_TAGS)
#define NORM_SETINTERACTIONSTATUS  (SETINTERACTIONSTATUS - CONT_SPEC_TAGS)
#define NORM_SETLABEL              (SETLABEL - CONT_SPEC_TAGS)
#define NORM_SETLINECOLOUR         (SETLINECOLOUR - CONT_SPEC_TAGS)
#define NORM_SETLINESTYLE          (SETLINESTYLE - CONT_SPEC_TAGS)
#define NORM_SETLINEWIDTH          (SETLINEWIDTH - CONT_SPEC_TAGS)
#define NORM_SETOVERWRITEMODE      (SETOVERWRITEMODE - CONT_SPEC_TAGS)
#define NORM_SETPALETTEREF         (SETPALETTEREF - CONT_SPEC_TAGS)
#define NORM_SETPORTION            (SETPORTION - CONT_SPEC_TAGS)
#define NORM_SETPOSITION           (SETPOSITION - CONT_SPEC_TAGS)
#define NORM_SETSLIDERVALUE        (SETSLIDERVALUE - CONT_SPEC_TAGS)
#define NORM_SETSPEED              (SETSPEED - CONT_SPEC_TAGS)
#define NORM_SETTIMER              (SETTIMER - CONT_SPEC_TAGS)
#define NORM_SETTRANSPARENCY       (SETTRANSPARENCY - CONT_SPEC_TAGS)
#define NORM_SETVARIABLE           (SETVARIABLE - CONT_SPEC_TAGS)
#define NORM_SETVOLUME             (SETVOLUME - CONT_SPEC_TAGS)
#define NORM_SPAWN                 (SPAWN - CONT_SPEC_TAGS)
#define NORM_STEP                  (STEP - CONT_SPEC_TAGS)
#define NORM_STOP                  (STOP - CONT_SPEC_TAGS)
#define NORM_STOREPERSISTENT       (STOREPERSISTENT - CONT_SPEC_TAGS)
#define NORM_SUBTRACT              (SUBTRACT - CONT_SPEC_TAGS)
#define NORM_TESTVARIABLE          (TESTVARIABLE - CONT_SPEC_TAGS)
#define NORM_TOGGLE                (TOGGLE - CONT_SPEC_TAGS)
#define NORM_TOGGLEITEM            (TOGGLEITEM - CONT_SPEC_TAGS)
#define NORM_TRANSITIONTO          (TRANSITIONTO - CONT_SPEC_TAGS)
#define NORM_UNLOAD                (UNLOAD - CONT_SPEC_TAGS)
#define NORM_UNLOCKSCREEN          (UNLOCKSCREEN - CONT_SPEC_TAGS)
#define NORM_INVOKE                (INVOKE - CONT_SPEC_TAGS)
#define NORM_GBOOL                 (GBOOL - CONT_SPEC_TAGS)
#define NORM_GINT                  (GINT - CONT_SPEC_TAGS)
#define NORM_GOSTRING              (GOSTRING - CONT_SPEC_TAGS)
#define NORM_GOBJREF               (GOBJREF - CONT_SPEC_TAGS)
#define NORM_GCONTREF              (GCONTREF - CONT_SPEC_TAGS)
#define NORM_NEWCOLIND             (NEWCOLIND - CONT_SPEC_TAGS)
#define NORM_NEWABSCOL             (NEWABSCOL - CONT_SPEC_TAGS)
#define NORM_NEWFONTNAME           (NEWFONTNAME - CONT_SPEC_TAGS)
#define NORM_NEWFONTREF            (NEWFONTREF - CONT_SPEC_TAGS)
#define NORM_NEWCSIZE              (NEWCSIZE - CONT_SPEC_TAGS)
#define NORM_NEWCPRIO              (NEWCPRIO - CONT_SPEC_TAGS)
#define NORM_INDIRECT              (INDIRECT - CONT_SPEC_TAGS)
#define NORM_SETBACKGROUNDCOLOUR   (SETBACKGROUNDCOLOUR - CONT_SPEC_TAGS)
#define NORM_SETCELLPOSITION       (SETCELLPOSITION - CONT_SPEC_TAGS)
#define NORM_SETINPUTREGISTER      (SETINPUTREGISTER - CONT_SPEC_TAGS)
#define NORM_SETTEXTCOLOUR         (SETTEXTCOLOUR - CONT_SPEC_TAGS)
#define NORM_SETFONTATTRIBUTES     (SETFONTATTRIBUTES - CONT_SPEC_TAGS)
#define NORM_SETVIDEODECODEOFFSET  (SETVIDEODECODEOFFSET - CONT_SPEC_TAGS)
#define NORM_GETVIDEODECODEOFFSET  (GETVIDEODECODEOFFSET - CONT_SPEC_TAGS)
#define NORM_GETFOCUSPOSITION      (GETFOCUSPOSITION - CONT_SPEC_TAGS)
#define NORM_SETFOCUSPOSITION      (SETFOCUSPOSITION - CONT_SPEC_TAGS)
#define NORM_SETBITMAPDECODEOFFSET (SETBITMAPDECODEOFFSET - CONT_SPEC_TAGS)
#define NORM_GETBITMAPDECODEOFFSET (GETBITMAPDECODEOFFSET - CONT_SPEC_TAGS)
#define NORM_SETSLIDERPARAMETERS   (SETSLIDERPARAMETERS - CONT_SPEC_TAGS)
#define NORM_ODESKTOPCOLOUR        (ODESKTOPCOLOUR - CONT_SPEC_TAGS)
#define NORM_SETDESKTOPCOLOUR      (SETDESKTOPCOLOUR - CONT_SPEC_TAGS)
#define NORM_GETCOUNTERPOSITION    (GETCOUNTERPOSITION - CONT_SPEC_TAGS)
#define NORM_GETCOUNTERMAXPOSITION (GETCOUNTERMAXPOSITION - CONT_SPEC_TAGS)

/*InputMask Extension*/
#define NORM_OINPUTMASK            (OINPUTMASK - CONT_SPEC_TAGS)
#define NORM_SETINPUTMASK          (SETINPUTMASK - CONT_SPEC_TAGS)

/* for checking the number of bytes needed to encode a particular tag */
#define ONE_BYTE_TAG   (CONT_SPEC_TAGS + 30)
#define TWO_BYTE_TAG   (CONT_SPEC_TAGS + 127)


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

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

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


int fpa1_parseDataInt(fpa1_syntaxList *listPtr)
{
   int intLength;
   int lengthPosition;

   if (listPtr == NULL)
   {
      return 0;
   }

   lengthPosition = listPtr->tagPosition;

   /* Skip over the tag iteslf to find the length byte(s)                     */
   /* The tag itself can be 1,2 or 3 bytes long                               */
   /* If the tag can be encoded in 5 bits (ie < 30) then one byte is used,    */
   /* Otherwise the lower 5 bits are all 1 and the following bytes(s)         */
   /* contain the tag (as 7 bit bytes, bit 8 indicating there is another tag  */
   /* byte following).*/

   if (listPtr->tag > TWO_BYTE_TAG) /* ie. 3 byte tag */
   {
      lengthPosition += 3;
   }
   else if (listPtr->tag > ONE_BYTE_TAG) /* ie. 2 byte tag */
   {
      lengthPosition += 2;
   }
   else    /* 1 byte tag */
   {
      lengthPosition++;
   }

   intLength = fpa1_rdfGetByteAbsolute(lengthPosition);

   /* Note: this cannot handle multi byte lengths (ie. >127 byte integer) */
   /*       Since the UKprofile does not allow integers this long anyway  */
   /*       it will not cause a problem.                                  */
   listPtr->data.intData = (MHEG5Int) fpa1_rdfGetIntegerAbsolute(lengthPosition + 1, intLength);

   listPtr->dataType = 2;

   return 0;
}

int fpa1_parseDataBool(fpa1_syntaxList *listPtr)
{
   int dataPosition = listPtr->tagPosition;

   /* Skip over the tag iteslf to find the length byte(s)                     */
   /* The tag itself can be 1,2 or 3 bytes long                               */
   /* If the tag can be encoded in 5 bits (ie < 30) then one byte is used,    */
   /* Otherwise the lower 5 bits are all 1 and the following bytes(s)         */
   /* contain the tag (as 7 bit bytes, bit 8 indicating there is another tag  */
   /* byte following).*/
   if (listPtr->tag > TWO_BYTE_TAG) /* ie. 3 byte tag */
   {
      dataPosition += 4;
   }
   else if (listPtr->tag > ONE_BYTE_TAG) /* ie. 2 byte tag */
   {
      dataPosition += 3;
   }
   else    /* 1 byte tag */
   {
      dataPosition += 2;
   }

   listPtr->data.boolData = (MHEG5Bool) fpa1_rdfGetBooleanAbsolute(dataPosition);

   listPtr->dataType = 1;

   return 0;
}

int fpa1_parseDataStr(fpa1_syntaxList *listPtr)
{
   unsigned int lengthOfLength;
   MHEG5Int length;
   unsigned long currentPosition = listPtr->tagPosition;
   MHEG5Byte *newString;
   int tag; /* only used internally */

   /* check for multibyte tag. This can happen because the contentRef tag
      is changed to a string during parsing. If not checked, the position of the
      length byte could be wrong.*/
   tag = fpa1_rdfGetByteAbsolute(currentPosition);
   tag &= 0x1f;

   if (tag == 0x1f)
   {
      currentPosition++;
      /* skip any other tag bytes */
      while ((fpa1_rdfGetByteAbsolute(currentPosition) & 0x80) != 0)
      {
         currentPosition++;
      }
   }


   /* Note: max length of string is 2147483647 chars long (UK Profile) */
   currentPosition++; /* length byte */
   length = fpa1_rdfGetByteAbsolute(currentPosition);
   currentPosition++;


   if (length > 127) /* multibyte length */
   {
      lengthOfLength = length & 0xFFFFFF7F;
      length = 0;

      while (lengthOfLength > 0)
      {
         length = (length << 8) | fpa1_rdfGetByteAbsolute(currentPosition);
         lengthOfLength--;
         currentPosition++;
      }
   }

   listPtr->data.stringData.len = length;

   /* Even if string is of 0 length, need to allocate pointer for the null string data */
   newString = STR_DataAlloc( length );

   /* Check we allocated the string ok */
   if (newString == NULL)
   {
      DPL1(("ERROR: fpa1_parseDataStr() failed to pa1_malloc %ld bytes\n", length));
      listPtr->data.stringData.data = NULL;
      listPtr->data.stringData.len = 0;
      return 1;
   }
   else
   {
      listPtr->data.stringData.data = newString;
      while (length)
      {
         *newString = fpa1_rdfGetByteAbsolute(currentPosition);
         length--;
         newString++;
         currentPosition++;
      }
   }

   listPtr->dataType = 4;

   return 0;
}

int fpa1_parseData(fpa1_syntaxList *listPtr)
{
   if (listPtr->tag == INTEGER)
   {
      fpa1_parseDataInt(listPtr);
   }
   else if (listPtr->tag == MHEG_BOOL)
   {
      fpa1_parseDataBool(listPtr);
   }
   else if ((listPtr->tag == OCTETSTRING) || (listPtr->tag == CONTREF))
   {
      fpa1_parseDataStr(listPtr);
   }

   return 0;
}

int fpa1_tagsParse( fpa1_syntaxList *listPtr )
{
   vpa1_filePos nextTagPosition;
   int success = FALSE;
   fpa1_syntaxList *childPtr = NULL;
   unsigned short childCnt[3] = {0, 0, 0};
   unsigned short startGenericDataCnt = fpa1_GenericDataCount;

   if (listPtr != NULL)
   {
      fpa1_rdfSetNewFilePosition( listPtr->tagPosition );
      nextTagPosition = listPtr->nextTagPosition;

      switch (listPtr->tag)
      {
         /* Universal Class tags - decode them separately */
         /* only decodes INTEGER, MHEG_BOOL and OCTETSTRING tags */
         case INTEGER:
            fpa1_parseDataInt(listPtr);
            fpa1_GenericDataCount++;
            success = TRUE;
            break;

         case MHEG_BOOL:
            fpa1_parseDataBool(listPtr);
            fpa1_GenericDataCount++;
            success = TRUE;
            break;

         case OCTETSTRING:
         case CONTREF:  /* CONTREF is treated as a string */
            fpa1_parseDataStr(listPtr);
            fpa1_GenericDataCount++;
         /* fallthrough */

         case MHEG_NULL:
         case ENUMERATED:
         case SEQUENCE:
         case SET:
            success = TRUE;
            break;

         default:
            if (listPtr->tag < CONT_SPEC_TAGS)
            {
               success = TRUE;
            }
      }

      if (success == FALSE)
      {
         /* Context Specific tags */

         /* now move to contents */
         fpa1_rdfMoveToContents();

         switch (listPtr->tag - CONT_SPEC_TAGS)
         {
            case NORM_APPLICATION:
               childPtr = fpa1_setParse( appSetCompsArr, nextTagPosition );
               #ifdef DEBUG_TAGS
               fpa1_decodeAppSetList( childPtr, 0 );
               #endif
               break;
            case NORM_SCENE:
               childPtr = fpa1_setParse( sceneSetCompsArr, nextTagPosition );
               #ifdef DEBUG_TAGS
               fpa1_decodeSceneSetList( childPtr, 0 );
               #endif
               break;
            case NORM_STDID:
               childPtr = fpa1_sequenceParse( childCnt, stdIdSeqCompArr, nextTagPosition );
               break;
            case NORM_STDVER:      /* INTEGER */
            case NORM_GCPRIO:      /* INTEGER */
            case NORM_CHARSET:     /* INTEGER */
            case NORM_TCHOOK:      /* INTEGER */
            case NORM_INTPRGCHOOK: /* INTEGER */
            case NORM_STREAMCHOOK: /* INTEGER */
            case NORM_BITMAPCHOOK: /* INTEGER */
            case NORM_LINEARTCHOOK: /* INTEGER */
            case NORM_INEVENT:     /* INTEGER */
            case NORM_CHOOK:       /* INTEGER */
            case NORM_CONTSIZE:    /* INTEGER */
            case NORM_CONTPRIO:    /* INTEGER */
            case NORM_PRGCONTAG:   /* INTEGER */
            case NORM_OTRANS:      /* INTEGER */
            case NORM_OLWIDTH:     /* INTEGER */
            case NORM_OLSTYLE:     /* INTEGER */
            case NORM_LOOPING:     /* INTEGER */
            case NORM_COMPTAG:     /* INTEGER */
            case NORM_OVOLUME:     /* INTEGER */
            case NORM_MAXLEN:      /* INTEGER */
            case NORM_MAXVAL:      /* INTEGER */
            case NORM_MINVAL:      /* INTEGER */
            case NORM_INITVAL:     /* INTEGER */
            case NORM_INITPOR:     /* INTEGER */
            case NORM_STEPSIZE:    /* INTEGER */
            case NORM_HJUST:       /* ENUMERATED */
            case NORM_VJUST:       /* ENUMERATED */
            case NORM_LINEOR:      /* ENUMERATED */
            case NORM_STARTCORN:   /* ENUMERATED */
            case NORM_INPUTTYPE:   /* ENUMERATED */
            case NORM_STORAGE:     /* ENUMERATED */
            case NORM_TERMIN:      /* ENUMERATED */
            case NORM_ORIENTATION: /* ENUMERATED */
            case NORM_SLSTYLE:     /* ENUMERATED */
            case NORM_BSTYLE:      /* ENUMERATED */
               fpa1_parseDataInt(listPtr);
               success = TRUE;
               break;

            case NORM_MOVING:      /* MHEG_BOOL */
            case NORM_INITACTIVE:  /* MHEG_BOOL */
            case NORM_SHARED:      /* MHEG_BOOL */
            case NORM_INITAVAIL:   /* MHEG_BOOL */
            case NORM_WRAP:        /* MHEG_BOOL */
            case NORM_MULTIPLE:    /* MHEG_BOOL */
            case NORM_TILING:      /* MHEG_BOOL */
            case NORM_BBBOX:       /* MHEG_BOOL */
            case NORM_TEXTWRAP:    /* MHEG_BOOL */
            case NORM_ENGRESP:     /* MHEG_BOOL */
            case NORM_OBSCURED:    /* MHEG_BOOL */
               fpa1_parseDataBool(listPtr);
               success = TRUE;
               break;

            case NORM_OBJINFO:     /* OCTETSTRING */
            case NORM_FONTATTS:    /* OCTETSTRING */
            case NORM_NAME:        /* OCTETSTRING */
            case NORM_CONTREF:     /* OCTETSTRING */
            case NORM_CHARLIST:    /* OCTETSTRING */
            case NORM_OLABEL:      /* OCTETSTRING */
            case NORM_OINPUTMASK:  /* OCTETSTRING */

               fpa1_parseDataStr(listPtr);
               success = TRUE;
               break;

            case NORM_STARTUP:
            case NORM_CLOSEDOWN:
            case NORM_SPAWNCLOSE:
            case NORM_RESTART:
            case NORM_EFFECT:
               childPtr = fpa1_sequenceOfParse( childCnt, SEQ_OF_ELEMENTARY_ACTION, nextTagPosition );
               fpa1_GroupActionCount += *childCnt;
               fpa1_GroupParamCount += fpa1_GenericDataCount - startGenericDataCnt;
               break;

            case NORM_ITEMS:
               childPtr = fpa1_sequenceOfParse( childCnt, SEQ_OF_GROUP_ITEM, nextTagPosition );
               break;

            case NORM_RESIDENT:
               childPtr = fpa1_setParse( resPrgSetCompsArr, nextTagPosition );
               break;

            case NORM_REMOTE:
               childPtr = fpa1_setParse( remPrgSetCompsArr, nextTagPosition );
               break;

            case NORM_INTERCHAN:
               childPtr = fpa1_setParse( itcPrgSetCompsArr, nextTagPosition );
               break;

            case NORM_PALETTE: /* same as PALETTE */
            case NORM_FONT:
            case NORM_CSHAPE:
               childPtr = fpa1_setParse( paletteSetCompsArr, nextTagPosition );
               break;

            case NORM_BOOLVAR:
               childPtr = fpa1_decodeVariable( nextTagPosition, MHEG_BOOL );
               break;

            case NORM_INTVAR:
               childPtr = fpa1_decodeVariable( nextTagPosition, INTEGER );
               break;

            case NORM_OCTVAR:
               childPtr = fpa1_decodeVariable( nextTagPosition, OCTETSTRING );
               break;

            case NORM_OBJVAR:
               childPtr = fpa1_decodeVariable( nextTagPosition, OBJREF );
               break;

            case NORM_CONTVAR:
               childPtr = fpa1_decodeVariable( nextTagPosition, CONTREF );
               break;

            case NORM_LINK:
               childPtr = fpa1_setParse( lnkSetCompsArr, nextTagPosition );
               break;

            case NORM_STREAM:
               childPtr = fpa1_setParse( streamSetCompsArr, nextTagPosition );
               break;

            case NORM_BITMAP:
               childPtr = fpa1_setParse( bmpSetCompsArr, nextTagPosition );
               break;

            case NORM_LINEART:
               childPtr = fpa1_setParse( lartSetCompsArr, nextTagPosition );
               break;

            case NORM_DYNAMICLINEART:
               childPtr = fpa1_setParse( dLartSetCompsArr, nextTagPosition );
               break;

            case NORM_RECT:
               childPtr = fpa1_setParse( rectSetCompsArr, nextTagPosition );
               break;

            case NORM_HOTSPOT:
               childPtr = fpa1_setParse( buttonSetCompsArr, nextTagPosition );
               break;

            case NORM_SWITCH:
               childPtr = fpa1_setParse( switButSetCompsArr, nextTagPosition );
               break;

            case NORM_PUSH:
               childPtr = fpa1_setParse( pushButSetCompsArr, nextTagPosition );
               break;

            case NORM_TEXT:
               childPtr = fpa1_setParse( txtSetCompsArr, nextTagPosition );
               break;

            case NORM_ENTRY:
               childPtr = fpa1_setParse( entFldSetCompsArr, nextTagPosition );
               break;

            case NORM_HYPER:
               childPtr = fpa1_setParse( hypTxtSetCompsArr, nextTagPosition );
               break;

            case NORM_SLIDER:
               childPtr = fpa1_setParse( sliderSetCompsArr, nextTagPosition );
               break;

            case NORM_TGROUP:
               childPtr = fpa1_setParse( tokGrpSetCompsArr, nextTagPosition );
               break;

            case NORM_LGROUP:
               childPtr = fpa1_setParse( listGrpSetCompsArr, nextTagPosition );
               break;

            case NORM_DEFATTS:
               childPtr = fpa1_sequenceOfParse( childCnt, SEQ_OF_DEF_ATTRIBS, nextTagPosition );
               break;

            case NORM_DEFFONT:
            case NORM_OFONT:
               childPtr = fpa1_choiceParse( fontBodyChoiceCompArr );
               break;

            case NORM_BACKCOL: /* Colour */
            case NORM_TCOL:
            case NORM_BUTTONREFCOL:
            case NORM_HIGHREFCOL:
            case NORM_SLIDEREFCOL:
            case NORM_ORLCOLOUR:
            case NORM_ORFCOLOUR:
            case NORM_ODESKTOPCOLOUR:
               childPtr = fpa1_choiceParse( colourChoiceCompArr );
               break;

            case NORM_SCENECOORDS: /* same sequence as SCENECOORDS */
            case NORM_ASPECT:
               childPtr = fpa1_sequenceParse( childCnt, sneCoordSysSeqCompArr, nextTagPosition );
               break;

            case NORM_NEXTSCN:
               childPtr = fpa1_sequenceOfParse( childCnt, SEQ_OF_NEXT_SCENE, nextTagPosition );
               fpa1_GroupParamCount += fpa1_GenericDataCount - startGenericDataCnt;
               break;

            case NORM_OCONTENT:
               childPtr = fpa1_choiceParse( cntBdyChoiceCompArr );
               break;

            case NORM_LINKCOND:
               childPtr = fpa1_sequenceParse( childCnt, lnkCndSeqCompArr, nextTagPosition );
               break;

            case NORM_OVALUE:
               childPtr = fpa1_choiceParse( oriVarChoiceCompArr );
               break;

            case NORM_OBJREF:  /* all ObjectReference choices */
            case NORM_OPALREF:
            case NORM_INDIRECT:
               childPtr = fpa1_choiceParse( objRefChoiceCompArr );
               break;

            case NORM_MOVEMENTTABLE:
               childPtr = fpa1_sequenceOfParse( childCnt, SEQ_OF_MOVEMENT, nextTagPosition );
               break;

            case NORM_TGITEMS:
               childPtr = fpa1_sequenceOfParse( childCnt, SEQ_OF_TOKEN_GROUP_ITEM, nextTagPosition );
               break;

            case NORM_NOTOKEN:
               childPtr = fpa1_sequenceOfParse( childCnt, SEQ_OF_ACTION_SLOT, nextTagPosition );
               break;

            case NORM_POSITIONS:
               childPtr = fpa1_sequenceOfParse( childCnt, SEQ_OF_XY_POSITION, nextTagPosition );
               break;

            case NORM_OBOXSIZE:
               childPtr = fpa1_sequenceParse( childCnt, oboxSizeSeqCompArr, nextTagPosition );
               break;

            case NORM_OPOSITION:
               childPtr = fpa1_sequenceParse( childCnt, xyPosSeqCompArr, nextTagPosition );
               break;

            case NORM_MULTIPLEX:
               childPtr = fpa1_sequenceOfParse( childCnt, SEQ_OF_STREAM_COMP, nextTagPosition );
               break;

            case NORM_AUDIO:
               childPtr = fpa1_setParse( audioSetCompsArr, nextTagPosition );
               break;

            case NORM_VIDEO:
               childPtr = fpa1_setParse( videoSetCompsArr, nextTagPosition );
               break;

            case NORM_RTGRAPHICS:
               childPtr = fpa1_setParse( rtgSetCompsArr, nextTagPosition );
               break;

            case NORM_ACTIVATE:     /* GenericObjectReference */
            case NORM_BRINGTOFRONT:
            case NORM_CLEAR:
            case NORM_DEACTIVATE:
            case NORM_DESELECT:
            case NORM_LOCKSCREEN:
            case NORM_PRELOAD:
            case NORM_QUIT:
            case NORM_RUN:
            case NORM_SELECT:
            case NORM_SENDTOBACK:
            case NORM_SPAWN:
            case NORM_STOP:
            case NORM_TOGGLE:
            case NORM_UNLOAD:
            case NORM_UNLOCKSCREEN:
            case NORM_GOBJREF:
            case NORM_NEWFONTREF:
               childPtr = fpa1_choiceParse( genObjRefChoiceCompArr );
               break;

            case NORM_ADD:          /* same sequence as ADD */
            case NORM_CALLACTIONSLOT:
            case NORM_CLOSECONNECTION:
            case NORM_DESELECTITEM:
            case NORM_DIVIDE:
            case NORM_LAUNCH:
            case NORM_MODULO:
            case NORM_MOVE:
            case NORM_MOVETO:
            case NORM_MULTIPLY:
            case NORM_SCROLLITEMS:
            case NORM_SELECTITEM:
            case NORM_SETCACHEPRIORITY:
            case NORM_SETCOUNTERENDPOSITION:
            case NORM_SETCOUNTERPOSITION:
            case NORM_SETENTRYPOINT:
            case NORM_SETFIRSTITEM:
            case NORM_SETFOCUSPOSITION:
            case NORM_SETINPUTREGISTER:
            case NORM_SETLINESTYLE:
            case NORM_SETLINEWIDTH:
            case NORM_SETPORTION:
            case NORM_SETSLIDERVALUE:
            case NORM_SETTRANSPARENCY:
            case NORM_SETVOLUME:
            case NORM_STEP:
            case NORM_SUBTRACT:
            case NORM_TOGGLEITEM:
               childPtr = fpa1_sequenceParse( childCnt, addSeqCompArr, nextTagPosition );
               break;

            case NORM_ADDITEM:
               childPtr = fpa1_sequenceParse( childCnt, addItemSeqCompArr, nextTagPosition );
               break;

            case NORM_APPEND: /* same sequence as APPEND */
            case NORM_SETLABEL:
            case NORM_SETFONTATTRIBUTES:
            case NORM_SETINPUTMASK:
               childPtr = fpa1_sequenceParse( childCnt, appendSeqCompArr, nextTagPosition );
               break;

            case NORM_CALL: /* same sequence as CALL */
            case NORM_FORK:
               childPtr = fpa1_sequenceParse( childCnt, callSeqCompArr, nextTagPosition );
               break;

            case NORM_CLONE:             /* same sequence as CLONE */
            case NORM_GETAVAILABILITYSTATUS:
            case NORM_GETENTRYPOINT:
            case NORM_GETFILLCOLOUR:
            case NORM_GETFIRSTITEM:
            case NORM_GETFOCUSPOSITION:
            case NORM_GETHIGHLIGHTSTATUS:
            case NORM_GETINTERACTIONSTATUS:
            case NORM_GETLABEL:
            case NORM_GETLASTANCHORFIRED:
            case NORM_GETLINECOLOUR:
            case NORM_GETLINESTYLE:
            case NORM_GETLINEWIDTH:
            case NORM_GETLISTSIZE:
            case NORM_GETOVERWRITEMODE:
            case NORM_GETPORTION:
            case NORM_GETRUNNINGSTATUS:
            case NORM_GETSELECTIONSTATUS:
            case NORM_GETSLIDERVALUE:
            case NORM_GETTEXTCONTENT:
            case NORM_GETTEXTDATA:
            case NORM_GETTOKENPOSITION:
            case NORM_GETVOLUME:
               childPtr = fpa1_sequenceParse( childCnt, cloneSeqCompArr, nextTagPosition );
               break;

            case NORM_DELITEM:  /* same sequence as DELITEM */
            case NORM_GETCOUNTERPOSITION:
            case NORM_GETCOUNTERMAXPOSITION:
            case NORM_PUTBEFORE:
            case NORM_PUTBEHIND:
            case NORM_SETPALETTEREF:
               childPtr = fpa1_sequenceParse( childCnt, delItemSeqCompArr, nextTagPosition );
               break;

            case NORM_DRAWARC: /* same sequence as DRAW ARC */
            case NORM_DRAWSECTOR:
               childPtr = fpa1_sequenceParse( childCnt, drawArcSeqCompArr, nextTagPosition );
               break;

            case NORM_DRAWLINE: /* same sequence as DRAW LINE */
            case NORM_DRAWOVAL:
            case NORM_DRAWRECTANGLE:
               childPtr = fpa1_sequenceParse( childCnt, drawLineSeqCompArr, nextTagPosition );
               break;

            case NORM_DRAWPOLYGON: /* same sequnce as DRAW POLYGON */
            case NORM_DRAWPOLYLINE:
               childPtr = fpa1_sequenceParse( childCnt, drawPolySeqCompArr, nextTagPosition );
               break;

            case NORM_GETBOXSIZE: /* same sequence as GET BOX SIZE */
            case NORM_GETCURSORPOSITION:
            case NORM_GETPOSITION:
            case NORM_GETBITMAPDECODEOFFSET:
            case NORM_GETVIDEODECODEOFFSET:
               childPtr = fpa1_sequenceParse( childCnt, getBoxSizeSeqCompArr, nextTagPosition );
               break;

            case NORM_GETCELLITEM: /* same sequence as GET CELL ITEM */
            case NORM_GETITEMSTATUS:
            case NORM_GETLISTITEM:
               childPtr = fpa1_sequenceParse( childCnt, getCellItemSeqCompArr, nextTagPosition );
               break;

            case NORM_GETENGINESUPPORT:
               childPtr = fpa1_sequenceParse( childCnt, getEngSupSeqCompArr, nextTagPosition );
               break;

            case NORM_OPENCONNECTION:
               childPtr = fpa1_sequenceParse( childCnt, openConnSeqCompArr, nextTagPosition );
               break;

            case NORM_READPERSISTENT: /* same sequence as READ PERSISTENT */
            case NORM_STOREPERSISTENT:
               childPtr = fpa1_sequenceParse( childCnt, readPersistSeqCompArr, nextTagPosition );
               break;

            case NORM_SCALEBITMAP: /* same sequence as SCALEBITMAP */
            case NORM_SCALEVIDEO:
            case NORM_SETBOXSIZE:
            case NORM_SETCURSORPOSITION:
            case NORM_SETPOSITION:
            case NORM_SETBITMAPDECODEOFFSET:
            case NORM_SETVIDEODECODEOFFSET:
               childPtr = fpa1_sequenceParse( childCnt, scaleBitmapSeqCompArr, nextTagPosition );
               break;

            case NORM_SENDEVENT:
               fpa1_GenericDataCount++; /* in case have "event data" optional parameter */
               childPtr = fpa1_sequenceParse( childCnt, sendEventSeqCompArr, nextTagPosition );
               break;

            case NORM_SETCOUNTERTRIGGER:
               childPtr = fpa1_sequenceParse( childCnt, setCntTrigSeqCompArr, nextTagPosition );
               break;

            case NORM_SETCURSORSHAPE:
               childPtr = fpa1_sequenceParse( childCnt, setCurShapeSeqCompArr, nextTagPosition );
               break;

            case NORM_SETDATA:
               childPtr = fpa1_sequenceParse( childCnt, setDataSeqCompArr, nextTagPosition );
               break;

            case NORM_SETFILLCOLOUR:
               childPtr = fpa1_sequenceParse( childCnt, setFillColSeqCompArr, nextTagPosition );
               break;

            case NORM_SETFONTREF:
               childPtr = fpa1_sequenceParse( childCnt, setFontRefSeqCompArr, nextTagPosition );
               break;

            case NORM_SETHIGHLIGHTSTATUS: /* same sequence as SET_IAC_STATUS */
            case NORM_SETINTERACTIONSTATUS:
            case NORM_SETOVERWRITEMODE:
               childPtr = fpa1_sequenceParse( childCnt, setIacStatSeqCompArr, nextTagPosition );
               break;

            case NORM_SETLINECOLOUR: /* same sequence as SET LINE COLOUR */
            case NORM_SETTEXTCOLOUR:
            case NORM_SETBACKGROUNDCOLOUR:
            case NORM_SETDESKTOPCOLOUR:
               childPtr = fpa1_sequenceParse( childCnt, setLineColSeqCompArr, nextTagPosition );
               break;

            case NORM_SETSLIDERPARAMETERS: /* same sequence as SET SLIDER PARAMETERS */
            case NORM_SETCELLPOSITION:
               childPtr = fpa1_sequenceParse( childCnt, setSliderParametersSeqCompArr, nextTagPosition );
               break;

            case NORM_SETSPEED:
               childPtr = fpa1_sequenceParse( childCnt, setSpeedSeqCompArr, nextTagPosition );
               break;

            case NORM_SETTIMER:
               childPtr = fpa1_sequenceParse( childCnt, setTimerSeqCompArr, nextTagPosition );
               break;

            case NORM_SETVARIABLE:
               childPtr = fpa1_sequenceParse( childCnt, setVarSeqCompArr, nextTagPosition );
               break;

            case NORM_TESTVARIABLE:
               childPtr = fpa1_sequenceParse( childCnt, testVarSeqCompArr, nextTagPosition );
               break;

            case NORM_TRANSITIONTO:
               childPtr = fpa1_sequenceParse( childCnt, transToSeqCompArr, nextTagPosition );
               break;

            case NORM_GBOOL:
               childPtr = fpa1_choiceParse(  genBooleanChoiceCompArr );
               break;

            case NORM_NEWCPRIO:
               fpa1_GenericDataCount++;
            /* fallthrough */

            case NORM_GINT:  /* all GenericInteger choices */
            case NORM_NEWCOLIND:
               childPtr = fpa1_choiceParse( genIntChoiceCompArr );
               break;

            case NORM_GOSTRING: /* all GenericOctetstring choices */
            case NORM_NEWABSCOL:
            case NORM_NEWFONTNAME:
               childPtr = fpa1_choiceParse( genOctStrChoiceCompArr );
               break;

            case NORM_GCONTREF:
               childPtr = fpa1_choiceParse( genContRefChoiceCompArr );
               break;
            case NORM_NEWCSIZE:
               fpa1_GenericDataCount++;
               childPtr = fpa1_choiceParse( newContSizeChoiceCompArr );
               break;
            default:
               childPtr = NULL;
         }

         if (childPtr != NULL)
         {
            /* update list */
            listPtr->children = childPtr;
            listPtr->childCount[0] = childCnt[0];
            listPtr->childCount[1] = childCnt[1];
            listPtr->childCount[2] = childCnt[2];
            listPtr->dataTotal = fpa1_GenericDataCount - startGenericDataCnt;

            success = TRUE;
         }
      }
   }

   return success;
} /* fpa1_tagsParse() */