/src/gpac/src/bifs/script_enc.c

Source
/*
 *      GPAC - Multimedia Framework C SDK
 *
 *      Authors: Jean Le Feuvre
 *      Copyright (c) Telecom ParisTech 2000-2023
 *          All rights reserved
 *
 *  This file is part of GPAC / BIFS codec sub-project
 *
 *  GPAC is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  GPAC is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/*
    script encoder is IM1 version
*/

#include "script.h"

#include <gpac/internal/scenegraph_dev.h>

#if !defined(GPAC_DISABLE_BIFS) && !defined(GPAC_DISABLE_BIFS_ENC) && defined(GPAC_HAS_QJS)

typedef struct
{
  GF_Node *script;
  GF_BifsEncoder *codec;
  GF_BitStream *bs;
  GF_List *identifiers;
  GF_Err err;

  char *cur_buf;
  char token[500];
  u32 token_code;

  u32 cur_line;

  Bool emul;

  char expr_toks[500];
  u32 expr_toks_len;
  GF_List *id_buf;
} ScriptEnc;


#define SFE_WRITE_INT(sc_enc, val, nbBits, str1, str2)  \
    if (!sc_enc->emul) GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, val, nbBits, str1, str2);  \


static GF_Err EncScriptFields(ScriptEnc *sc_enc)
{
  u32 nbFields, nbBits, eType, nbBitsProto, i;
  Bool use_list;
  GF_Err e;
  GF_FieldInfo info;

  nbFields = gf_node_get_num_fields_in_mode(sc_enc->script, GF_SG_FIELD_CODING_ALL) - 3;
  use_list = GF_TRUE;
  nbBits = gf_get_bit_size(nbFields);
  if (nbFields+1 > 4 + gf_get_bit_size(nbFields)) use_list = GF_FALSE;
  if (!nbFields) {
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "Script::isList", NULL);
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "end", NULL);
    return GF_OK;
  }
  GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, use_list ? 1 : 0, 1, "Script::isList", NULL);
  if (!use_list) {
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, nbBits, 4, "nbBits", NULL);
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, nbFields, nbBits, "count", NULL);
  }

  nbBitsProto = 0;
  if (sc_enc->codec->encoding_proto) nbBitsProto = gf_get_bit_size(gf_sg_proto_get_field_count(sc_enc->codec->encoding_proto) - 1);

  for (i=0; i<nbFields; i++) {
    if (use_list) GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 0, 1, "end", NULL);

    gf_node_get_field(sc_enc->script, i+3, &info);
    switch (info.eventType) {
    case GF_SG_EVENT_IN:
      eType = GF_SG_SCRIPT_TYPE_EVENT_IN;
      break;
    case GF_SG_EVENT_OUT:
      eType = GF_SG_SCRIPT_TYPE_EVENT_OUT;
      break;
    default:
      eType = GF_SG_SCRIPT_TYPE_FIELD;
      break;
    }
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, eType, 2, "eventType", NULL);
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, info.fieldType, 6, "fieldType", NULL);
    gf_bifs_enc_name(sc_enc->codec, sc_enc->bs, (char *) info.name);
    /*this is an identifier for script*/
    gf_list_add(sc_enc->identifiers, gf_strdup(info.name));

    if (sc_enc->codec->encoding_proto) {
      GF_Route *isedField = gf_bifs_enc_is_field_ised(sc_enc->codec, sc_enc->script, i+3);
      if (isedField) {
        GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "isedField", NULL);

        if (isedField->ToNode == sc_enc->script) {
          GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, isedField->FromField.fieldIndex, nbBitsProto, "protoField", NULL);
        } else {
          GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, isedField->ToField.fieldIndex, nbBitsProto, "protoField", NULL);
        }
        continue;
      }
      GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 0, 1, "isedField", NULL);
    }
    /*default value*/
    if (eType == GF_SG_SCRIPT_TYPE_FIELD) {
      GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, (info.far_ptr) ? 1 : 0, 1, "hasInitialValue", NULL);
      if (info.far_ptr) {
        e = gf_bifs_enc_field(sc_enc->codec, sc_enc->bs, sc_enc->script, &info);
        if (e) return e;
      }
    }
  }
  if (use_list) GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "end", NULL);
  return GF_OK;
}



enum
{
  TOK_FUNCTION,
  TOK_IF,
  TOK_ELSE,
  TOK_FOR,
  TOK_WHILE,
  TOK_RETURN,
  TOK_BREAK,
  TOK_CONTINUE,
  TOK_NEW,
  TOK_SWITCH,
  TOK_CASE,
  TOK_DEFAULT,
  TOK_VAR,
  NUMBER_OF_KEYWORD,
  TOK_LEFT_BRACE = NUMBER_OF_KEYWORD,
  TOK_RIGHT_BRACE,
  TOK_LEFT_CURVE,
  TOK_RIGHT_CURVE,
  TOK_LEFT_BRACKET,
  TOK_RIGHT_BRACKET,
  TOK_PERIOD,
  TOK_NOT,
  TOK_ONESCOMP,
  TOK_NEGATIVE,
  TOK_INCREMENT,
  TOK_DECREMENT,
  TOK_MULTIPLY,
  TOK_DIVIDE,
  TOK_MOD,
  TOK_PLUS,
  TOK_MINUS,
  TOK_LSHIFT,
  TOK_RSHIFT,
  TOK_RSHIFTFILL,
  TOK_LT,
  TOK_LE,
  TOK_GT,
  TOK_GE,
  TOK_EQ,
  TOK_NE,
  TOK_AND,
  TOK_XOR,
  TOK_OR,
  TOK_LAND,
  TOK_LOR,
  TOK_CONDTEST,
  TOK_ASSIGN,
  TOK_PLUSEQ,
  TOK_MINUSEQ,
  TOK_MULTIPLYEQ,
  TOK_DIVIDEEQ,
  TOK_MODEQ,
  TOK_LSHIFTEQ,
  TOK_RSHIFTEQ,
  TOK_RSHIFTFILLEQ,
  TOK_ANDEQ,
  TOK_XOREQ,
  TOK_OREQ,
  TOK_COMMA,
  TOK_SEMICOLON,
  TOK_CONDSEP,
  TOK_IDENTIFIER,
  TOK_STRING,
  TOK_NUMBER,
  TOK_EOF,
  TOK_BOOLEAN
};

const char *tok_names[] =
{
  "function",
  "if",
  "else",
  "for",
  "while",
  "return",
  "break",
  "continue",
  "new",
  "switch",
  "case",
  "default",
  "var",
  "{",
  "}",
  "(",
  ")",
  "[",
  "]",
  ".",
  "!",
  "~",
  "-",
  "++",
  "--",
  "*",
  "/",
  "%",
  "+",
  "-",
  "<<",
  ">>",
  ">>>",
  "<",
  "<=",
  ">",
  ">=",
  "==",
  "!=",
  "&",
  "^",
  "|",
  "&&",
  "||",
  "?",
  "=",
  "+=",
  "-=",
  "*=",
  "/=",
  "%=",
  "<<=",
  ">>=",
  ">>>=",
  "&=",
  "^=",
  "|=",
  ",",
  ";",
  ":",
  "identifier",
  "string",
  "number",
  "boolean",
  "end of script"
};

const char* sc_keywords [] =
{
  "function",
  "if",
  "else",
  "for",
  "while",
  "return",
  "break",
  "continue",
  "new",
  "switch",
  "case",
  "default",
  "var"
};

Bool SFE_GetNumber(ScriptEnc *sc_enc)
{
  u32 i = 0;
  Bool exp = GF_FALSE;
  while ( isdigit(sc_enc->cur_buf[i])
          || (toupper(sc_enc->cur_buf[i])=='X')
          || ((toupper(sc_enc->cur_buf[i]) >='A') && (toupper(sc_enc->cur_buf[i])<='F'))
          || (sc_enc->cur_buf[i]=='.')
          || (tolower(sc_enc->cur_buf[i])=='e')
          || (exp && (sc_enc->cur_buf[i] == '-'))
        ) {
    sc_enc->token[i] = sc_enc->cur_buf[i];
    if (tolower(sc_enc->cur_buf[i])=='e') exp = GF_TRUE;
    i++;
    if (!sc_enc->cur_buf[i]) {
      GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: Invalid number syntax (%s)\n", sc_enc->cur_buf));
      sc_enc->err = GF_BAD_PARAM;
      return GF_FALSE;
    }
  }
  sc_enc->token[i] = 0;
  sc_enc->cur_buf += i;
  sc_enc->token_code = TOK_NUMBER;
  return GF_TRUE;
}

