mh5variable.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 "mh5variable.h"
#include "mh5object.h"          /* for actions                */
#include "mh5gate.h"
#include "mh5memory.h"          /* for constructor/destructor */
#include "mh5queue.h"           /* Events           */
#include "mh5application.h"     /* For QuitApp Event by division by zero */
#include "mh5debug.h"
#include "mh5profile.h"
#include "mh5scene.h"

/*
   Debug
 */
#ifdef MH5PRINTOUT
#include <string.h>
#endif
/*---constant definitions for this file--------------------------------------*/


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

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

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

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

static MHEG5Bool MHEG5variableIs(MHEG5Root *variable);
static MHEG5Int MHEG5storeBool(MHEG5Bool b, char *buf, MHEG5Int bufLen);
static MHEG5Int MHEG5storeString(MHEG5String s, char *buf, MHEG5Int bufLen);
static MHEG5Int MHEG5storeInt(MHEG5Int i, char *buf, MHEG5Int bufLen);
static MHEG5Int MHEG5readBool(MHEG5Bool *b, char *buf);
static MHEG5Int MHEG5readInt(MHEG5Int *i, char *buf);

/* Documentation of the SubClasses of Variable */

/*
   Debug
 */
#ifdef MH5PRINTOUT

void MHEG5booleanVariablePrint(MHEG5BooleanVariable *v, char *out)
{
   MHEG5ingredientPrint(&v->ingredient, out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":OrigValue ");
   MHEG5boolPrint(v->originalValue, out);
   MHEG5newLine(out);
/*
    if ( v->value ) {
       MHEG5indent(out);
       MHEG_PRINT(out,"// Value:\ttrue");
       MHEG5newLine(out);
    }
 */
}

void MHEG5integerVariablePrint(MHEG5IntegerVariable *v, char *out)
{
   MHEG5ingredientPrint(&v->ingredient, out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":OrigValue ");
   MHEG5intPrint(v->originalValue, out);
   MHEG5newLine(out);
/*
   if ( v->value ) {
      MHEG5indent(out);
      MHEG_PRINT(out,"// Value:\t");
      MHEG5intPrint(v->value,out);
      MHEG5newLine(out);
   }
 */
}

void MHEG5stringVariablePrint(MHEG5OctetStringVariable *v, char *out)
{
   MHEG5ingredientPrint(&v->ingredient, out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":OrigValue ");
   MHEG5stringPrint(v->originalValue, out);
   MHEG5newLine(out);
/*
   if (v->value.len) {
      MHEG5indent(out);
      MHEG_PRINT(out,"// Value:\t");
      MHEG5stringPrint(v->value,out);
      MHEG5newLine(out);
   }
 */
}

void MHEG5oRefVariablePrint(MHEG5ObjectRefVariable *v, char *out)
{
   MHEG5ingredientPrint(&v->ingredient, out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":OrigValue :ObjectRef");
   if (v->originalValueGid.len)
   {
      MHEG_PRINT(out, " ");
      MHEG5stringPrint(*((MHEG5String *)&v->originalValueGid), out);
   }
   MHEG_PRINT(out, " ");
   MHEG5intPrint(v->originalValueId, out);
   //MHEG_PRINT(out,")");
   MHEG5newLine(out);
/*
   if (v->valueGrp.len) {
      MHEG5indent(out);
      MHEG_PRINT(out,"// Value:\t(");
      MHEG5stringPrint( v->valueGrp, out );
      MHEG_PRINT(out," ");
      MHEG5intPrint(v->valueId,out);
      MHEG_PRINT(out,")");
      MHEG5newLine(out);
   }
 */
}

void MHEG5cRefVariablePrint(MHEG5ContentVariable *v, char *out)
{
   MHEG5ingredientPrint(&v->ingredient, out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":OrigValue ");
   if (v->originalContentData.data)
   {
      MHEG_PRINT(out, ":ContentRef ");
      MHEG5stringPrint(v->originalContentData, out);
      MHEG5newLine(out);
   }
   if (v->contentData.data)
   {
      MHEG5indent(out);
      MHEG_PRINT(out, "// Value:\t");
      MHEG_PRINT(out, ":ContentRef ");
      MHEG5stringPrint(v->contentData, out);
      MHEG5newLine(out);
   }
}

