gbx_exec_loop.c

Gambas is a graphical development environment based on a Basic interpreter, like Visual Basic. It us

_JUMP_IF_FALSE:

  VALUE_conv(&SP[-1], T_BOOLEAN);
  SP--;
  if (SP->_boolean.value == 0)
  {
    PC += (signed short)PC[1] + 2;
    goto _MAIN;
  }

  goto _NEXT2;

/*-----------------------------------------------*/

_RETURN:

  if (GET_XX())
  {
    VALUE_conv(&SP[-1], FP->type);
    SP--;
    *RP = *SP;

    EXEC_leave(FALSE);
  }
  else
  {
    VALUE_default(RP, FP->type);
    EXEC_leave(FALSE);
  }

  if (PC == NULL)
    return;

  goto _NEXT;

/*-----------------------------------------------*/

_CALL:

  {
    static void *call_jump[7] =
      { &&_CALL_NULL, &&_CALL_NATIVE, &&_CALL_PRIVATE, &&_CALL_PUBLIC,
        &&_CALL_SNATIVE, &&_CALL_SPUBLIC, &&_CALL_UNKNOWN };

    register VALUE *val;

    ind = GET_3X();
    val = &SP[-(ind + 1)];

    /*EXEC_FUNCTION exec_func;*/

    if (!TYPE_is_function(val->type))
    {
      bool defined;

      /* On devrait plut� cr�r une FUNCTION sur la pile */

      EXEC_object(val, &EXEC.class, (OBJECT **)&EXEC.object, &defined);
      EXEC.drop = PCODE_is_void(code);
      EXEC.nparam = ind;

      EXEC_class(); //class, object, ind, PCODE_is_void(code));
      goto _NEXT;
    }

    EXEC.class = val->_function.class;
    EXEC.object = val->_function.object;
    EXEC.drop = PCODE_is_void(code);
    EXEC.nparam = ind;

    if (!val->_function.defined)
      *PC |= CODE_CALL_VARIANT;

    goto *call_jump[(int)val->_function.kind];

  _CALL_NULL:

    while (ind > 0)
    {
      POP();
      ind--;
    }

    POP();

    if (!PCODE_is_void(code))
    {
      /*VALUE_default(SP, (TYPE)(val->_function.function));*/
      SP->type = T_NULL;
      SP++;
    }

    goto _NEXT;

  _CALL_NATIVE:

    EXEC.native = TRUE;
    EXEC.index = val->_function.index;
    EXEC.desc = &EXEC.class->table[EXEC.index].desc->method;
    EXEC.use_stack = TRUE;

    goto __EXEC_NATIVE;

  _CALL_PRIVATE:

    EXEC.native = FALSE;
    EXEC.index = val->_function.index;

    goto __EXEC_ENTER;

  _CALL_PUBLIC:

    EXEC.native = FALSE;
    EXEC.desc = &EXEC.class->table[val->_function.index].desc->method;
    EXEC.index = (int)(EXEC.desc->exec);
    EXEC.class = EXEC.desc->class;

    goto __EXEC_ENTER;

  _CALL_SNATIVE:

    EXEC.native = TRUE;
    EXEC.desc = &(EXEC.class)->special[val->_function.index]->method;
    EXEC.use_stack = TRUE;

    goto __EXEC_NATIVE;

  _CALL_SPUBLIC:

    EXEC.native = FALSE;
    EXEC.desc = &EXEC.class->special[val->_function.index]->method;
    EXEC.index = (int)(EXEC.desc->exec);
    EXEC.class = EXEC.desc->class;

  __EXEC_ENTER:

    EXEC_enter();
    goto _MAIN;

  _CALL_UNKNOWN:

    EXEC.native = TRUE;
    EXEC.desc = &EXEC.class->special[SPEC_UNKNOWN]->method;
    EXEC.use_stack = TRUE;
    EXEC.index = val->_function.index;
    EXEC.property = FALSE;

  __EXEC_NATIVE:

    //EXEC.class = EXEC.desc->class;
    EXEC_native();
    goto _NEXT;
  }

/*-----------------------------------------------*/

_JUMP_FIRST:

  PC[1] &= 0xFF00;
  goto _NEXT;

/*-----------------------------------------------*/