Bool SFE_NextToken(ScriptEnc *sc_enc)
{
  u32 i;
  if (sc_enc->err) return GF_FALSE;
  while (strchr(" \t\r\n", sc_enc->cur_buf[0])) {
    if (sc_enc->cur_buf[0]=='\n') sc_enc->cur_line ++;
    sc_enc->cur_buf++;
  }
  if ((sc_enc->cur_buf[0] == '/') && (sc_enc->cur_buf[1] == '*')) {
    sc_enc->cur_buf += 2;
    while ((sc_enc->cur_buf[0] != '*') || (sc_enc->cur_buf[1] != '/')) {
      sc_enc->cur_buf++;
      if (!sc_enc->cur_buf[0] || !sc_enc->cur_buf[1]) {
        GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: cannot find closing comment */\n"));
        sc_enc->err = GF_BAD_PARAM;
        return GF_FALSE;
      }
    }
    sc_enc->cur_buf+=2;
    return SFE_NextToken(sc_enc);
  }
  i = 0;
  /*get a name*/
  if (isalpha(sc_enc->cur_buf[i]) || (sc_enc->cur_buf[i]=='_')) {
    while (isalnum(sc_enc->cur_buf[i]) || (sc_enc->cur_buf[i]=='_')) {
      sc_enc->token[i] = sc_enc->cur_buf[i];
      i++;
    }
    sc_enc->token[i] = 0;
    sc_enc->cur_buf += i;
    sc_enc->token_code = TOK_IDENTIFIER;
    /*check keyword*/
    for (i=0; i<NUMBER_OF_KEYWORD; i++) {
      if (!strcmp(sc_enc->token, sc_keywords[i])) {
        sc_enc->token_code = i;
        return GF_TRUE;
      }
    }
    if (!stricmp(sc_enc->token, "TRUE") || !stricmp(sc_enc->token, "FALSE") ) {
      sc_enc->token_code = TOK_BOOLEAN;
    }
    return GF_TRUE;
  }
  /*get a number*/
  if (isdigit(sc_enc->cur_buf[i])) return SFE_GetNumber(sc_enc);
  /*get a string*/
  if ((sc_enc->cur_buf[i]=='\'') || (sc_enc->cur_buf[i]=='\"')
          || ((sc_enc->cur_buf[i]=='\\') && (sc_enc->cur_buf[i+1]=='\"'))
     ) {
    char end;
    Bool skip_last = GF_FALSE;
    end = sc_enc->cur_buf[i];
    if (sc_enc->cur_buf[i]=='\\') {
      skip_last = GF_TRUE;
      sc_enc->cur_buf++;
    }
    while (sc_enc->cur_buf[i+1] != end) {
      sc_enc->token[i] = sc_enc->cur_buf[i+1];
      i++;
    }
    sc_enc->token[i] = 0;
    sc_enc->cur_buf += i+2;
    if (skip_last) sc_enc->cur_buf++;
    sc_enc->token_code = TOK_STRING;
    return GF_TRUE;
  }
  /*all other codes*/
  switch (sc_enc->cur_buf[i]) {
  case '.':
    if (isdigit(sc_enc->cur_buf[i+1])) {
      SFE_GetNumber(sc_enc);
      return GF_TRUE;
    } else {
      sc_enc->token_code = TOK_PERIOD;
    }
    break;
  case '!':
    if (sc_enc->cur_buf[i+1] == '=') {
      sc_enc->token_code = TOK_NE;
      sc_enc->cur_buf ++;
    } else {
      sc_enc->token_code = TOK_NOT;
    }
    break;
  case '=':
    if (sc_enc->cur_buf[i+1]=='=') {
      if (sc_enc->cur_buf[i+2]=='=') {
        GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[BIFSEnc] JavaScript token '===' not supported by standard\n"));
        sc_enc->err = GF_NOT_SUPPORTED;
        return GF_FALSE;
      }
      sc_enc->token_code = TOK_EQ;
      sc_enc->cur_buf ++;
    } else {
      sc_enc->token_code = TOK_ASSIGN;
    }
    break;
  case '+':
    if(sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_PLUSEQ;
      sc_enc->cur_buf ++;
    } else if(sc_enc->cur_buf[i+1]=='+') {
      sc_enc->token_code = TOK_INCREMENT;
      sc_enc->cur_buf++;
    } else {
      sc_enc->token_code = TOK_PLUS;
    }
    break;
  case '-':
    if(sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_MINUSEQ;
      sc_enc->cur_buf++;
    } else if(sc_enc->cur_buf[i+1] == '-') {
      sc_enc->token_code = TOK_DECREMENT;
      sc_enc->cur_buf++;
    } else {
      sc_enc->token_code = TOK_MINUS;
    }
    break;
  case '*':
    if(sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_MULTIPLYEQ;
      sc_enc->cur_buf++;
    } else {
      sc_enc->token_code = TOK_MULTIPLY;
    }
    break;
  case '/':
    if(sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_DIVIDEEQ;
      sc_enc->cur_buf++;
    } else {
      sc_enc->token_code = TOK_DIVIDE;
    }
    break;
  case '%':
    if(sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_MODEQ;
      sc_enc->cur_buf++;
    } else {
      sc_enc->token_code = TOK_MOD;
    }
    break;
  case '&':
    if(sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_ANDEQ;
      sc_enc->cur_buf++;
    } else if(sc_enc->cur_buf[i+1]=='&') {
      sc_enc->token_code = TOK_LAND;
      sc_enc->cur_buf++;
    } else {
      sc_enc->token_code = TOK_AND;
    }
    break;
  case '|':
    if(sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_OREQ;
      sc_enc->cur_buf++;
    } else if(sc_enc->cur_buf[i+1]=='|') {
      sc_enc->token_code = TOK_LOR;
      sc_enc->cur_buf++;
    } else {
      sc_enc->token_code = TOK_OR;
    }
    break;
  case '^':
    if(sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_XOREQ;
      sc_enc->cur_buf++;
    } else {
      sc_enc->token_code = TOK_XOR;
    }
    break;
  case '<':
    if (sc_enc->cur_buf[i+1]=='<') {
      if(sc_enc->cur_buf[i+2]=='=') {
        sc_enc->token_code = TOK_LSHIFTEQ;
        sc_enc->cur_buf += 1;
      } else {
        sc_enc->token_code = TOK_LSHIFT;
      }
      sc_enc->cur_buf += 1;
    } else if(sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_LE;
      sc_enc->cur_buf ++;
    } else {
      sc_enc->token_code = TOK_LT;
    }
    break;
  case '>':
    if (sc_enc->cur_buf[i+1]=='>') {
      if (sc_enc->cur_buf[i+2]=='=') {
        sc_enc->token_code = TOK_RSHIFTEQ;
        sc_enc->cur_buf ++;
      } else if(sc_enc->cur_buf[i+2]=='>') {
        if(sc_enc->cur_buf[i+3]=='=') {
          sc_enc->token_code = TOK_RSHIFTFILLEQ;
          sc_enc->cur_buf ++;
        } else {
          sc_enc->token_code = TOK_RSHIFTFILL;
        }
        sc_enc->cur_buf ++;
      } else {
        sc_enc->token_code = TOK_RSHIFT;
      }
      sc_enc->cur_buf ++;
    } else if (sc_enc->cur_buf[i+1]=='=') {
      sc_enc->token_code = TOK_GE;
      sc_enc->cur_buf ++;
    } else {
      sc_enc->token_code = TOK_GT;
    }
    break;
  case '?':
    sc_enc->token_code = TOK_CONDTEST;
    break;
  case ':':
    sc_enc->token_code = TOK_CONDSEP;
    break;
  case '~':
    sc_enc->token_code = TOK_ONESCOMP;
    break;
  case ',':
    sc_enc->token_code = TOK_COMMA;
    break;
  case ';':
    sc_enc->token_code = TOK_SEMICOLON;
    break;
  case '{':
    sc_enc->token_code = TOK_LEFT_BRACE;
    break;
  case '}':
    sc_enc->token_code = TOK_RIGHT_BRACE;
    break;
  case '(':
    sc_enc->token_code = TOK_LEFT_CURVE;
    break;
  case ')':
    sc_enc->token_code = TOK_RIGHT_CURVE;
    break;
  case '[':
    sc_enc->token_code = TOK_LEFT_BRACKET;
    break;
  case ']':
    sc_enc->token_code = TOK_RIGHT_BRACKET;
    break;
  default:
    GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: Unrecognized symbol %c\n", sc_enc->cur_buf[i]));
    sc_enc->err = GF_BAD_PARAM;
    return GF_FALSE;
  }
  sc_enc->cur_buf ++;
  return GF_TRUE;
}