void MHEG5variablePrint(MHEG5Ingredient *variable, char *out)
{
   if (((MHEG5Root *)variable)->clazz == MHEG5BOOLEANVARIABLE)
      MHEG5booleanVariablePrint((MHEG5BooleanVariable *)variable, out);
   if (((MHEG5Root *)variable)->clazz == MHEG5INTEGERVARIABLE)
      MHEG5integerVariablePrint((MHEG5IntegerVariable *)variable, out);
   if (((MHEG5Root *)variable)->clazz == MHEG5OCTETSTRINGVARIABLE)
      MHEG5stringVariablePrint((MHEG5OctetStringVariable *)variable, out);
   if (((MHEG5Root *)variable)->clazz == MHEG5OBJECTREFVARIABLE)
      MHEG5oRefVariablePrint((MHEG5ObjectRefVariable *)variable, out);
   if (((MHEG5Root *)variable)->clazz == MHEG5CONTENTREFVARIABLE)
      MHEG5cRefVariablePrint((MHEG5ContentVariable *)variable, out);
}

#endif


static MHEG5Bool MHEG5variableIs(MHEG5Root *variable)
{
   if ((variable->clazz == MHEG5BOOLEANVARIABLE) ||
       (variable->clazz == MHEG5INTEGERVARIABLE) ||
       (variable->clazz == MHEG5OCTETSTRINGVARIABLE) ||
       (variable->clazz == MHEG5OBJECTREFVARIABLE) ||
       (variable->clazz == MHEG5CONTENTREFVARIABLE))
      return MHEG5TRUE;
   return MHEG5FALSE;
}

/*
     Constructors
 */
void MHEG5booleanVariableInit(MHEG5BooleanVariable *variable)
{
   assert(variable);

   MHEG5ingredientInit(&variable->ingredient);
}

void MHEG5booleanVariablePrepare(MHEG5BooleanVariable *variable)
{
   assert(variable);

   variable->value = variable->originalValue;

   MHEG5ingredientPrepare(&variable->ingredient);
}

void MHEG5booleanVariableFree(MHEG5BooleanVariable *variable)
{
   assert(variable);

   MHEG5ingredientFree(&variable->ingredient);
}

void MHEG5integerVariableInit(MHEG5IntegerVariable *variable)
{
   assert(variable);

   MHEG5ingredientInit(&variable->ingredient);
}

void MHEG5integerVariablePrepare(MHEG5IntegerVariable *variable)
{
   assert(variable);

   variable->value = variable->originalValue;

   MHEG5ingredientPrepare(&variable->ingredient);
}

void MHEG5integerVariableFree(MHEG5IntegerVariable *variable)
{
   assert(variable);

   MHEG5ingredientFree(&variable->ingredient);
}

void MHEG5octetStringVariableInit(MHEG5OctetStringVariable *variable)
{
   assert(variable);

   MHEG5ingredientInit(&variable->ingredient);
}

void MHEG5octetStringVariablePrepare(MHEG5OctetStringVariable *variable)
{
   assert(variable);

   variable->value = MHEG5stringCopy(variable->originalValue);

   MHEG5ingredientPrepare(&variable->ingredient);
}

void MHEG5octetStringVariableFree(MHEG5OctetStringVariable *variable)
{
   assert(variable);

   MHEG5ingredientFree(&variable->ingredient);

   MHEG5stringDestruct(&variable->originalValue);
}

void MHEG5octetStringVariableDestruct(MHEG5OctetStringVariable *variable)
{
   assert(variable);
   MHEG5ingredientDestruct((MHEG5Ingredient *)variable);

   MHEG5stringDestruct(&variable->value);
}

void MHEG5objectRefVariableInit(MHEG5ObjectRefVariable *variable)
{
   assert(variable);

   MHEG5ingredientInit(&variable->ingredient);
}

void MHEG5objRefStoreValue( MHEG5ObjectRefVariable *objRef, MH5GroupRef ref, MHEG5Int id )
{
   MHEG5stringDestruct(&objRef->valueGrp);
   if (ref.len == 0)
   {
      if (ref.ptr.group == (MHEG5Group *)MHEG5getCurrentApplication() ||
          ref.ptr.group == (MHEG5Group *)MHEG5getCurrentScene())
      {
         /*assert( g.value.o.gref.ptr.group->magic == GROUP_MAGIC_NUM );*/
         ref.len = ref.ptr.group->groupName.len;
         ref.ptr.name = ref.ptr.group->groupName.data;
      }
   }
   objRef->valueGrp.len = ref.len;
   objRef->valueGrp.data = STR_DataAlloc( ref.len );
   if (objRef->valueGrp.data != NULL)
   {
      memcpy( objRef->valueGrp.data, ref.ptr.name, ref.len );
   }
   else
   {
      TRACE(TERROR, ("failed to get memory"))
   }
   objRef->valueId = id;
}