_JUMP_NEXT:

  {
    static void *jn_jump[5] = { &&_JN_START, &&_JN_NEXT_1, &&_JN_NEXT_2, &&_JN_NEXT_3, &&_JN_NEXT_4 };

    VALUE *end = &BP[PC[-1] & 0xFF];
    VALUE *inc = end + 1;
    register VALUE *val = &BP[PC[2] & 0xFF];

    goto *jn_jump[GET_XX()];

  _JN_START:

    type = val->type;

		// The step value must stay negative, even if the loop variable is a byte

    if (TYPE_is_integer(type))
    {
    	VALUE_conv(&SP[-1], T_INTEGER);
  	}
    else
    {
    	VALUE_conv(&SP[-1], type);
		}

   	VALUE_conv(&SP[-2], type);

    ind = PC[-1] & 0xFF;

    _pop_ctrl(ind + 1); /* modifie val ! */
    _pop_ctrl(ind);

    val = &BP[PC[2] & 0xFF];

    if (TYPE_is_integer(type))
    {
      if (inc->_integer.value > 0)
      {
        *PC |= 1;
        goto _JN_TEST_1;
      }
      else
      {
        *PC |= 2;
        goto _JN_TEST_2;
      }
    }
    else if (TYPE_is_float(type))
    {
      if (inc->_float.value > 0)
      {
        *PC |= 3;
        goto _JN_TEST_3;
      }
      else
      {
        *PC |= 4;
        goto _JN_TEST_4;
      }
    }
    else
      THROW(E_TYPE, "Number", TYPE_get_name(type));

  _JN_NEXT_1:

    val->_integer.value += inc->_integer.value;

  _JN_TEST_1:

    if (val->_integer.value <= end->_integer.value)
      goto _NEXT3;

    goto _JN_END;

  _JN_NEXT_2:

    val->_integer.value += inc->_integer.value;

  _JN_TEST_2:

    if (val->_integer.value >= end->_integer.value)
      goto _NEXT3;

    goto _JN_END;

  _JN_NEXT_3:

    val->_float.value += inc->_float.value;

  _JN_TEST_3:

    if (val->_float.value <= end->_float.value)
      goto _NEXT3;

    goto _JN_END;

  _JN_NEXT_4:

    val->_float.value += inc->_float.value;

  _JN_TEST_4:

    if (val->_float.value >= end->_float.value)
      goto _NEXT3;

    goto _JN_END;

  _JN_END:

    PC += (signed short)PC[1] + 2;
    goto _MAIN;
  }

/*-----------------------------------------------*/

_ENUM_FIRST:

  _pop_ctrl(GET_XX());
  EXEC_enum_first(code);
  goto _NEXT;

/*-----------------------------------------------*/

_ENUM_NEXT:

  if (EXEC_enum_next(code))
    goto _JUMP;
  else
    goto _NEXT2;

/*-----------------------------------------------*/

_PUSH_CLASS:

  SP->type = T_CLASS;
  SP->_class.class = CP->load->class_ref[GET_7XX()];
  SP++;

  goto _NEXT;

/*-----------------------------------------------*/

_PUSH_FUNCTION:

  /*ind = GET_7XX();*/

  SP->type = T_FUNCTION;
  SP->_function.class = CP;
  SP->_function.object = OP;
  SP->_function.kind = FUNCTION_PRIVATE;
  SP->_function.index = GET_7XX();
  SP->_function.defined = TRUE;

  OBJECT_REF(OP, "exec_loop._PUSH_FUNCTION (FUNCTION)");
  SP++;

  goto _NEXT;

/*-----------------------------------------------*/

  {
    CLASS_VAR *var;
    char *addr;

_PUSH_DYNAMIC:

    var = &CP->load->dyn[GET_7XX()];

    if (OP == NULL)
      THROW(E_ILLEGAL);

    addr = &OP[var->pos];
    goto __READ;

_PUSH_STATIC:

    var = &CP->load->stat[GET_7XX()];
    addr = (char *)CP->stat + var->pos;
    goto __READ;

__READ:

    VALUE_class_read(CP, SP, addr, var->type);

    PUSH();
    goto _NEXT;


_POP_DYNAMIC:

    var = &CP->load->dyn[GET_7XX()];

    if (OP == NULL)
      THROW(E_ILLEGAL);

    addr = &OP[var->pos];
    goto __WRITE;

_POP_STATIC:

    var = &CP->load->stat[GET_7XX()];
    addr = (char *)CP->stat + var->pos;
    goto __WRITE;

__WRITE:

    VALUE_class_write(CP, &SP[-1], addr, var->type);
    POP();

    goto _NEXT;

  }

/*-----------------------------------------------*/

_PUSH_CONST:

  ind = GET_UXXX();

	CLASS_CONST *cc = &CP->load->cst[ind];

	if (cc->type == T_FLOAT)
	{
		SP->type = cc->type;
		SP->_float.value = cc->_float.value;
	}
	else if (cc->type == T_STRING)
	{
		SP->type = T_CSTRING;
		SP->_string.addr = (char *)cc->_string.addr;
		SP->_string.start = 0;
		SP->_string.len = cc->_string.len;
	}
	else if (cc->type == T_CSTRING)
	{
		SP->type = T_CSTRING;
		SP->_string.addr = (char *)LOCAL_gettext(cc->_string.addr);
		SP->_string.start = 0;
		SP->_string.len = strlen(SP->_string.addr);
	}
	else
	{
		SP->type = cc->type;
		SP->_integer.value = cc->_integer.value;
	}

  SP++;

  goto _NEXT;

/*-----------------------------------------------*/

_PUSH_QUICK:

  SP->type = T_INTEGER;
  SP->_integer.value = GET_XXX();
  SP++;
  goto _NEXT;

/*-----------------------------------------------*/

_TRY:

  ERROR_clear();
  EP = SP;
  ET = EC;
  EC = PC + (signed short)PC[1] + 2;

  #if DEBUG_ERROR
  printf("TRY %p\n", EC);
  #endif

  goto _NEXT2;

/*-----------------------------------------------*/

_END_TRY:

  #if DEBUG_ERROR
  printf("END TRY %p\n", PC);
  #endif

  EP = NULL;
  EC = ET;
  ET = NULL;
  goto _NEXT;

/*-----------------------------------------------*/

_CATCH:

  if (EC == NULL)
    goto _NEXT;
  else
    goto _RETURN;
}