Bool SFE_CheckToken(ScriptEnc *sc_enc, u32 token)
{
  if (sc_enc->token_code != token) {
    GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: Bad token (expecting \"%s\" got \"%s\")\n", tok_names[token] , tok_names[sc_enc->token_code]));
    return GF_FALSE;
  }
  return GF_TRUE;
}

void SFE_PutIdentifier(ScriptEnc *sc_enc, char *id)
{
  u32 i;
  u32 nbBits, length;
  char *str;

  if (sc_enc->emul) return;

  i=0;
  while ((str = (char *)gf_list_enum(sc_enc->identifiers, &i))) {
    if (strcmp(str, id)) continue;

    nbBits = 0;
    length = gf_list_count(sc_enc->identifiers) - 1;
    while (length > 0) {
      length >>= 1;
      nbBits ++;
    }
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "received", str);
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, i-1, nbBits, "identifierCode", str);
    return;
  }
  GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 0, 1, "received", id);
  gf_list_add(sc_enc->identifiers, gf_strdup(id));
  gf_bifs_enc_name(sc_enc->codec, sc_enc->bs, id);
}


void SFE_Arguments(ScriptEnc *sc_enc)
{
  while (1) {
    if (!SFE_NextToken(sc_enc)) return;
    if (sc_enc->token_code == TOK_RIGHT_CURVE) break;
    else if (sc_enc->token_code == TOK_COMMA) continue;
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "hasArgument", NULL);
    SFE_PutIdentifier(sc_enc, sc_enc->token);
  }
  GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 0, 1, "hasArgument", NULL);
}

void SFE_StatementBlock(ScriptEnc *sc_enc);
void SFE_Statement(ScriptEnc *sc_enc);

void SFE_PutInteger(ScriptEnc *sc_enc, char *str)
{
  u32 nbBits, val = 0;
  if (sc_enc->emul) return;
  if ((str[0]=='0') && (str[1]=='x' || str[1]=='X')) {
    val = (u32) strtoul(sc_enc->token, (char **) NULL, 16);
  } else if (str[0]=='0' && isdigit(str[1])) {
    val = (u32) strtoul(str, (char **) NULL, 8);
  } else if (isdigit(str[0])) {
    val = (u32) strtoul(str, (char **) NULL, 10);
  } else {
    GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: %s is not an integer\n", str));
    sc_enc->err = GF_BAD_PARAM;
    return;
  }
  nbBits = gf_get_bit_size(val);
  GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, nbBits, 5, "nbBitsInteger", NULL);
  GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, val, nbBits, "value", sc_enc->token);
}

u32 SFE_LoadExpression(ScriptEnc *sc_enc, u32 *expr_sep)
{
  Bool is_var = GF_FALSE;
  u32 close_code, open_code;
  u32 count = 0;
  u32 nbExpr = 1;
  u32 nbIndir = 0;
  expr_sep[0] = 0;

  sc_enc->expr_toks_len = 0;

  while ( (sc_enc->token_code != TOK_SEMICOLON) && (sc_enc->token_code != TOK_RIGHT_CURVE) ) {
    switch (sc_enc->token_code) {
    case TOK_CONDTEST:
      nbIndir ++;
      break;
    case TOK_CONDSEP:
      if (nbIndir > 0) nbIndir--;
      /*'case'*/
      else {
        goto break_loop;
      }
      break;
    case TOK_IDENTIFIER:
    case TOK_NUMBER:
    case TOK_STRING:
    case TOK_BOOLEAN:
      gf_list_add(sc_enc->id_buf, gf_strdup(sc_enc->token));
      break;
    case TOK_FUNCTION:
      goto break_loop;
    }

    if (sc_enc->token_code==TOK_VAR) is_var = GF_TRUE;
    if (!is_var || (sc_enc->token_code!=TOK_COMMA)) {
      sc_enc->expr_toks[sc_enc->expr_toks_len] = sc_enc->token_code;
      sc_enc->expr_toks_len++;
    }

    open_code = sc_enc->token_code;
    close_code = 0;
    if (sc_enc->token_code == TOK_LEFT_CURVE) close_code = TOK_RIGHT_CURVE;
    else if (sc_enc->token_code == TOK_LEFT_BRACKET) close_code = TOK_RIGHT_BRACKET;
    else if (sc_enc->token_code == TOK_LEFT_BRACE) close_code = TOK_RIGHT_BRACE;

    /*other expr*/
    if ((sc_enc->token_code == TOK_COMMA) && (sc_enc->expr_toks[0] != TOK_VAR) ) {
      expr_sep[nbExpr++] = sc_enc->expr_toks_len - 1;
    }
    /*sub-expr*/
    else if (close_code) {
      count++;
      do {
        SFE_NextToken(sc_enc);
        if ((sc_enc->token_code == TOK_IDENTIFIER) || (sc_enc->token_code == TOK_NUMBER)
                || (sc_enc->token_code == TOK_STRING) || (sc_enc->token_code == TOK_BOOLEAN) ) {
          gf_list_add(sc_enc->id_buf, gf_strdup(sc_enc->token));
        }
        sc_enc->expr_toks[sc_enc->expr_toks_len] = sc_enc->token_code;
        sc_enc->expr_toks_len++;
        if (sc_enc->token_code == open_code) count++;
        else if (sc_enc->token_code == close_code) count--;
      } while ( (sc_enc->token_code != close_code) || count);
    }
    SFE_NextToken(sc_enc);

    if (sc_enc->err) break;
  }

break_loop:
  if (sc_enc->err) {
    GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: end of compoundExpression not found\n"));
    return 0;
  }
  expr_sep[nbExpr] = sc_enc->expr_toks_len;
  if ((sc_enc->token_code == TOK_IDENTIFIER) || (sc_enc->token_code == TOK_NUMBER)
          || (sc_enc->token_code == TOK_STRING) || (sc_enc->token_code == TOK_BOOLEAN) ) {
    gf_list_add(sc_enc->id_buf, gf_strdup(sc_enc->token));
  }

  if ((sc_enc->token_code != TOK_CONDSEP) && (sc_enc->token_code != TOK_RIGHT_BRACE) && (sc_enc->expr_toks[0] != TOK_VAR)) {
    sc_enc->expr_toks[sc_enc->expr_toks_len] = sc_enc->token_code;
    sc_enc->expr_toks_len++;
  }
  return nbExpr;
}

u32 MoveToToken(ScriptEnc *sc_enc, u32 endTok, u32 cur, u32 end);

u32 SFE_ScanExpression(ScriptEnc *sc_enc, u32 start, u32 end, u32 *expr_sep)
{
  u32 curTok;
  u32 n = start;
  u32 nbExpr = 1;

  expr_sep[0] = start;
  while (n<end) {
    curTok = sc_enc->expr_toks[n++];
    if (curTok == TOK_LEFT_CURVE) {
      n = MoveToToken(sc_enc, TOK_RIGHT_CURVE, n-1, end);
      n++;
    } else if (curTok == TOK_LEFT_BRACKET) {
      n = MoveToToken(sc_enc, TOK_RIGHT_BRACKET, n-1, end);
      n++;
    } else if (curTok == TOK_COMMA) {
      expr_sep[nbExpr++] = n-1;
    }
  }
  expr_sep[nbExpr] = end;
  return nbExpr;
}

u32 SFE_Expression(ScriptEnc *sc_enc, u32 start, u32 end, Bool memberAccess);