void MHEG5objRefStoreString( MHEG5ObjectRefVariable *objRef, MHEG5String ref, MHEG5Int id )
{
   MHEG5stringDestruct(&objRef->valueGrp);
   if (ref.len)
   {
      objRef->valueGrp.len = ref.len;
      objRef->valueGrp.data = STR_DataAlloc( ref.len );
      if (objRef->valueGrp.data != NULL)
      {
         memcpy( objRef->valueGrp.data, ref.data, ref.len );
      }
      else
      {
         TRACE(TERROR, ("failed to get memory"))
         objRef->valueGrp.len = 0;
      }
   }
   else
   {
      objRef->valueGrp.len = 0;
      objRef->valueGrp.data = NULL;
   }
   objRef->valueId = id;
}

void MHEG5objectRefVariablePrepare(MHEG5ObjectRefVariable *variable)
{
   assert(variable);

   MHEG5objRefStoreValue( variable, variable->originalValueGid, variable->originalValueId );

   MHEG5ingredientPrepare(&variable->ingredient);
}

void MHEG5objectRefVariableFree(MHEG5ObjectRefVariable *variable)
{
   assert(variable);

   MHEG5ingredientFree(&variable->ingredient);

   if (variable->originalValueGid.len)
      MHEG5stringDestruct((MHEG5String *)&variable->originalValueGid );
   if (variable->valueGrp.len)
      MHEG5stringDestruct((MHEG5String *)&variable->valueGrp );
}

void MHEG5contentVariableInit(MHEG5ContentVariable *variable)
{
   assert(variable);

   MHEG5ingredientInit(&variable->ingredient);
}

void MHEG5contentVariablePrepare(MHEG5ContentVariable *variable)
{
   assert(variable);

   variable->contentData = MHEG5stringCopy(variable->originalContentData);

   MHEG5ingredientPrepare(&variable->ingredient);
}

void MHEG5contentVariableFree(MHEG5ContentVariable *variable)
{
   assert(variable);

   MHEG5ingredientFree(&variable->ingredient);

   MHEG5stringDestruct(&variable->originalContentData);
}

void MHEG5contentVariableDestruct(MHEG5ContentVariable *variable)
{
   assert(variable);
   MHEG5ingredientDestruct(&variable->ingredient);

   MHEG5stringDestruct(&variable->contentData);
}

/*
     Internal behaviours
 */


void MHEG5variablePrepare(MHEG5Ingredient *variable)
{
   MHEG5ingredientPrepare(variable);
}

void MHEG5variableActivate(MHEG5Ingredient *variable)
{
   assert(variable);
   if (!variable->root.runningStatus)
   {
      if (!variable->root.availabilityStatus)
      {
         switch (variable->root.clazz)
         {
            case MHEG5BOOLEANVARIABLE:
               MHEG5booleanVariablePrepare((MHEG5BooleanVariable *)variable);
               break;
            case MHEG5INTEGERVARIABLE:
               MHEG5integerVariablePrepare((MHEG5IntegerVariable *)variable);
               break;
            case MHEG5OCTETSTRINGVARIABLE:
               MHEG5octetStringVariablePrepare((MHEG5OctetStringVariable *)variable);
               break;
            case MHEG5OBJECTREFVARIABLE:
               MHEG5objectRefVariablePrepare((MHEG5ObjectRefVariable *)variable);
               break;
            case MHEG5CONTENTREFVARIABLE:
               MHEG5contentVariablePrepare((MHEG5ContentVariable *)variable);
               break;
            default:;
         }
      }
      /* Could call the base class activation behaviour, but */
      /* MHEG5ingredientActivate(variable); <- does nothing, so don't bother */

      variable->root.runningStatus = MHEG5TRUE;
      MHEG5sendSync((MHEG5Root *) variable, MHEG5ISRUNNING, 0);
   }
}

void MHEG5variableDeactivate(MHEG5Ingredient *variable)
{
   assert(variable);
   MHEG5ingredientDeactivate(variable);
}

void MHEG5variableDestruct(MHEG5Ingredient *variable)
{
   assert(variable);
   MHEG5ingredientDestruct(variable);
   if (((MHEG5Root *) variable)->clazz == MHEG5OCTETSTRINGVARIABLE)
   {
      MHEG5stringDestruct(&((MHEG5OctetStringVariable *) variable)->value);
   }
   if (((MHEG5Root *) variable)->clazz == MHEG5CONTENTREFVARIABLE)
   {
      MHEG5stringDestruct(&((MHEG5ContentVariable *) variable)->contentData);
   }
}

/*
     Actions
 */