void SFE_CompoundExpression(ScriptEnc *sc_enc, u32 start, u32 end, u32 isPar)
{
  u32 nbExp, i;
  /*filled by indexes of ',' expressions in the expr_tok buffer*/
  u32 expr_sep[MAX_NUM_EXPR];

  if (sc_enc->err) return;

  if (end==0) {
    /*load expressions , eg "a ? ((a>b) ? 1 : 0) : 0" */
    nbExp = SFE_LoadExpression(sc_enc, expr_sep);
  } else {
    /*load sub-expression from loaded expression set*/
    nbExp = SFE_ScanExpression(sc_enc, start, end, expr_sep);
  }

  SFE_Expression(sc_enc, expr_sep[0], expr_sep[1], GF_FALSE);
  for (i=1; i<nbExp; i++) {
    SFE_WRITE_INT(sc_enc, 1, 1, isPar ? "hasParam" : "hasExpression", NULL);
    SFE_Expression(sc_enc, expr_sep[i]+1, expr_sep[i+1], GF_FALSE);
  }
  SFE_WRITE_INT(sc_enc, 0, 1, isPar ? "hasParam" : "hasExpression", NULL);
}

void SFE_OptionalExpression(ScriptEnc *sc_enc)
{
  if (sc_enc->token_code != TOK_SEMICOLON) {
    SFE_WRITE_INT(sc_enc, 1, 1, "hasCompoundExpression", NULL);
    SFE_CompoundExpression(sc_enc, 0, 0, 0);
  } else {
    SFE_WRITE_INT(sc_enc, 0, 1, "hasCompoundExpression", NULL);
  }
}

void SFE_IfStatement(ScriptEnc *sc_enc)
{
  char *buf_bck;
  u32 tok_bck;
  SFE_NextToken(sc_enc);
  SFE_CheckToken(sc_enc, TOK_LEFT_CURVE);
  SFE_NextToken(sc_enc);
  SFE_CompoundExpression(sc_enc, 0, 0, 0);
  SFE_CheckToken(sc_enc, TOK_RIGHT_CURVE);
  SFE_StatementBlock(sc_enc);

  buf_bck = sc_enc->cur_buf;
  tok_bck = sc_enc->token_code;
  SFE_NextToken(sc_enc);
  if (sc_enc->token_code == TOK_ELSE) {
    SFE_WRITE_INT(sc_enc, 1, 1, "hasELSEStatement", NULL);
    SFE_StatementBlock(sc_enc);
  } else {
    SFE_WRITE_INT(sc_enc, 0, 1, "hasELSEStatement", NULL);
    sc_enc->cur_buf = buf_bck;
    sc_enc->token_code = tok_bck;
  }
}

void SFE_ForStatement(ScriptEnc *sc_enc)
{
  SFE_NextToken(sc_enc);
  SFE_CheckToken(sc_enc, TOK_LEFT_CURVE);

  SFE_NextToken(sc_enc);
  SFE_OptionalExpression(sc_enc);
  SFE_CheckToken(sc_enc, TOK_SEMICOLON);

  SFE_NextToken(sc_enc);
  SFE_OptionalExpression(sc_enc);
  SFE_CheckToken(sc_enc, TOK_SEMICOLON);

  SFE_NextToken(sc_enc);
  SFE_OptionalExpression(sc_enc);
  SFE_CheckToken(sc_enc, TOK_RIGHT_CURVE);

  SFE_StatementBlock(sc_enc);
}

void SFE_WhileStatement(ScriptEnc *sc_enc)
{
  SFE_NextToken(sc_enc);
  SFE_CheckToken(sc_enc, TOK_LEFT_CURVE);
  SFE_NextToken(sc_enc);
  SFE_CompoundExpression(sc_enc, 0, 0, 0);
  SFE_CheckToken(sc_enc, TOK_RIGHT_CURVE);

  SFE_StatementBlock(sc_enc);
}

void SFE_ReturnStatement(ScriptEnc *sc_enc)
{
  SFE_NextToken(sc_enc);
  if (sc_enc->token_code != TOK_SEMICOLON) {
    SFE_WRITE_INT(sc_enc, 1, 1, "returnValue", NULL);
    SFE_CompoundExpression(sc_enc, 0, 0, 0);
  } else {
    SFE_WRITE_INT(sc_enc, 0, 1, "returnValue", NULL);
  }
}

void SFE_CaseBlock(ScriptEnc *sc_enc)
{
  SFE_WRITE_INT(sc_enc, 1, 1, "isCompoundStatement", NULL);
  SFE_NextToken(sc_enc);
  if (sc_enc->token_code == TOK_LEFT_BRACE) {
    SFE_NextToken(sc_enc);
    while (sc_enc->token_code != TOK_RIGHT_BRACE) {
      SFE_WRITE_INT(sc_enc, 1, 1, "hasStatement", NULL);
      SFE_Statement(sc_enc);
      SFE_NextToken(sc_enc);
    }
    SFE_NextToken(sc_enc);
  }
  while ((sc_enc->token_code != TOK_CASE) && (sc_enc->token_code != TOK_DEFAULT) && (sc_enc->token_code != TOK_RIGHT_BRACE)) {
    SFE_WRITE_INT(sc_enc, 1, 1, "hasStatement", NULL);
    SFE_Statement(sc_enc);
    SFE_NextToken(sc_enc);
  }
  SFE_WRITE_INT(sc_enc, 0, 1, "hasStatement", NULL);
}

u32 SFE_PutCaseInteger(ScriptEnc *sc_enc, char *str, u32 nbBits)
{
  u32 val = 0;
  if ((str[0]=='0') && (str[1]=='x' || str[1]=='X')) {
    val = (u32) strtoul(sc_enc->token, (char **) NULL, 16);
  } else if (str[0]=='0' && isdigit(str[1])) {
    val = (u32) strtoul(str, (char **) NULL, 8);
  } else if (isdigit(str[0])) {
    val = (u32) strtoul(str, (char **) NULL, 10);
  } else {
    GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: %s is not an integer\n", str));
    sc_enc->err = GF_BAD_PARAM;
    return 0;
  }
  if (!sc_enc->emul) {
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, val, nbBits, "value", sc_enc->token);
  } else {
    nbBits = gf_get_bit_size(val);
  }
  return nbBits;
}

void SFE_SwitchStatement(ScriptEnc *sc_enc)
{
  u32 nbBits, maxBits = 0;
  Bool prev_emu;
  char *buf_bck;
  u32 tok_bck;

  SFE_NextToken(sc_enc);
  SFE_CheckToken(sc_enc, TOK_LEFT_CURVE);

  SFE_NextToken(sc_enc);
  SFE_CompoundExpression(sc_enc, 0, 0, 0);
  SFE_CheckToken(sc_enc, TOK_RIGHT_CURVE);

  SFE_NextToken(sc_enc);
  SFE_CheckToken(sc_enc, TOK_LEFT_BRACE);

  /*first pass in emul*/
  buf_bck = sc_enc->cur_buf;
  tok_bck = sc_enc->token_code;
  prev_emu = sc_enc->emul;
  sc_enc->emul = GF_TRUE;

  SFE_NextToken(sc_enc);
  while (sc_enc->token_code == TOK_CASE) {
    SFE_NextToken(sc_enc);
    SFE_CheckToken(sc_enc, TOK_NUMBER);
    nbBits = SFE_PutCaseInteger(sc_enc, sc_enc->token, 0);
    if (maxBits<nbBits) maxBits = nbBits;

    SFE_NextToken(sc_enc);
    SFE_CheckToken(sc_enc, TOK_CONDSEP);

    SFE_CaseBlock(sc_enc);
    SFE_WRITE_INT(sc_enc, (sc_enc->token_code == TOK_CASE) ? 1 : 0, 1, "hasMoreCases", NULL);
  }

  /*second pass in parent mode*/
  sc_enc->cur_buf = buf_bck;
  sc_enc->token_code = tok_bck;
  sc_enc->emul = prev_emu;
  maxBits ++;
  SFE_WRITE_INT(sc_enc, maxBits, 5, "caseNbBits", NULL);

  SFE_NextToken(sc_enc);
  while (sc_enc->token_code == TOK_CASE) {
    SFE_NextToken(sc_enc);
    SFE_CheckToken(sc_enc, TOK_NUMBER);
    SFE_PutCaseInteger(sc_enc, sc_enc->token, maxBits);

    SFE_NextToken(sc_enc);
    SFE_CheckToken(sc_enc, TOK_CONDSEP);

    SFE_CaseBlock(sc_enc);
    SFE_WRITE_INT(sc_enc, (sc_enc->token_code == TOK_CASE) ? 1 : 0, 1, "hasMoreCases", NULL);
  }

  if (sc_enc->token_code == TOK_DEFAULT) {
    SFE_WRITE_INT(sc_enc, 1, 1, "hasDefault", NULL);
    SFE_NextToken(sc_enc);
    SFE_CheckToken(sc_enc, TOK_CONDSEP);
    SFE_CaseBlock(sc_enc);
  } else {
    SFE_WRITE_INT(sc_enc, 0, 1, "hasDefault", NULL);
  }
  SFE_CheckToken(sc_enc, TOK_RIGHT_BRACE);
}

void SFE_Statement(ScriptEnc *sc_enc)
{
  switch (sc_enc->token_code) {
  case TOK_IF:
    SFE_WRITE_INT(sc_enc, ST_IF, NUMBITS_STATEMENT, "statementType", "if");
    SFE_IfStatement(sc_enc);
    break;
  case TOK_FOR:
    SFE_WRITE_INT(sc_enc, ST_FOR, NUMBITS_STATEMENT, "statementType", "for");
    SFE_ForStatement(sc_enc);
    break;
  case TOK_WHILE:
    SFE_WRITE_INT(sc_enc, ST_WHILE, NUMBITS_STATEMENT, "statementType", "while");
    SFE_WhileStatement(sc_enc);
    break;
  case TOK_RETURN:
    SFE_WRITE_INT(sc_enc, ST_RETURN, NUMBITS_STATEMENT, "statementType", "return");
    SFE_ReturnStatement(sc_enc);
    break;
  case TOK_BREAK:
    SFE_WRITE_INT(sc_enc, ST_BREAK, NUMBITS_STATEMENT, "statementType", "break");
    SFE_NextToken(sc_enc);
    break;
  case TOK_CONTINUE:
    SFE_WRITE_INT(sc_enc, ST_CONTINUE, NUMBITS_STATEMENT, "statementType", "continue");
    SFE_NextToken(sc_enc);
    break;
  case TOK_SWITCH:
    SFE_WRITE_INT(sc_enc, ST_SWITCH, NUMBITS_STATEMENT, "statementType", "while");
    SFE_SwitchStatement(sc_enc);
    break;
  default:
    SFE_WRITE_INT(sc_enc, ST_COMPOUND_EXPR, NUMBITS_STATEMENT, "statementType", "compoundExpr");
    SFE_CompoundExpression(sc_enc, 0, 0, 0);
    break;
  }
}

void SFE_Statements(ScriptEnc *sc_enc)
{
  while (1) {
    if (!SFE_NextToken(sc_enc)) return;
    if (sc_enc->token_code == TOK_RIGHT_BRACE) break;
    SFE_WRITE_INT(sc_enc, 1, 1, "hasStatement", NULL);
    SFE_Statement(sc_enc);
  }
  SFE_WRITE_INT(sc_enc, 0, 1, "hasStatement", NULL);
}

void SFE_StatementBlock(ScriptEnc *sc_enc)
{
  if (!SFE_NextToken(sc_enc)) return;
  if (sc_enc->token_code == TOK_LEFT_BRACE) {
    SFE_WRITE_INT(sc_enc, 1, 1, "isCompoundStatement", NULL);
    SFE_Statements(sc_enc);
  } else {
    SFE_WRITE_INT(sc_enc, 0, 1, "isCompoundStatement", NULL);
    SFE_Statement(sc_enc);
  }
}
void SFE_Function(ScriptEnc *sc_enc)
{
  char szName[1000];

  SFE_NextToken(sc_enc);
  SFE_CheckToken(sc_enc, TOK_FUNCTION);

  SFE_NextToken(sc_enc);
  SFE_CheckToken(sc_enc, TOK_IDENTIFIER);
  strcpy(szName, sc_enc->token);
  SFE_PutIdentifier(sc_enc, sc_enc->token);

  SFE_NextToken(sc_enc);
  SFE_CheckToken(sc_enc, TOK_LEFT_CURVE);

  SFE_Arguments(sc_enc);
  SFE_StatementBlock(sc_enc);

  if (sc_enc->err) GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: Error while parsing function %s\n", szName));
}


GF_Err SFScript_Encode(GF_BifsEncoder *codec, SFScript *script_field, GF_BitStream *bs, GF_Node *n)
{
  char *ptr;
  ScriptEnc sc_enc;
  if (gf_node_get_tag(n) != TAG_MPEG4_Script) return GF_NON_COMPLIANT_BITSTREAM;

  memset(&sc_enc, 0, sizeof(ScriptEnc));
  sc_enc.codec = codec;
  sc_enc.script = n;
  sc_enc.bs = bs;
  sc_enc.identifiers = gf_list_new();
  sc_enc.id_buf = gf_list_new();
  sc_enc.err = GF_OK;

  if (codec->is_encoding_command) {
    GF_BIFS_WRITE_INT(codec, bs, 1, 1, "Script::isList", NULL);
    GF_BIFS_WRITE_INT(codec, bs, 1, 1, "end", NULL);
  } else {
    EncScriptFields(&sc_enc);
  }
  /*reserevd*/
  GF_BIFS_WRITE_INT(codec, bs, 1, 1, "reserved", NULL);

  if (script_field) {
    sc_enc.cur_buf = (char *)script_field->script_text;
  } else if (((M_Script*)n)->url.count) {
    sc_enc.cur_buf = (char *)((M_Script*)n)->url.vals[0].script_text;
  }
  if (sc_enc.cur_buf) {
    if (!strnicmp(sc_enc.cur_buf, "javascript:", 11)
            || !strnicmp(sc_enc.cur_buf, "vrmlscript:", 11)
            || !strnicmp(sc_enc.cur_buf, "ECMAScript:", 11)
       ) {
      sc_enc.cur_buf += 11;
    } else if (!strnicmp(sc_enc.cur_buf, "mpeg4script:", 12) ) {
      sc_enc.cur_buf += 12;
    }
  }

  /*encode functions*/
  while (sc_enc.cur_buf && sc_enc.cur_buf[0] && (sc_enc.cur_buf[0]!='}')) {
    if (strchr("\r\n\t ", sc_enc.cur_buf[0]) ) {
      sc_enc.cur_buf++;
      continue;
    }
    GF_BIFS_WRITE_INT(codec, bs, 1, 1, "hasFunction", NULL);
    SFE_Function(&sc_enc);
    if (sc_enc.err) break;
  }
  GF_BIFS_WRITE_INT(codec, bs, 0, 1, "hasFunction", NULL);

  //clean up
  while (gf_list_count(sc_enc.identifiers)) {
    ptr = (char *)gf_list_get(sc_enc.identifiers, 0);
    gf_list_rem(sc_enc.identifiers, 0);
    gf_free(ptr);
  }
  gf_list_del(sc_enc.identifiers);
  /*in case of error this is needed*/
  while (gf_list_count(sc_enc.id_buf)) {
    ptr = (char *)gf_list_get(sc_enc.id_buf, 0);
    gf_list_rem(sc_enc.id_buf, 0);
    gf_free(ptr);
  }
  gf_list_del(sc_enc.id_buf);

  return sc_enc.err;
}


void SFE_PutReal(ScriptEnc *sc_enc, char *str)
{
  u32 i;
  size_t length = strlen(str);
  for (i=0; i<length; i++) {
    s32 c = str[i];
    if (c >= '0' && c <= '9')
    {
      SFE_WRITE_INT(sc_enc, c-'0', 4, "floatChar", "Digital");
    }
    else if (c == '.')
    {
      SFE_WRITE_INT(sc_enc, 10, 4, "floatChar", "Decimal Point");
    }
    else if (c == 'e' || c == 'E')
    {
      SFE_WRITE_INT(sc_enc, 11, 4, "floatChar", "Exponential");
    }
    else if (c == '-')
    {
      SFE_WRITE_INT(sc_enc, 12, 4, "floatChar", "Sign");
    }
    else {
      GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: %s is not a real number\n", str));
      sc_enc->err = GF_BAD_PARAM;
      return;
    }
  }
  SFE_WRITE_INT(sc_enc, 15, 4, "floatChar", "End Symbol");
}

void SFE_PutNumber(ScriptEnc *sc_enc, char *str)
{
  if (strpbrk(str,".eE-") == 0) {
    SFE_WRITE_INT(sc_enc, 1, 1, "isInteger", "integer");
    SFE_PutInteger(sc_enc, str);
  } else {
    SFE_WRITE_INT(sc_enc, 0, 1, "isInteger", "real");
    SFE_PutReal(sc_enc, str);
  }
}