/*
     SetVariable (NewVariableValue)
     Set the Value attribute of the Target object to NewVariableValue.

     Provisions of use:
     The Target object shall be an active object of one of the following classes:
     BooleanVariable, IntegerVariable, OctetStringVariable, ObjectRefVariable or
     ContentRefVariable.
     NewVariableValue shall be set or refer to a value that is not necessarily of the
     same type as the current Value attribute of the target Variable. When
     NewVariableValue and the Target object are of two different types,
     NewVariableValue is automatically converted into the class type of Target.
     NOTE - More details on conversions are given in subclauses relevant to each
     Variable subclasses.
 */
MHEG5ErrorCode MHEG5setVariable(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5GList *thirdParam = 0, *fourthParam = 0;
   MHEG5String cdata;
   MHEG5Bool cref = MHEG5FALSE;
   MHEG5Bool valid = MHEG5FALSE;
   MHEG5Generic g;

   assert(target);

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;

   switch (target->clazz)
   {
      case MHEG5CONTENTREFVARIABLE:
         MHEG5resolveGenericCRef(params, &cdata, &cref, &valid);
         if (!cref)
         {
            TRACE(TERROR, ("Application error: ISO/IEC 13522-5 sec 26.4 - Provision of use!"))
         }
         else
         {
            MHEG5stringDestruct(&((MHEG5ContentVariable *) target)->contentData);
            ((MHEG5ContentVariable *) target)->contentData = MHEG5stringCopy(cdata);
               #ifdef TRACING
            if (mheg_trace_debug & TACTIONS)
            {
               char buff[288];
               strcpy(buff, "   = ");
               MHEG5stringTrace(((MHEG5ContentVariable *) target)->contentData, buff, 0, 120 );
               DBG_PRINTF(buff);
            }
               #endif
         }
         break;

      case MHEG5BOOLEANVARIABLE:
         (void) MHEG5resolveGenericGeneric(params, &g);
         if (g.type == MHEG5BOOL)
         {
            ((MHEG5BooleanVariable *) target)->value = g.value.b;
         }
         break;

      case MHEG5INTEGERVARIABLE:
         (void) MHEG5resolveGenericGeneric(params, &g);
         if (g.type == MHEG5INT)
         {
            ((MHEG5IntegerVariable *) target)->value = g.value.i;
         }
         if (g.type == MHEG5OCTETSTRING)
         {
            ((MHEG5IntegerVariable *) target)->value = MHEG5strToInt(g.value.s);
         }
            #ifdef TRACING
         if (mheg_trace_debug & TACTIONS)
         {
            DBG_PRINTF("   = %ld", ((MHEG5IntegerVariable *) target)->value);
         }
            #endif
         break;

      case MHEG5OCTETSTRINGVARIABLE:
         (void) MHEG5resolveGenericGeneric(params, &g);
         switch (g.type )
         {
            case MHEG5INT:
               cdata = MHEG5intToStr(g.value.i);
               break;
            case MHEG5OCTETSTRING:
               cdata = MHEG5stringCopy(g.value.s);
               break;
            default:
               cdata.len = 0;
               cdata.data= NULL;
         }
         MHEG5stringDestruct(&((MHEG5OctetStringVariable *) target)->value);
         ((MHEG5OctetStringVariable *) target)->value = cdata;
         #ifdef TRACING
         if (mheg_trace_debug & TACTIONS)
         {
            char buff[288];
            strcpy(buff, "   <- ");
            MHEG5stringTrace(((MHEG5OctetStringVariable *) target)->value, buff, 0, 120 );
            DBG_PRINTF(buff);
            DBG_PRINTF("  len: %ld", ((MHEG5OctetStringVariable *) target)->value.len);
         }
            #endif
         break;

      case MHEG5OBJECTREFVARIABLE:
      {
         MHEG5ObjectRefVariable *objRef = (MHEG5ObjectRefVariable *)target;
         thirdParam = MHEG5resolveGenericGeneric(params, &g);
         if (g.type == MHEG5OBJECTREF)
         {
            MHEG5objRefStoreValue( objRef, g.value.o.gref, g.value.o.id );
         }
         else
         {
            if (thirdParam)
            {
               fourthParam = MHEG5resolveGenericGeneric(thirdParam, &g);
            }
            if (g.type == MHEG5OCTETSTRING)
            {
               MHEG5objRefStoreString( objRef, g.value.s, 0 );
               if (fourthParam)
               {
                  MHEG5resolveGenericGeneric(fourthParam, &g);
                  if (g.type == MHEG5INT)
                  {
                     objRef->valueId = g.value.i;
                  }
               }
            }
         }
      }
      break;
      default:
         ERROR_PRINT(("ERROR: MHEG5setVariable: Invalid object class for setting variable value\n"));
         return MHEG5ERR_WRONGTARGET;
   }
   return MHEG5ERR_NOERROR;
}