void SFE_PutBoolean(ScriptEnc *sc_enc, char *str)
{
  u32 v = 1;
  if (!stricmp(str, "false") || !strcmp(str, "0")) v = 0;
  SFE_WRITE_INT(sc_enc, v, 1, "value", "bolean");
}


#define CHECK_TOK(x) \
  if (curTok != x) { \
    GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: Token %s read, %s expected\n", tok_names[curTok], tok_names[x])); \
    sc_enc->err = GF_BAD_PARAM; \
  }  \


u32 TOK_To_ET(u32 tok)
{
  switch(tok) {
  case TOK_INCREMENT:
    return ET_INCREMENT;
  case TOK_DECREMENT:
    return ET_DECREMENT;
  case TOK_NOT:
    return ET_NOT;
  case TOK_ONESCOMP:
    return ET_ONESCOMP;
  case TOK_MULTIPLY :
    return ET_MULTIPLY;
  case TOK_DIVIDE :
    return ET_DIVIDE;
  case TOK_MOD :
    return ET_MOD;
  case TOK_PLUS :
    return ET_PLUS;
  case TOK_MINUS :
    return ET_MINUS;
  case TOK_LSHIFT :
    return ET_LSHIFT;
  case TOK_RSHIFT :
    return ET_RSHIFT;
  case TOK_RSHIFTFILL :
    return ET_RSHIFTFILL;
  case TOK_LT :
    return ET_LT;
  case TOK_LE :
    return ET_LE;
  case TOK_GT :
    return ET_GT;
  case TOK_GE :
    return ET_GE;
  case TOK_EQ :
    return ET_EQ;
  case TOK_NE :
    return ET_NE;
  case TOK_AND :
    return ET_AND;
  case TOK_XOR :
    return ET_XOR;
  case TOK_OR :
    return ET_OR;
  case TOK_LAND :
    return ET_LAND;
  case TOK_LOR :
    return ET_LOR;
  case TOK_CONDTEST :
    return ET_CONDTEST;
  case TOK_ASSIGN :
    return ET_ASSIGN;
  case TOK_PLUSEQ :
    return ET_PLUSEQ;
  case TOK_MINUSEQ :
    return ET_MINUSEQ;
  case TOK_MULTIPLYEQ :
    return ET_MULTIPLYEQ;
  case TOK_DIVIDEEQ :
    return ET_DIVIDEEQ;
  case TOK_MODEQ :
    return ET_MODEQ;
  case TOK_LSHIFTEQ :
    return ET_LSHIFTEQ;
  case TOK_RSHIFTEQ :
    return ET_RSHIFTEQ;
  case TOK_RSHIFTFILLEQ :
    return ET_RSHIFTFILLEQ;
  case TOK_ANDEQ :
    return ET_ANDEQ;
  case TOK_XOREQ :
    return ET_XOREQ;
  case TOK_OREQ :
    return ET_OREQ;
  case TOK_FUNCTION:
    return ET_FUNCTION_CALL;
  case TOK_VAR:
    return ET_VAR;
  default:
    gf_assert(0);
    return (u32) -1;
  }
}

#ifndef GPAC_DISABLE_LOG
static const char *expr_name[] = {
  "ET_CURVED_EXPR",
  "ET_NEGATIVE",
  "ET_NOT",
  "ET_ONESCOMP",
  "ET_INCREMENT",
  "ET_DECREMENT",
  "ET_POST_INCREMENT",
  "ET_POST_DECREMENT",
  "ET_CONDTEST",
  "ET_STRING",
  "ET_NUMBER",
  "ET_IDENTIFIER",
  "ET_FUNCTION_CALL",
  "ET_NEW",
  "ET_OBJECT_MEMBER_ACCESS",
  "ET_OBJECT_METHOD_CALL",
  "ET_ARRAY_DEREFERENCE",
  "ET_ASSIGN",
  "ET_PLUSEQ",
  "ET_MINUSEQ",
  "ET_MULTIPLYEQ",
  "ET_DIVIDEEQ",
  "ET_MODEQ",
  "ET_ANDEQ",
  "ET_OREQ",
  "ET_XOREQ",
  "ET_LSHIFTEQ",
  "ET_RSHIFTEQ",
  "ET_RSHIFTFILLEQ",
  "ET_EQ",
  "ET_NE",
  "ET_LT",
  "ET_LE",
  "ET_GT",
  "ET_GE",
  "ET_PLUS",
  "ET_MINUS",
  "ET_MULTIPLY",
  "ET_DIVIDE",
  "ET_MOD",
  "ET_LAND",
  "ET_LOR",
  "ET_AND",
  "ET_OR",
  "ET_XOR",
  "ET_LSHIFT",
  "ET_RSHIFT",
  "ET_RSHIFTFILL",
  "ET_BOOLEAN",
  "ET_VAR",
  "NUMBER_OF_EXPR_TYPE"
};
#endif


#define NUMBER_OF_RANK  15
static s32 ET_Rank[NUMBER_OF_EXPR_TYPE] =
{
  1,// ET_CURVED_EXPR
  2,// ET_NEGATIVE
  2,// ET_NOT
  2,// ET_ONESCOMP
  2,// ET_INCREMENT
  2,// ET_DECREMENT
  2,// ET_POST_INCREMENT
  2,// ET_POST_DECREMENT
  14,// ET_CONDTEST
  0,// ET_STRING
  0,// ET_NUMBER
  0,// ET_IDENTIFIER
  1,// ET_FUNCTION_CALL
  2,// ET_NEW
  1,// ET_OBJECT_MEMBER_ACCESS
  1,// ET_OBJECT_METHOD_CALL
  1,// ET_ARRAY_DEREFERENCE
  14,// ET_ASSIGN
  14,// ET_PLUSEQ
  14,// ET_MINUSEQ
  14,// ET_MULTIPLYEQ
  14,// ET_DIVIDEEQ
  14,// ET_MODEQ
  14,// ET_ANDEQ
  14,// ET_OREQ
  14,// ET_XOREQ
  14,// ET_LSHIFTEQ
  14,// ET_RSHIFTEQ
  14,// ET_RSHIFTFILLEQ
  8,// ET_EQ
  9,// ET_NE
  6,// ET_LT
  6,// ET_LE
  7,// ET_GT
  7,// ET_GE
  5,// ET_PLUS
  5,// ET_MINUS
  3,// ET_MULTIPLY
  3,// ET_DIVIDE
  3,// ET_MOD
  13,// ET_LAND
  14,// ET_LOR
  10,// ET_AND
  12,// ET_OR
  11,// ET_XOR
  5,// ET_LSHIFT
  6,// ET_RSHIFT
  6,// ET_RSHIFTFILL
  0, // ET_BOOLEAN
  14 // ET_VAR

  /*
    0, 0, 0,      // variable, number, string
    1, 1, 1, 1, 1,      // curved expr, call, member, array
    2, 2, 2, 2, 2, 2, 2, 2,   // unary operator
    3, 3, 3,      // multiply, divide, mod
    4, 4,       // add, subtract
    5, 5, 5,      // bitwise shift
    6, 6, 6, 6,     // relational
    7, 7,       // equality
    8,        // bitwise and
    9,        // bitwise xor
    10,       // bitwise or
    11,       // logical and
    12,       // logical or
    13,       // conditional
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14  // assignment
    */
};
static s32 ET_leftAssoc[NUMBER_OF_RANK] = {1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0};

u32 MoveToToken(ScriptEnc *sc_enc, u32 endTok, u32 cur, u32 end)
{
  u32 cnt = 0;
  u32 startTok = TOK_EOF, curTok;

  if (endTok == TOK_RIGHT_CURVE) startTok = TOK_LEFT_CURVE;
  else if (endTok == TOK_RIGHT_BRACKET) startTok = TOK_LEFT_BRACKET;
  else if (endTok == TOK_RIGHT_BRACE) startTok = TOK_LEFT_BRACE;
  else if (endTok == TOK_CONDSEP) startTok = TOK_CONDTEST;
  else {
    GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: illegal MoveToToken %s\n", tok_names[endTok]));
    sc_enc->err = GF_BAD_PARAM;
    return (u32) -1;
  }
  do {
    curTok = sc_enc->expr_toks[cur++];
    if (curTok == startTok) cnt++;
    else if (curTok == endTok) cnt--;
  } while ( (curTok != endTok || cnt) && cur < end);
  if (curTok==endTok && cnt==0) return cur-1;
  return (u32) -1;
}


void SFE_FunctionCall(ScriptEnc *sc_enc, u32 start, u32 end);
void SFE_Params(ScriptEnc *sc_enc, u32 start, u32 end);
void SFE_ConditionTest(ScriptEnc *sc_enc, u32 start, u32 op, u32 end);
void SFE_ObjectConstruct(ScriptEnc *sc_enc, u32 start, u32 op, u32 end);
void SFE_ArrayDereference(ScriptEnc *sc_enc, u32 start, u32 op, u32 end);
void SFE_ObjectMethodCall(ScriptEnc *sc_enc, u32 start, u32 op, u32 end);
void SFE_ObjectMemberAccess(ScriptEnc *sc_enc, u32 start, u32 op, u32 end);

u32 SFE_Expression(ScriptEnc *sc_enc, u32 start, u32 end, Bool memberAccess)
{
  char *str;
  u32 n = start;
  u32 curPos = 0, finalPos = 0;
  u32 curTok, prevTok;
  u32 curExpr = 0, expr = 0;
  u32 curRank, maxRank=0;

  if (sc_enc->err) return 0;

  curTok = prevTok = sc_enc->expr_toks[n];
  do {
    curPos = n;
    switch (curTok) {
    case TOK_IDENTIFIER:
      curExpr = ET_IDENTIFIER;
      break;
    case TOK_NUMBER:
      curExpr = ET_NUMBER;
      break;
    case TOK_BOOLEAN:
      curExpr = ET_BOOLEAN;
      break;
    case TOK_STRING:
      curExpr = ET_STRING;
      break;
    case TOK_LEFT_CURVE:
      if (prevTok == TOK_IDENTIFIER) curExpr = ET_FUNCTION_CALL;
      else curExpr = ET_CURVED_EXPR;
      n = MoveToToken(sc_enc, TOK_RIGHT_CURVE, n, end);
      curTok = TOK_RIGHT_CURVE;
      break;
    case TOK_LEFT_BRACKET:
      curExpr = ET_ARRAY_DEREFERENCE;
      n = MoveToToken(sc_enc, TOK_RIGHT_BRACKET, n, end);
      curTok = TOK_RIGHT_BRACKET;
      break;
    case TOK_PERIOD:
      curTok = sc_enc->expr_toks[++n];
      CHECK_TOK(TOK_IDENTIFIER);
      if (sc_enc->expr_toks[n+1] == TOK_LEFT_CURVE) {
        curExpr = ET_OBJECT_METHOD_CALL;
        n = MoveToToken(sc_enc, TOK_RIGHT_CURVE, n+1, end);
        curTok = TOK_RIGHT_CURVE;
      } else {
        curExpr = ET_OBJECT_MEMBER_ACCESS;
      }
      break;
    case TOK_NEW:
      curExpr = ET_NEW;
      curTok = sc_enc->expr_toks[++n];
      CHECK_TOK(TOK_IDENTIFIER);
      curTok = sc_enc->expr_toks[++n];
      CHECK_TOK(TOK_LEFT_CURVE);
      n = MoveToToken(sc_enc, TOK_RIGHT_CURVE, n, end);
      curTok = TOK_RIGHT_CURVE;
      break;
    case TOK_FUNCTION:
      curExpr = ET_FUNCTION_ASSIGN;
      break;
    case TOK_PLUS:
      if (
          prevTok==TOK_RIGHT_CURVE || prevTok==TOK_RIGHT_BRACKET ||
          prevTok==TOK_IDENTIFIER || prevTok==TOK_NUMBER ||
          prevTok==TOK_STRING || prevTok==TOK_INCREMENT ||
          prevTok==TOK_DECREMENT
      ) {
        curExpr = ET_PLUS;
      } else {
        goto skip_token;
      }
      break;
    case TOK_MINUS:
      if (
          prevTok==TOK_RIGHT_CURVE || prevTok==TOK_RIGHT_BRACKET ||
          prevTok==TOK_IDENTIFIER || prevTok==TOK_NUMBER ||
          prevTok==TOK_STRING || prevTok==TOK_INCREMENT ||
          prevTok==TOK_DECREMENT
      ) {
        curExpr = ET_MINUS;
      } else {
        curExpr = ET_NEGATIVE;
        curTok = TOK_NEGATIVE;
      }
      break;
    case TOK_INCREMENT:
      curExpr = ET_INCREMENT;
      break;
    case TOK_DECREMENT:
      curExpr = ET_DECREMENT;
      break;
    case TOK_NOT:
      curExpr = ET_NOT;
      break;
    case TOK_ONESCOMP:
      curExpr = ET_ONESCOMP;
      break;
    case TOK_CONDTEST:
      curExpr = ET_CONDTEST;
      break;
    case TOK_CONDSEP:
      break;
    case TOK_LEFT_BRACE:
      curExpr = ET_CURVED_EXPR;
      n = MoveToToken(sc_enc, TOK_RIGHT_BRACE, n, end);
      curTok = TOK_RIGHT_BRACE;
      break;
      break;
    default:

      if (curTok && (curTok != TOK_VAR)
              && (curTok < TOK_MULTIPLY || curTok > TOK_OREQ)) {
        GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: illegal token %s read\n", tok_names[curTok]));
        sc_enc->err = GF_BAD_PARAM;
        return 0;
      }
      curExpr = TOK_To_ET(curTok);
    }

    if (curTok == TOK_CONDSEP) {
      prevTok = curTok;
      curTok = sc_enc->expr_toks[++n];
      continue;
    }
    curRank = ET_Rank[curExpr];
    if (curRank > maxRank) {
      maxRank = curRank;
      expr = curExpr;
      finalPos = curPos;
    } else if (curRank == maxRank && ET_leftAssoc[curRank]) {
      expr = curExpr;
      finalPos = curPos;
    }
    prevTok = curTok;
skip_token:
    curTok = sc_enc->expr_toks[++n];
  } while (n<end);

  if (expr == ET_INCREMENT) {
    if (finalPos==start) {}
    else if (finalPos==end-1) expr = ET_POST_INCREMENT;
    else {
      GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: illegal Increment expression\n"));
      sc_enc->err = GF_BAD_PARAM;
      return expr;
    }
  } else if (expr == ET_DECREMENT) {
    if (finalPos==start) {}
    else if (finalPos==end-1) expr = ET_POST_DECREMENT;
    else {
      GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: illegal Decrement expression\n"));
      sc_enc->err = GF_BAD_PARAM;
      return expr;
    }
  }

  SFE_WRITE_INT(sc_enc, expr, NUMBITS_EXPR_TYPE, "expressionType", (char *) expr_name[expr]);

  switch (expr) {
  case ET_MULTIPLY:
  case ET_DIVIDE:
  case ET_MOD:
  case ET_PLUS:
  case ET_MINUS:
  case ET_LSHIFT:
  case ET_RSHIFT:
  case ET_RSHIFTFILL:
  case ET_LT:
  case ET_LE:
  case ET_GT:
  case ET_GE:
  case ET_EQ:
  case ET_NE:
  case ET_AND:
  case ET_XOR:
  case ET_OR:
  case ET_LAND:
  case ET_LOR:
    SFE_Expression(sc_enc, start, finalPos, GF_FALSE);
    SFE_Expression(sc_enc, finalPos+1, end, GF_FALSE);
    break;
  case ET_ASSIGN:
  case ET_PLUSEQ:
  case ET_MINUSEQ:
  case ET_MULTIPLYEQ:
  case ET_DIVIDEEQ:
  case ET_MODEQ:
  case ET_LSHIFTEQ:
  case ET_RSHIFTEQ:
  case ET_RSHIFTFILLEQ:
  case ET_ANDEQ:
  case ET_XOREQ:
  case ET_OREQ:
  {
    u32 ret = SFE_Expression(sc_enc, start, finalPos, GF_FALSE);
    if ( ret != ET_IDENTIFIER && ret != ET_OBJECT_MEMBER_ACCESS && ret != ET_ARRAY_DEREFERENCE ) {
      GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: LeftVariable expected, %s returned\n", expr_name[ret]));
      sc_enc->err = GF_BAD_PARAM;
      return expr;
    }
    SFE_Expression(sc_enc, finalPos+1, end, GF_FALSE);
  }
  break;

  case ET_IDENTIFIER:
    str = (char *)gf_list_get(sc_enc->id_buf, 0);
    gf_list_rem(sc_enc->id_buf, 0);
    /*TODO: when accessing member, we should try to translate proto fields into _fieldALL when not
    using USENAMEs...*/
    if (memberAccess) {
    }
    SFE_PutIdentifier(sc_enc, str);
    gf_free(str);
    break;
  case ET_NUMBER:
    str = (char *)gf_list_get(sc_enc->id_buf, 0);
    gf_list_rem(sc_enc->id_buf, 0);
    SFE_PutNumber(sc_enc, str);
    gf_free(str);
    break;
  case ET_BOOLEAN:
    str = (char *)gf_list_get(sc_enc->id_buf, 0);
    gf_list_rem(sc_enc->id_buf, 0);
    SFE_PutBoolean(sc_enc, str);
    gf_free(str);
    break;
  case ET_VAR:
    while (1) {
      str = (char *)gf_list_get(sc_enc->id_buf, 0);
      if (!str) break;
      gf_list_rem(sc_enc->id_buf, 0);
      GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "hasArgument", NULL);
      SFE_PutIdentifier(sc_enc, str);
      gf_free(str);
    }
    GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 0, 1, "hasArgument", NULL);
    break;
  case ET_STRING:
    str = (char *)gf_list_get(sc_enc->id_buf, 0);
    gf_list_rem(sc_enc->id_buf, 0);
    if (!sc_enc->emul) gf_bifs_enc_name(sc_enc->codec, sc_enc->bs, str);
    gf_free(str);
    break;
  case ET_NEGATIVE:
  case ET_INCREMENT:
  case ET_DECREMENT:
  case ET_NOT:
  case ET_ONESCOMP:
    SFE_Expression(sc_enc, finalPos+1, end, GF_FALSE);
    break;
  case ET_CURVED_EXPR:
    SFE_CompoundExpression(sc_enc, finalPos+1, end-1, 0);
    break;
  case ET_POST_INCREMENT :
  case ET_POST_DECREMENT :
    SFE_Expression(sc_enc, start, finalPos, GF_FALSE);
    break;
  case ET_FUNCTION_CALL:
    SFE_FunctionCall(sc_enc, start, end);
    break;
  case ET_OBJECT_MEMBER_ACCESS :
    SFE_ObjectMemberAccess(sc_enc, start, finalPos, end);
    break;
  case ET_OBJECT_METHOD_CALL:
    SFE_ObjectMethodCall(sc_enc, start, finalPos, end);
    break;
  case ET_ARRAY_DEREFERENCE:
    SFE_ArrayDereference(sc_enc, start, finalPos, end);
    break;
  case ET_NEW:
    SFE_ObjectConstruct(sc_enc, start, finalPos, end);
    break;
  case ET_CONDTEST:
    SFE_ConditionTest(sc_enc, start, finalPos, end);
    break;
  case ET_FUNCTION_ASSIGN:
    SFE_NextToken(sc_enc);
    SFE_CheckToken(sc_enc, TOK_LEFT_CURVE);

    SFE_Arguments(sc_enc);
    SFE_StatementBlock(sc_enc);
    SFE_NextToken(sc_enc);
    SFE_CheckToken(sc_enc, TOK_SEMICOLON);
    break;
  default:
    GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: illegal expression type %s\n", expr < GF_ARRAY_LENGTH(expr_name) ? expr_name[expr] : ""));
    sc_enc->err = GF_BAD_PARAM;
    break;
  }
  return expr;
}


void SFE_FunctionCall(ScriptEnc *sc_enc, u32 start, u32 end)
{
  u32 curTok;
  char *str;
  curTok = sc_enc->expr_toks[start++];
  CHECK_TOK(TOK_IDENTIFIER);
  str = (char *)gf_list_get(sc_enc->id_buf, 0);
  gf_list_rem(sc_enc->id_buf, 0);
  SFE_PutIdentifier(sc_enc, str);
  gf_free(str);
  curTok = sc_enc->expr_toks[start++];
  CHECK_TOK(TOK_LEFT_CURVE);
  SFE_Params(sc_enc, start, end-1);
  curTok = sc_enc->expr_toks[end-1];
  CHECK_TOK(TOK_RIGHT_CURVE);
}

void SFE_ObjectMemberAccess(ScriptEnc *sc_enc, u32 start, u32 op, u32 end)
{
  u32 curTok;
  char *str;

  SFE_Expression(sc_enc, start, op, GF_TRUE);
  curTok = sc_enc->expr_toks[op];
  CHECK_TOK(TOK_PERIOD);
  curTok = sc_enc->expr_toks[end-1];
  CHECK_TOK(TOK_IDENTIFIER);
  str = (char *)gf_list_get(sc_enc->id_buf, 0);
  gf_list_rem(sc_enc->id_buf, 0);
  SFE_PutIdentifier(sc_enc, str);
  gf_free(str);
}