/*
     TestVariable (Target, Operator, ComparisonValue)
     Execute the following sequence of actions:
     1. Compare the Value of the variable to the ComparisonValue parameter. The
     Variable value is the first operand, the ComparisonValue parameter is the
     second operand of the comparison.
     2. Generate the corresponding TestEvent.
     source: Target of TestVariable,
     Associated data: Boolean.
     Provisions of use:
     The Target object shall be an active object of one of the following classes:
     BooleanVariable, IntegerVariable, OctetStringVariable, ObjectRefVariable or
     ContentRefVariable.
     The ComparisonValue shall be of corresponding type (GenericBoolean,
     GenericInteger, GenericOctetString, GenericObjectReference and
     GenericContentReference respectively). No implicit type conversion is allowed.
     When values are Integer, the Operator shall be an integer in the range 1 to 6
     with the following meaning:
     1 means equal, 2 not equal,
     3 strictly less than, 4 less than or equal to,
     5 strictly greater than, 6 greater than or equal to.
     When values are Boolean, OctetString, ObjectReference or ContentReference,
     the Operator shall be an integer in the range 1 to 2 with the following meaning:
     1 means equal, 2 not equal.
 */
MHEG5ErrorCode MHEG5testVariable(MHEG5Root *target, MHEG5GList *params)
{
    #ifdef TRACING
   static const char opstr[6][3] = {"==", "!=", "< ", "<=", "> ", ">="};
    #endif
   MHEG5GList *thirdParam = 0;
   MHEG5String cdata;
   MHEG5Int csize = 0;
   MHEG5Bool cref = MHEG5FALSE;
   MHEG5Bool eq = MHEG5FALSE;
   int eventData;
   MHEG5Int op = 0;
   MHEG5Bool invalidString;

   assert(target);

   if (!MHEG5variableIs(target))
   {
      return MHEG5ERR_WRONGTARGET;
   }

   /* Parse the operator parameter */
   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   thirdParam = MHEG5resolveGenericInteger(params, &op);
   if (!thirdParam)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }

   if ((op < 1) || (op > (target->clazz == MHEG5INTEGERVARIABLE ? 6 : 2)))
   {
      ERROR_PRINT(("MHEG5testVariable invalid Operator %ld\n", op));
      return MHEG5ERR_WRONGPARAM;
   }

   /* Set the default TestEvent data */
   eventData = MHEG5FALSE;

   //TRACE(TEVNTS,(" TestVar %d op=%ld",target->clazz,op))

   switch (target->clazz)
   {
      case MHEG5CONTENTREFVARIABLE:
         /* Parse the ComparisonValue parameter */
         MHEG5resolveGenericCRef(thirdParam, &cdata, &cref, &invalidString);
         if (op == 1 && cref &&
             MHEG5stringEqual(&((MHEG5ContentVariable *) target)->contentData, &cdata))
         {
            eventData = MHEG5TRUE;
         }
         else if (op == 2 && !MHEG5stringEqual(&((MHEG5ContentVariable *) target)->contentData, &cdata))
         {
            eventData = MHEG5TRUE;
         }
         break;
      case MHEG5INTEGERVARIABLE:
         /* Parse the ComparisonValue parameter */
         MHEG5resolveGenericInteger(thirdParam, &csize);
         switch (op)
         {
            case 1:
               if (((MHEG5IntegerVariable *) target)->value == csize)
               {
                  eventData = MHEG5TRUE;
               }
               break;
            case 2:
               if (((MHEG5IntegerVariable *) target)->value != csize)
               {
                  eventData = MHEG5TRUE;
               }
               break;
            case 3:
               if (((MHEG5IntegerVariable *) target)->value < csize)
               {
                  eventData = MHEG5TRUE;
               }
               break;
            case 4:
               if (((MHEG5IntegerVariable *) target)->value <= csize)
               {
                  eventData = MHEG5TRUE;
               }
               break;
            case 5:
               if (((MHEG5IntegerVariable *) target)->value > csize)
               {
                  eventData = MHEG5TRUE;
               }
               break;
            case 6:
               if (((MHEG5IntegerVariable *) target)->value >= csize)
               {
                  eventData = MHEG5TRUE;
               }
               break;
         }
            #ifdef TRACING
         if (mheg_trace_debug & TACTIONS)
         {
            DBG_PRINTF("   %ld %s %ld", ((MHEG5IntegerVariable *) target)->value, opstr[op - 1], csize);
         }
            #endif
         break;
      case MHEG5BOOLEANVARIABLE:
         /* Parse the ComparisonValue parameter */
         MHEG5resolveGenericBoolean(thirdParam, &cref);
         if (((op == 1) && (((MHEG5BooleanVariable *) target)->value == cref)) ||
             ((op == 2) && (((MHEG5BooleanVariable *) target)->value != cref)))
         {
            eventData = MHEG5TRUE;
         }
         break;
      case MHEG5OCTETSTRINGVARIABLE:
         /* Parse the ComparisonValue parameter */
         MHEG5resolveGenericOctetString(thirdParam, &cdata, &invalidString);
         if (invalidString)
         {
            /* Parameter was not an octet string */
            return MHEG5ERR_WRONGPARAM;
         }

         if (((op == 1) && MHEG5stringEqual(&((MHEG5OctetStringVariable *) target)->value, &cdata)) ||
             ((op == 2) && !MHEG5stringEqual(&((MHEG5OctetStringVariable *) target)->value, &cdata)))
         {
            eventData = MHEG5TRUE;
         }
         break;
      case MHEG5OBJECTREFVARIABLE:
      {
         MHEG5ObjectRefVariable *objref = (MHEG5ObjectRefVariable *) target;
         MH5GroupRef gref;
         MH5GroupRef vRef;
         MHEG5Int id;

         /* Parse the ComparisonValue parameter */
         MHEG5resolveGenericORefProper(thirdParam, &gref, &id);

         vRef.len = objref->valueGrp.len;
         vRef.ptr.name = objref->valueGrp.data;

         /* Find out whether the variable is equal to the comparison value */

         eq = (objref->valueId == id) && MHEG5sameGroups( vRef, gref );

         /* Check eq and operation to determine TestEvent result */
         if ((eq && (op == 1)) || (!eq && (op == 2)))
         {
            eventData = MHEG5TRUE;
         }
         break;
      }
      default:
         ERROR_PRINT(("MHEG5testVariable internal error - target->clazz = %d\n", target->clazz));
   }

   MHEG5sendSync( target, MHEG5TESTEVENT, eventData );

   return MHEG5ERR_NOERROR;
}