void SFE_ObjectMethodCall(ScriptEnc *sc_enc, u32 start, u32 op, u32 end)
{
  u32 curTok;
  char *str;

  SFE_Expression(sc_enc, start, op, GF_FALSE);
  curTok = sc_enc->expr_toks[op];
  CHECK_TOK(TOK_PERIOD);
  curTok = sc_enc->expr_toks[op+1];
  CHECK_TOK(TOK_IDENTIFIER);
  str = (char *)gf_list_get(sc_enc->id_buf, 0);
  gf_list_rem(sc_enc->id_buf, 0);
  SFE_PutIdentifier(sc_enc, str);
  gf_free(str);
  curTok = sc_enc->expr_toks[op+2];
  CHECK_TOK(TOK_LEFT_CURVE);
  SFE_Params(sc_enc, op+3, end-1);
  curTok = sc_enc->expr_toks[end-1];
  CHECK_TOK(TOK_RIGHT_CURVE);
}

void SFE_ArrayDereference(ScriptEnc *sc_enc, u32 start, u32 op, u32 end)
{
  u32 curTok;

  SFE_Expression(sc_enc, start, op, GF_FALSE);
  curTok = sc_enc->expr_toks[op];
  CHECK_TOK(TOK_LEFT_BRACKET);
  SFE_CompoundExpression(sc_enc, op+1, end-1, 0);
  curTok = sc_enc->expr_toks[end-1];
  CHECK_TOK(TOK_RIGHT_BRACKET);
}

void SFE_ObjectConstruct(ScriptEnc *sc_enc, u32 start, u32 op, u32 end)
{
  u32 curTok;
  char *str;

  curTok = sc_enc->expr_toks[start++];
  CHECK_TOK(TOK_NEW);
  curTok = sc_enc->expr_toks[start++];
  CHECK_TOK(TOK_IDENTIFIER);
  str = (char *)gf_list_get(sc_enc->id_buf, 0);
  gf_list_rem(sc_enc->id_buf, 0);
  SFE_PutIdentifier(sc_enc, str);
  gf_free(str);
  curTok = sc_enc->expr_toks[start++];
  CHECK_TOK(TOK_LEFT_CURVE);
  SFE_Params(sc_enc, start, end-1);
  curTok = sc_enc->expr_toks[end-1];
  CHECK_TOK(TOK_RIGHT_CURVE);
}

void SFE_ConditionTest(ScriptEnc *sc_enc, u32 start, u32 op, u32 end)
{
  u32 curTok;

  SFE_Expression(sc_enc, start, op, GF_FALSE);
  curTok = sc_enc->expr_toks[op];
  CHECK_TOK(TOK_CONDTEST);
  start = op+1;
  op = MoveToToken(sc_enc, TOK_CONDSEP, op, end-1);
  SFE_Expression(sc_enc, start, op, GF_FALSE);
  curTok = sc_enc->expr_toks[op];
  CHECK_TOK(TOK_CONDSEP);
  SFE_Expression(sc_enc, op+1, end, GF_FALSE);
}

void SFE_Params(ScriptEnc *sc_enc, u32 start, u32 end)
{
  u32 curTok;

  curTok = sc_enc->expr_toks[start];
  if (curTok != TOK_RIGHT_CURVE) {
    SFE_WRITE_INT(sc_enc, 1, 1, "hasParam", NULL);
    SFE_CompoundExpression(sc_enc, start, end, 1);
  } else {
    SFE_WRITE_INT(sc_enc, 0, 1, "hasParam", NULL);
  }
}

#endif  /* !defined(GPAC_DISABLE_BIFS) && !defined(GPAC_DISABLE_BIFS_ENC) && defined(GPAC_HAS_QJS) */

Coverage Report

Created: 2025-10-10 06:58