/*
     IntegerVariable Actions
 */
/*
     Add (Value)
     Add Target Variable to Value. Target variable is the first operand of the infix
     operation. Result is stored in Target Variable.

     Provision of use:
     The Target object shall be an active IntegerVariable object.
 */
MHEG5ErrorCode MHEG5add(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int value = 0;

   assert(target);

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if (target->clazz != MHEG5INTEGERVARIABLE)
      return MHEG5ERR_WRONGTARGET;
   MHEG5resolveGenericInteger(params, &value);
   #ifdef TRACING
   if (mheg_trace_debug & TACTIONS)
   {
      DBG_PRINTF("   %ld += %ld", ((MHEG5IntegerVariable *) target)->value, value);
   }
   #endif
   ((MHEG5IntegerVariable *) target)->value += value;
   return MHEG5ERR_NOERROR;
}

/*
     Subtract (Value)
     Subtract Value from Target Variable. Target variable is the first operand of the infix
     operation. Result is stored in Target Variable.

     Provision of use:
     The Target object shall be an active IntegerVariable object.
 */
MHEG5ErrorCode MHEG5subtract(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int value = 0;

   assert(target);

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if (target->clazz != MHEG5INTEGERVARIABLE)
      return MHEG5ERR_WRONGTARGET;
   MHEG5resolveGenericInteger(params, &value);
   #ifdef TRACING
   if (mheg_trace_debug & TACTIONS)
   {
      DBG_PRINTF("   %ld -= %ld", ((MHEG5IntegerVariable *) target)->value, value);
   }
   #endif
   ((MHEG5IntegerVariable *) target)->value -= value;
   return MHEG5ERR_NOERROR;
}

/*
     Multiply (Value)
     Multiplies Target Variable by Value. Target variable is the first operand of the infix
     operation. Result is stored in Target Variable.

     Provision of use:
     The Target object shall be an active IntegerVariable object.
 */
MHEG5ErrorCode MHEG5multiply(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int value = 0;
   MHEG5IntegerVariable *i;

   assert(target);

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if (target->clazz != MHEG5INTEGERVARIABLE)
      return MHEG5ERR_WRONGTARGET;
   MHEG5resolveGenericInteger(params, &value);
   i = (MHEG5IntegerVariable *) target;
   i->value *= value;
   return MHEG5ERR_NOERROR;
}

/*
     Divide (Value)
     Divides Target Variable by Value. Target variable is the first operand of the infix
     operation. Result is stored in Target Variable. When the result is not an integer
     value, rounding is made towards 0.

     Provision of use:
     The Target object shall be an active IntegerVariable object.
 */
MHEG5ErrorCode MHEG5divide(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int value = 0;

   assert(target);

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if (target->clazz != MHEG5INTEGERVARIABLE)
      return MHEG5ERR_WRONGTARGET;
   MHEG5resolveGenericInteger(params, &value);
   if (value != 0)
      ((MHEG5IntegerVariable *) target)->value /= value;
   else
   {
      /* What should we do here? */
#ifdef MHEG5LOG
      MHEG5LogPrintf(MHEG5WARNING, "Division by zero\n");
#endif
   }
   return MHEG5ERR_NOERROR;
}

/*
     Modulo (Value)
     Returns the remainder modulo Value of Target - as defined by usual integer
     arithmetic rules, that is to say that for any integers a and b the following equality is
     satisfied:
     (a DIV b) *b + (a MOD b) = a.
     Target variable is the first operand of the infix operation. Result is stored in Target
     Variable.

     Provision of use:
     The Target object shall be an active IntegerVariable object.
 */
MHEG5ErrorCode MHEG5modulo(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5Int value = 0;

   assert(target);

   if (!params)
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   if (target->clazz != MHEG5INTEGERVARIABLE)
      return MHEG5ERR_WRONGTARGET;
   MHEG5resolveGenericInteger(params, &value);
   if (value != 0)
      ((MHEG5IntegerVariable *) target)->value %= value;
   else
   {
      /* What should we do here? */
#ifdef MHEG5LOG
      MHEG5LogPrintf(MHEG5WARNING, "Modulo division by zero\n");
#endif
   }
   return MHEG5ERR_NOERROR;
}

/*
     OctetStringVariable Actions
 */
/*
     Append (AppendValue)
     Appends AppendValue to Target Variable. Target variable is the first operand of the
     infix operation. Result is stored in Target Variable.

     Provision of use:
     The Target object shall be an active OctetStringVariable object.
 */
MHEG5ErrorCode MHEG5append(MHEG5Root *target, MHEG5GList *params)
{
   MHEG5String value, buf;
   MHEG5OctetStringVariable *os;
   MHEG5Bool invalidString;

   assert(target);

   if (!params)
   {
      return MHEG5ERR_WRONGNUMBEROFPARAMS;
   }
   if (target->clazz != MHEG5OCTETSTRINGVARIABLE)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   MHEG5resolveGenericOctetString(params, &value, &invalidString);
   if (invalidString)
   {
      /* Parameter was not an octet string */
      return MHEG5ERR_WRONGPARAM;
   }
   if (!value.len)
   {
      /* String to append is empty - nothing to do */
      return MHEG5ERR_NOERROR;
   }

   os = (MHEG5OctetStringVariable *) target;
   #ifdef TRACING
   if (mheg_trace_debug & TACTIONS)
   {
      DBG_PRINTF(" lens: %ld += %ld", os->value.len, value.len);
   }
   #endif
   buf = MHEG5stringCat(os->value, value);
   if (buf.len > 0)
   {
      MHEG5stringDestruct(&os->value);
      os->value = buf;
      #ifdef TRACING
      if (mheg_trace_debug & TACTIONS)
      {
         char buff[288];
         strcpy(buff, "  rst: ");
         MHEG5stringTrace( os->value, buff, 0, 120 );
         DBG_PRINTF(buff);
      }
      #endif
   }

   return MHEG5ERR_NOERROR;
}

/*
   Store the value of the Variable in the Buffer and Return number of Bytes used.
   Return -1 for failure
 */
static MHEG5Int MHEG5storeBool(MHEG5Bool b, char *buf, MHEG5Int bufLen)
{
   if (bufLen < 1)
      return -1;
   if (b)
      buf[0] = 'T';
   else
      buf[0] = 'F';
   return 1;
}

static MHEG5Int MHEG5storeString(MHEG5String s, char *buf, MHEG5Int bufLen)
{
   if (bufLen < (MHEG5Int)sizeof(s.len))
      return -1;
   memcpy(buf, &s.len, sizeof(s.len));
   if (s.len + (MHEG5Int)sizeof(s.len) > bufLen)
      return -1;
   if (s.len > 0)
      memcpy(&buf[sizeof(s.len)], s.data, s.len);
   return s.len + sizeof(s.len);
}

static MHEG5Int MHEG5storeInt(MHEG5Int i, char *buf, MHEG5Int bufLen)
{
   if (bufLen < (MHEG5Int)sizeof(i))
      return -1;
   memcpy(buf, &i, sizeof(i));
   return sizeof(i);
}

static MHEG5Int MHEG5readBool(MHEG5Bool *b, char *buf)
{
   if (buf[0] == 'T')
      *b = MHEG5TRUE;
   else
      *b = MHEG5FALSE;
   return 1;
}

static MHEG5Int MHEG5readString(MHEG5String *s, char *buf, MHEG5Int max_size)
{
   memcpy(&s->len, buf, sizeof(s->len));

   /* Check that the length looks sensible */
   if (s->len > max_size)
   {
      s->len = 0;
   }

   if (s->len == 0)
   {
      return sizeof(s->len);
   }

   s->data = STR_DataAlloc( s->len );
   memcpy(s->data, &buf[sizeof(s->len)], s->len);
   return s->len + sizeof(s->len);
}

static MHEG5Int MHEG5readInt(MHEG5Int *i, char *buf)
{
   memcpy(i, buf, sizeof(*i));
   return sizeof(*i);
}

MHEG5Int MHEG5variableStore(MHEG5Ingredient *v, void *buf, MHEG5Int bufLen)
{
   MHEG5Int len = 0, rc;

   if (!v)
      return -1;
   if (!buf)
      return -1;
   if (!bufLen)
      return -1;
   switch (((MHEG5Root *)v)->clazz)
   {
      case MHEG5CONTENTREFVARIABLE:
/*          local[len++]='C';
 */
         rc = MHEG5storeString(((MHEG5ContentVariable *) v)->contentData, buf, bufLen);
         if (rc < 0)
            return -1;
         len = rc;
         break;
      case MHEG5INTEGERVARIABLE:
/*          local[len++]='I';
 */
         rc = MHEG5storeInt(((MHEG5IntegerVariable *) v)->value, buf, bufLen);
         if (rc < 0)
            return -1;
         len = rc;
         break;
      case MHEG5BOOLEANVARIABLE:
/*          local[len++]='B';
 */
         rc = MHEG5storeBool(((MHEG5BooleanVariable *) v)->value, buf, bufLen);
         if (rc < 0)
            return -1;
         len = rc;
         break;
      case MHEG5OCTETSTRINGVARIABLE:
/*          local[len++]='S';
 */
         rc = MHEG5storeString(((MHEG5OctetStringVariable *) v)->value, buf, bufLen);
         if (rc < 0)
            return -1;
         len = rc;
         break;
      case MHEG5OBJECTREFVARIABLE:
/*          local[len++]='O';
 */
         rc = MHEG5storeInt(((MHEG5ObjectRefVariable *) v)->valueId, buf, bufLen);
         if (rc < 0)
            return -1;
         len = rc;
         rc = MHEG5storeString(((MHEG5ObjectRefVariable *) v)->valueGrp, (char *)buf + len, bufLen - len);
         if (rc < 0)
            return -1;
         len += rc;
         break;
      default:
         return -1;
   }
   return len;
}

/*
   Set the Variable to the Buffer values and Return the Number of Bytes read.
   Return -1 for failure
 */
MHEG5Int MHEG5variableRead(MHEG5Ingredient *v, char *buf, MHEG5Int max_size)
{
   MHEG5Int pos = 0, rc, id;
   if (!v)
   {
      return -1;
   }

   if (!buf)
   {
      return -1;
   }

   switch (((MHEG5Root *)v)->clazz)
   {
      case MHEG5CONTENTREFVARIABLE:
         MHEG5stringDestruct( &((MHEG5ContentVariable *) v)->contentData );
         rc = MHEG5readString(&((MHEG5ContentVariable *) v)->contentData, &buf[pos], max_size);
         pos += rc;
         break;

      case MHEG5INTEGERVARIABLE:
         rc = MHEG5readInt(&((MHEG5IntegerVariable *) v)->value, &buf[pos]);
         pos += rc;
         break;

      case MHEG5BOOLEANVARIABLE:
         rc = MHEG5readBool(&((MHEG5BooleanVariable *) v)->value, &buf[pos]);
         pos += rc;
         break;

      case MHEG5OCTETSTRINGVARIABLE:
         MHEG5stringDestruct( &((MHEG5OctetStringVariable *) v)->value );
         rc = MHEG5readString(&((MHEG5OctetStringVariable *) v)->value, &buf[pos], max_size);
         pos += rc;
         break;

      case MHEG5OBJECTREFVARIABLE:
      {
         MHEG5ObjectRefVariable *objRef = (MHEG5ObjectRefVariable *)v;

         rc = MHEG5readInt( &id, &buf[pos] );
         pos += rc;
         rc = MHEG5readString(&objRef->valueGrp, &buf[pos], max_size);
         objRef->valueId = id;
         pos += rc;
      }
      break;

      default:
         return -1;
   }
   return pos;
}