Exemplo n.º 1
0
		void deserialize(const char* attrName, const BoundSetter<T>& setValue, const Context& dc)
		{
			pugi::xml_node attrib = parent.find_child(FindAttribute(attrName));
			if(!attrib)
			{
				SPK_LOG_WARNING("XMLLoader::load(std::istream&) - Missing attribute '" << attrName << "'. Default value will be used");
			}
			if(!dc.isStructuredAttribute())
				loadValue(attrib, setValue);
			else
			{
				// Find item node
				pugi::xml_node item = attrib.child("item");
				unsigned int id = dc.structured.id;
				while(id > 0)
				{
					item = item.next_sibling("item");
					id--;
				}
				
				// Find field node
				pugi::xml_node field = item.find_child(FindAttribute(dc.structured.fieldName));
				if(!field)
				{
					SPK_LOG_WARNING("XMLLoader::load(std::istream&) - Missing field '" << dc.structured.fieldName << "' in attribute '" << attrName << "'. Default value will be used");
				}
				loadValue(field, setValue);
			}
		}
bool ParticleComponentLoader::loadInit(const TiXmlElement& initElement, ParticleComponentDefinitionProto& proto)
{
   const TiXmlElement* pXmlElement = initElement.FirstChildElement("size");
   if ( pXmlElement != NULL )
   {
      proto.initSize = loadValue(*pXmlElement, "value");
      proto.initSizeRange = loadValueRange(*pXmlElement, "range");
   }

   pXmlElement = initElement.FirstChildElement("lifetime");
   if ( pXmlElement != NULL )
   {
      proto.initLifeTime = loadValue(*pXmlElement, "value");
      proto.initLifeTimeRange = loadValueRange(*pXmlElement, "range");
   }

   pXmlElement = initElement.FirstChildElement("velocity");
   if ( pXmlElement != NULL )
   {
      proto.initVelocity = loadVector(*pXmlElement, "value");
      proto.initVelocityRange = loadVectorRange(*pXmlElement, "range");
   }

   return true;
}
Exemplo n.º 3
0
static bool genCmpFP(CompilationUnit *cUnit, MIR *mir, RegLocation rlDest,
                     RegLocation rlSrc1, RegLocation rlSrc2)
{
    bool isDouble;
    int defaultResult;
    bool ltNaNBias;
    RegLocation rlResult;

    switch(mir->dalvikInsn.opCode) {
        case OP_CMPL_FLOAT:
            isDouble = false;
            defaultResult = -1;
            break;
        case OP_CMPG_FLOAT:
            isDouble = false;
            defaultResult = 1;
            break;
        case OP_CMPL_DOUBLE:
            isDouble = true;
            defaultResult = -1;
            break;
        case OP_CMPG_DOUBLE:
            isDouble = true;
            defaultResult = 1;
            break;
        default:
            return true;
    }
    if (isDouble) {
        rlSrc1 = loadValueWide(cUnit, rlSrc1, kFPReg);
        rlSrc2 = loadValueWide(cUnit, rlSrc2, kFPReg);
        dvmCompilerClobberSReg(cUnit, rlDest.sRegLow);
        rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
        loadConstant(cUnit, rlResult.lowReg, defaultResult);
        newLIR2(cUnit, kThumb2Vcmpd, S2D(rlSrc1.lowReg, r1Src2.highReg),
                S2D(rlSrc2.lowReg, rlSrc2.highReg));
    } else {
        rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
        rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
        dvmCompilerClobberSReg(cUnit, rlDest.sRegLow);
        rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
        loadConstant(cUnit, rlResult.lowReg, defaultResult);
        newLIR2(cUnit, kThumb2Vcmps, rlSrc1.lowReg, rlSrc2.lowReg);
    }
    assert(!FPREG(rlResult.lowReg));
    newLIR0(cUnit, kThumb2Fmstat);
    genIT(cUnit, (defaultResult == -1) ? kArmCondGt : kArmCondMi, "");
    newLIR2(cUnit, kThumb2MovImmShift, rlResult.lowReg,
            modifiedImmediate(-defaultResult)); // Must not alter ccodes
    genIT(cUnit, kArmCondEq, "");
    loadConstant(cUnit, rlResult.lowReg, 0);
    storeValue(cUnit, rlDest, rlResult);
    return false;
}
Exemplo n.º 4
0
	void Skin::updateMainScreen()
	{
		// Forced
		isChanged = false;
		loadValue(espMainDescTextFormat, "MAIN_FORMAT");
		if (isChanged) isMainDescChanged = true;
		// ----------------------
		// Forced
		isChanged = false;
		loadValue(espVarsDescTextFormat, "STAT_FORMAT");
		if (isChanged) isVarsDescChanged = true;
		// Others
		loadValue(espViewAlwaysShow, "ALWAYS_SHOW_VIEW");
	}
Exemplo n.º 5
0
void mslLoader::OBJloader::load(const std::string& fileName)
{
    if(fileName.empty())
        return;

    std::ifstream file(fileName.c_str(), std::ios_base::in);
    if(!file)
        return;

    std::string bufferString;
    char buffer_c_string[256];
    const int streamSize = 256;

    mesh.vertices.clear();
    mesh.faces.clear();

    while(!file.eof())
    {
        file.getline(buffer_c_string,streamSize);
        bufferString = buffer_c_string;

        loadValue(bufferString);
    }

}
ComponentDefinitionProto* ParticleComponentLoader::load(const TiXmlElement& element)
{
   std::unique_ptr<ParticleComponentDefinitionProto> proto(new ParticleComponentDefinitionProto());

   if ( element.QueryFloatAttribute("emitrate", &proto->emitRate) != TIXML_SUCCESS )
   {
      return NULL;
   }

   proto->gravity = loadValue(element, "gravity");

   const TiXmlElement* pXmlInitElement = element.FirstChildElement("init");
   if ( pXmlInitElement != NULL )
   {
      loadInit(*pXmlInitElement, *proto);
   }

   const TiXmlElement* pXmlUpdateElement = element.FirstChildElement("update");
   if ( pXmlUpdateElement != NULL )
   {
      loadUpdate(*pXmlUpdateElement, *proto);
   }

   return proto.release();
}
Exemplo n.º 7
0
static bool genInlinedMinMaxInt(CompilationUnit *cUnit, MIR *mir, bool isMin)
{
    RegLocation rlSrc1 = dvmCompilerGetSrc(cUnit, mir, 0);
    RegLocation rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 1);
    rlSrc1 = loadValue(cUnit, rlSrc1, kCoreReg);
    rlSrc2 = loadValue(cUnit, rlSrc2, kCoreReg);
    RegLocation rlDest = inlinedTarget(cUnit, mir, false);
    RegLocation rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
    opRegReg(cUnit, kOpCmp, rlSrc1.lowReg, rlSrc2.lowReg);
    genIT(cUnit, (isMin) ? kArmCondGt : kArmCondLt, "E");
    opRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc2.lowReg);
    opRegReg(cUnit, kOpMov, rlResult.lowReg, rlSrc1.lowReg);
    genBarrier(cUnit);
    storeValue(cUnit, rlDest, rlResult);
    return false;
}
Exemplo n.º 8
0
static bool genArithOpFloat(CompilationUnit *cUnit, MIR *mir,
                            RegLocation rlDest, RegLocation rlSrc1,
                            RegLocation rlSrc2)
{
    int op = kThumbBkpt;
    RegLocation rlResult;

    /*
     * Don't attempt to optimize register usage since these opcodes call out to
     * the handlers.
     */
    switch (mir->dalvikInsn.opcode) {
        case OP_ADD_FLOAT_2ADDR:
        case OP_ADD_FLOAT:
            op = kThumb2Vadds;
            break;
        case OP_SUB_FLOAT_2ADDR:
        case OP_SUB_FLOAT:
            op = kThumb2Vsubs;
            break;
        case OP_DIV_FLOAT_2ADDR:
        case OP_DIV_FLOAT:
            op = kThumb2Vdivs;
            break;
        case OP_MUL_FLOAT_2ADDR:
        case OP_MUL_FLOAT:
            op = kThumb2Vmuls;
            break;
        case OP_REM_FLOAT_2ADDR:
        case OP_REM_FLOAT:
        case OP_NEG_FLOAT: {
            return genArithOpFloatPortable(cUnit, mir, rlDest, rlSrc1,
                                              rlSrc2);
        }
        default:
            return true;
    }
    rlSrc1 = loadValue(cUnit, rlSrc1, kFPReg);
    rlSrc2 = loadValue(cUnit, rlSrc2, kFPReg);
    rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kFPReg, true);
    newLIR3(cUnit, (ArmOpcode)op, rlResult.lowReg, rlSrc1.lowReg,
            rlSrc2.lowReg);
    storeValue(cUnit, rlDest, rlResult);
    return false;
}
Exemplo n.º 9
0
static void genNegFloat(CompilationUnit *cUnit, RegLocation rlDest,
                        RegLocation rlSrc)
{
    RegLocation rlResult;
    rlSrc = loadValue(cUnit, rlSrc, kFPReg);
    rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kFPReg, true);
    newLIR2(cUnit, kThumb2Vnegs, rlResult.lowReg, rlSrc.lowReg);
    storeValue(cUnit, rlDest, rlResult);
}
Exemplo n.º 10
0
/* No select in thumb, so we need to branch.  Thumb2 will do better */
static bool genInlinedMinMaxInt(CompilationUnit *cUnit, MIR *mir, bool isMin)
{
    int offset = offsetof(InterpState, retval);
    RegLocation rlSrc1 = dvmCompilerGetSrc(cUnit, mir, 0);
    RegLocation rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 1);
    int reg0 = loadValue(cUnit, rlSrc1, kCoreReg).lowReg;
    int reg1 = loadValue(cUnit, rlSrc2, kCoreReg).lowReg;
    newLIR2(cUnit, kThumbCmpRR, reg0, reg1);
    ArmLIR *branch1 = newLIR2(cUnit, kThumbBCond, 2,
           isMin ? kArmCondLt : kArmCondGt);
    newLIR2(cUnit, kThumbMovRR, reg0, reg1);
    ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel);
    target->defMask = ENCODE_ALL;
    newLIR3(cUnit, kThumbStrRRI5, reg0, rGLUE, offset >> 2);
    branch1->generic.target = (LIR *)target;
    //TUNING: rewrite this to not clobber
    dvmCompilerClobber(cUnit,reg0);
    return false;
}
Exemplo n.º 11
0
/*
 * Perform a "reg cmp imm" operation and jump to the PCR region if condition
 * satisfies.
 */
static void genNegFloat(CompilationUnit *cUnit, RegLocation rlDest,
                        RegLocation rlSrc)
{
    RegLocation rlResult;
    rlSrc = loadValue(cUnit, rlSrc, kCoreReg);
    rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true);
    opRegRegImm(cUnit, kOpAdd, rlResult.lowReg,
                rlSrc.lowReg, 0x80000000);
    storeValue(cUnit, rlDest, rlResult);
}
Exemplo n.º 12
0
static bool genInlinedAbsFloat(CompilationUnit *cUnit, MIR *mir)
{
    RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
    RegLocation rlDest = inlinedTarget(cUnit, mir, true);
    rlSrc = loadValue(cUnit, rlSrc, kFPReg);
    RegLocation rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kFPReg, true);
    newLIR2(cUnit, kThumb2Vabss, rlResult.lowReg, rlSrc.lowReg);
    storeValue(cUnit, rlDest, rlResult);
    return false;
}
Exemplo n.º 13
0
void testLoadVal(){
    UM_Word normal = 200;
    loadValue(registers, 0, normal);

    printf("Load Verify: ");
    if(registers[0] != normal){
        printf("Expected %u and got: ", normal);
        output(registers, 0);
    }
    else printf("Verified!\n");
}
Exemplo n.º 14
0
hashtable_t* hashtable_load(FILE* file, void* (*loadValue)(const void* key,size_t key_length,off_t location,void* metadata),void* metadata)
{
	int i,j;
	size_t size;
	int magic=-1;
	fread(&magic,sizeof(int),1,file);
	if(magic!=HASHTABLE_MAGIC)
	{
		warn("bad magic %d!=%d",magic,HASHTABLE_MAGIC);
		return NULL;
	}
	fread(&size,sizeof(size_t),1,file);
	hashtable_t* h=hashtable_new_size(size);
	off_t bucketLocation[size];
	size_t bucketLength[size];
	size_t bucketSize[size];
	for(i=0;i<h->size;i++)
	{
		fread(&bucketLocation[i],sizeof(off_t),1,file);
		fread(&bucketLength[i],sizeof(size_t),1,file);
		fread(&bucketSize[i],sizeof(size_t),1,file);
	}
	for(i=0;i<h->size;i++)
	{
		//warn("%d %lld %d %d",i,bucketLocation[i],bucketLength[i],bucketSize[i]);
		if(bucketLength[i]!=0)
		{
			fseeko(file,bucketLocation[i],SEEK_SET);
			char buffer[bucketSize[i]];
			fread(buffer,bucketSize[i],1,file);
			char* ptr=buffer;
			for(j=0;j<bucketLength[i];j++)
			{
				size_t key_length=*(size_t*)ptr;
				ptr+=sizeof(size_t);
				char* key=ptr;
				ptr+=key_length;
				void* value=NULL;
				if(loadValue!=NULL)
				{
					value=loadValue(key,key_length,*(off_t*)ptr,metadata);
					ptr+=sizeof(off_t);
				}
				else
				{
					value=*(void**)ptr;
					ptr+=sizeof(void*);
				}
				hashtable_set(h,key,key_length,value);
			}
		}
	}
	return h;
}
Exemplo n.º 15
0
                        OFixedText :: OFixedText (ODataWidget *pODataWidget, ODataWidget *oODataWidget )
                     : QLabel (pODataWidget ? pODataWidget->WidgetQ() : NULL),
OEHControlValue (pODataWidget,oODataWidget,NO)
{

  connect(ods(),SIGNAL(OnInstanceUpdated()),
          this, SLOT(loadValue()));

  setAlignment(alignment() & ~Qt::AlignVCenter);


}
Exemplo n.º 16
0
void Property::load( const Config& config )
{
  if( config.getType() == Config::Value )
  {
    loadValue( config );
  }
  else if( config.getType() == Config::Map )
  {
    // A special map entry named "Value" means the value of this property, not a child.
    // (If child "Value"does not exist, loadValue() will do nothing.)
    loadValue( config.mapGetChild( "Value" ));

    // Loop over all child Properties.
    int num_property_children = children_.size();
    for( int i = 0; i < num_property_children; i++ )
    {
      Property* child = children_.at( i );
      // Load the child Property with the config under the child property's name.
      child->load( config.mapGetChild( child->getName() ));
    }
  }
}
Exemplo n.º 17
0
	void Skin::updateBaseVars()
	{
		// Forced
		isChanged = false;
		loadValue(espHideScrollMain, "HIDE_MAIN_SCROLL");
		loadValue(espHideScrollActs, "HIDE_ACTS_SCROLL");
		loadValue(espHideScrollVars, "HIDE_STAT_SCROLL");
		loadValue(espHideScrollObjs, "HIDE_OBJS_SCROLL");
		loadValue(espHideScrollAny, "HIDE_ALL_SCROLL");
		loadValue(espHideScrollArrows, "HIDE_SCROLL_ARROWS");
		loadValue(espNoSave, "NOSAVE");
		if (isChanged) isBaseVarsChanged = true;
		// -----------
		isChanged = false;
		loadValue(espUseHtml, "USEHTML");
		if (isChanged) isHtmlModeChanged = true;
		// Others
		loadValue(espDisableScroll, "DISABLESCROLL");
	}
Exemplo n.º 18
0
static bool genInlinedAbsFloat(CompilationUnit *cUnit, MIR *mir)
{
    int offset = offsetof(InterpState, retval);
    RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0);
    int reg0 = loadValue(cUnit, rlSrc, kCoreReg).lowReg;
    int signMask = dvmCompilerAllocTemp(cUnit);
    loadConstant(cUnit, signMask, 0x7fffffff);
    newLIR2(cUnit, kThumbAndRR, reg0, signMask);
    dvmCompilerFreeTemp(cUnit, signMask);
    storeWordDisp(cUnit, rGLUE, offset, reg0);
    //TUNING: rewrite this to not clobber
    dvmCompilerClobber(cUnit, reg0);
    return true;
}
Exemplo n.º 19
0
void Property::load( const YAML::Node& yaml_node )
{
  if( yaml_node.Type() == YAML::NodeType::Scalar )
  {
    loadValue( yaml_node );
  }
  else if( yaml_node.Type() == YAML::NodeType::Map )
  {
    loadChildren( yaml_node );
  }
  else
  {
    printf( "Property::load() TODO: error handling - unexpected YAML type (Sequence) at line %d, column %d.\n",
            yaml_node.GetMark().line, yaml_node.GetMark().column );
  }
}
Exemplo n.º 20
0
      /*! This will automatically start and finish a node to load the data */
      void loadBinaryValue( void * data, size_t size )
      {
        startNode();

        std::string encoded;
        loadValue( encoded );

        auto decoded = base64::decode( encoded );

        if( size != decoded.size() )
          throw Exception("Decoded binary data size does not match specified size");

        std::memcpy( data, decoded.data(), decoded.size() );

        finishNode();
      };
Exemplo n.º 21
0
static void popStackFrame(VM *vm, const int **ip, int *bp, uint returnValues)
{
    uint expectedReturnValues;
    const int *oldIP = *ip;
    int oldBP = *bp;

    *bp = IVPop(&vm->callStack);
    *ip = vmBytecode + IVPop(&vm->callStack);

    expectedReturnValues = (uint)*(*ip)++;
    assert(returnValues >= expectedReturnValues); /* TODO: Fail nicely */
    while (expectedReturnValues--)
    {
        storeValue(vm, *bp, *(*ip)++, loadValue(vm, oldBP, *oldIP++));
    }

    IVSetSize(&vm->stack, (size_t)oldBP);
}
Exemplo n.º 22
0
void Property::loadChildren( const YAML::Node& yaml_node )
{
  if( yaml_node.Type() != YAML::NodeType::Map )
  {
    printf( "Property::loadChildren() TODO: error handling - unexpected YAML type.\n" );
    return;
  }

  // A special map entry named "Value" means the value of this property, not a child.
  if( const YAML::Node *value_node = yaml_node.FindValue( "Value" ))
  {
    loadValue( *value_node );
  }

  // Yaml-cpp's FindValue() and operator[] functions are order-N,
  // according to the docs, so we don't want to use those.  Instead we
  // make a hash table of the existing property children, then loop
  // over all the yaml key-value pairs, looking up their targets by
  // key (name) in the map.  This should keep this function down to
  // order-N or close, instead of order N squared.

  // First make the hash table of all child properties indexed by name.
  QHash<QString, Property*> child_map;
  int num_property_children = children_.size();
  for( int i = 0; i < num_property_children; i++ )
  {
    Property* child = children_.at( i );
    child_map[ child->getName() ] = child;
  }

  // Next loop over all yaml key/value pairs, calling load() on each
  // child whose name we find.
  for( YAML::Iterator it = yaml_node.begin(); it != yaml_node.end(); ++it )
  {
    QString key;
    it.first() >> key;
    QHash<QString, Property*>::const_iterator hash_iter = child_map.find( key );
    if( hash_iter != child_map.end() )
    {
      Property* child = hash_iter.value();
      child->load( it.second() );
    }
  }
}
Exemplo n.º 23
0
void WSI_Appearance::revert()
{
    mUseOpenGlCheckBox->setChecked(loadValue("appearance_use_opengl", false).toBool());
}
Exemplo n.º 24
0
void input::tickUpdate() {
	if (inArr->setRequest(INPUT_ID))
		loadValue();
	return;
}
Exemplo n.º 25
0
static VM *execute(VM *vm)
{
    int maxInstructions = 100;

    while (maxInstructions--)
    {
        int i = *vm->ip;
        int arg = i >> 8;
        if (DEBUG_TRACE)
        {
            traceLine(vm, (int)(vm->ip - vmBytecode));
            fflush(stdout);
        }
        vm->ip++;
        switch ((Instruction)(i & 0xff))
        {
        case OP_NULL:
            storeValue(vm, vm->bp, arg, VNull);
            break;

        case OP_TRUE:
            storeValue(vm, vm->bp, arg, VTrue);
            break;

        case OP_FALSE:
            storeValue(vm, vm->bp, arg, VFalse);
            break;

        case OP_EMPTY_LIST:
            storeValue(vm, vm->bp, arg, VEmptyList);
            break;

        case OP_LIST:
        {
            vref result;
            vref *array;
            vref *write;
            assert(arg);
            array = VCreateArray((size_t)arg);
            for (write = array; arg--; write++)
            {
                vref value = loadValue(vm, vm->bp, *vm->ip++);
                if (value == VFuture)
                {
                    vm->ip += arg;
                    VAbortArray(array);
                    result = VFuture;
                    goto storeList;
                }
                *write = value;
                assert(HeapGetObjectType(*write) != TYPE_FUTURE);
            }
            result = VFinishArray(array);
    storeList:
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_FILELIST:
        {
            vref string = refFromInt(arg);
            vref result;
            if (string == VFuture)
            {
                result = VFuture;
            }
            else
            {
                result = VCreateFilelistGlob(VGetString(string), VStringLength(string));
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_STORE_CONSTANT:
            storeValue(vm, vm->bp, arg, refFromInt(*vm->ip++));
            break;

        case OP_COPY:
            storeValue(vm, vm->bp, *vm->ip++, loadValue(vm, vm->bp, arg));
            break;

        case OP_NOT:
            storeValue(vm, vm->bp, *vm->ip++,
                       VNot(loadValue(vm, vm->bp, arg)));
            break;

        case OP_NEG:
        {
            vref result = VNeg(vm, loadValue(vm, vm->bp, arg));
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_INV:
        {
            vref result = VInv(vm, loadValue(vm, vm->bp, arg));
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_ITER_NEXT:
        {
            vref collection = loadValue(vm, vm->bp, *vm->ip++);
            int indexVariable = *vm->ip++;
            vref index = loadValue(vm, vm->bp, indexVariable);
            vref step = loadValue(vm, vm->bp, *vm->ip++);
            if (index == VFuture || step == VFuture)
            {
                index = VFuture;
                storeValue(vm, vm->bp, indexVariable, index);
                goto iterNextFuture;
            }
            else
            {
                index = VAdd(vm, index, step);
                storeValue(vm, vm->bp, indexVariable, index);
            }
            if (collection == VFuture)
            {
        iterNextFuture:
                assert(0);
            }
            switch (VGetBool(VValidIndex(vm, collection, index)))
            {
            case TRUTHY:
                storeValue(vm, vm->bp, *vm->ip++, VIndexedAccess(vm, collection, index));
                break;
            case FALSY:
                vm->ip += arg - 2;
                break;
            case FUTURE:
                unreachable;
            }
            break;
        }

        case OP_EQUALS:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VEquals(value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_NOT_EQUALS:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VEquals(value1, value2);
            if (!result)
            {
                return vm;
            }
            switch (VGetBool(result))
            {
            case TRUTHY: result = VFalse; break;
            case FALSY: result = VTrue; break;
            case FUTURE: break;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_LESS_EQUALS:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VLessEquals(vm, value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_GREATER_EQUALS:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VLessEquals(vm, value2, value1);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_LESS:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VLess(vm, value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_GREATER:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VLess(vm, value2, value1);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_ADD:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VAdd(vm, value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_SUB:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VSub(vm, value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_MUL:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VMul(vm, value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_DIV:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VDiv(vm, value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_REM:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VRem(vm, value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_CONCAT_LIST:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VConcat(vm, value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_CONCAT_STRING:
        {
            vref result;
            assert(!IVSize(&temp));
            for (i = 0; i < arg; i++)
            {
                IVAdd(&temp, intFromRef(loadValue(vm, vm->bp, *vm->ip++)));
            }
            result = VConcatString((size_t)arg, (vref*)IVGetWritePointer(&temp, 0));
            storeValue(vm, vm->bp, *vm->ip++, result);
            IVSetSize(&temp, 0);
            break;
        }

        case OP_INDEXED_ACCESS:
        {
            vref collection = loadValue(vm, vm->bp, arg);
            vref index = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VIndexedAccess(vm, collection, index);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_RANGE:
        {
            vref value1 = loadValue(vm, vm->bp, arg);
            vref value2 = loadValue(vm, vm->bp, *vm->ip++);
            vref result = VRange(vm, value1, value2);
            if (!result)
            {
                return vm;
            }
            storeValue(vm, vm->bp, *vm->ip++, result);
            break;
        }

        case OP_JUMP:
            vm->ip += arg + 1;
            break;

        case OP_BRANCH_TRUE:
        {
            vref value = loadValue(vm, vm->bp, *vm->ip++);
            VBool b = VGetBool(value);
            vm->base.clonePoints++;
            if (vm->child && vm->base.clonePoints >= vm->child->clonePoints)
            {
                if (vm->base.clonePoints > vm->child->clonePoints)
                {
                    VMDispose(vm->child);
                    vm->child = null;
                    goto branchTrueNoChild;
                }
                assert(!vm->child->fullVM);
                if (b == FUTURE)
                {
                    VMReplaceCloneBranch(vm, vm->ip + arg);
                }
                else
                {
                    uint keepChild;
                    if (b == FALSY)
                    {
                        keepChild = 0;
                    }
                    else
                    {
                        vm->ip += arg;
                        keepChild = 1;
                    }
                    vm->child = VMDisposeBranch((VMBranch*)vm->child, keepChild);
                }
            }
            else
            {
        branchTrueNoChild:
                switch (b)
                {
                case FALSY:
                    break;
                case FUTURE:
                    assert(!vm->child);
                    VMCloneBranch(vm, vm->ip);
                    /* fallthrough */
                case TRUTHY:
                    vm->ip += arg;
                    break;
                }
            }
            break;
        }

        case OP_BRANCH_FALSE:
        {
            vref value = loadValue(vm, vm->bp, *vm->ip++);
            VBool b = VGetBool(value);
            vm->base.clonePoints++;
            if (vm->child && vm->base.clonePoints >= vm->child->clonePoints)
            {
                if (vm->base.clonePoints > vm->child->clonePoints)
                {
                    VMDispose(vm->child);
                    vm->child = null;
                    goto branchFalseNoChild;
                }
                assert(!vm->child->fullVM);
                if (b == FUTURE)
                {
                    VMReplaceCloneBranch(vm, vm->ip);
                    vm->ip += arg;
                }
                else
                {
                    uint keepChild;
                    if (b == FALSY)
                    {
                        vm->ip += arg;
                        keepChild = 0;
                    }
                    else
                    {
                        keepChild = 1;
                    }
                    vm->child = VMDisposeBranch((VMBranch*)vm->child, keepChild);
                }
            }
            else
            {
        branchFalseNoChild:
                switch (b)
                {
                case TRUTHY:
                    break;
                case FUTURE:
                    assert(!vm->child);
                    VMCloneBranch(vm, vm->ip);
                    /* fallthrough */
                case FALSY:
                    vm->ip += arg;
                    break;
                }
            }
            break;
        }

        case OP_RETURN:
            assert(IVSize(&vm->callStack));
            popStackFrame(vm, &vm->ip, &vm->bp, (uint)arg);
            break;

        case OP_RETURN_VOID:
            if (!IVSize(&vm->callStack))
            {
                vm->base.clonePoints++;
                VMHalt(vm, 0);
                return vm;
            }
            popStackFrame(vm, &vm->ip, &vm->bp, 0);
            break;

        case OP_INVOKE:
        {
            vref *values;
            int function = *vm->ip++;
            values = (vref*)IVGetAppendPointer(&vm->stack, (size_t)arg);
            for (i = 0; i < arg; i++)
            {
                *values++ = loadValue(vm, vm->bp, *vm->ip++);
            }
            IVAdd(&vm->callStack, (int)(vm->ip - vmBytecode));
            IVAdd(&vm->callStack, vm->bp);
            initStackFrame(vm, &vm->ip, &vm->bp, function, (uint)arg);
            break;
        }

        case OP_INVOKE_NATIVE:
        {
            nativefunctionref nativeFunction = refFromInt(arg);
            vref value;
            int storeAt;
            assert(!vm->job);
            vm->base.clonePoints++;
            if (vm->child && vm->base.clonePoints >= vm->child->clonePoints)
            {
                VM *child = (VM*)vm->child;
                assert(vm->child->fullVM);
                VMReplaceChild(vm, child);
            }
            value = NativeInvoke(vm, nativeFunction);
            if (vm->idle)
            {
                return vm;
            }
            storeAt = *vm->ip++;
            storeValue(vm, vm->bp, storeAt, value);
            if (vm->job)
            {
                vm->job->storeAt = storeAt;
                vm->idle = true;

                /* TODO: Activate speculative execution */
                JobExecute(vm->job);
                if (unlikely(vm->failMessage))
                {
                    return vm;
                }
                /* vm = VMClone(vm, vm->ip); */
            }
            break;
        }

        case OP_FUNCTION:
        case OP_FUNCTION_UNLINKED:
        case OP_LOAD_FIELD:
        case OP_STORE_FIELD:
        case OP_ITER_NEXT_INDEXED:
        case OP_JUMPTARGET:
        case OP_JUMP_INDEXED:
        case OP_BRANCH_TRUE_INDEXED:
        case OP_BRANCH_FALSE_INDEXED:
        case OP_INVOKE_UNLINKED:
        case OP_UNKNOWN_VALUE:
        case OP_FILE:
        case OP_LINE:
        case OP_ERROR:
        default:
            unreachable;
        }
    }
    return vm;
}
Exemplo n.º 26
0
/*
 * Generate array load
 */
static void genArrayGet(CompilationUnit *cUnit, MIR *mir, OpSize size,
                        RegLocation rlArray, RegLocation rlIndex,
                        RegLocation rlDest, int scale)
{
    RegisterClass regClass = dvmCompilerRegClassBySize(size);
    int lenOffset = OFFSETOF_MEMBER(ArrayObject, length);
    int dataOffset = OFFSETOF_MEMBER(ArrayObject, contents);
    RegLocation rlResult;
    rlArray = loadValue(cUnit, rlArray, kCoreReg);
    rlIndex = loadValue(cUnit, rlIndex, kCoreReg);
    int regPtr;

    /* null object? */
    ArmLIR * pcrLabel = NULL;

    if (!(mir->OptimizationFlags & MIR_IGNORE_NULL_CHECK)) {
        pcrLabel = genNullCheck(cUnit, rlArray.sRegLow,
                                rlArray.lowReg, mir->offset, NULL);
    }

    regPtr = dvmCompilerAllocTemp(cUnit);

    if (!(mir->OptimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
        int regLen = dvmCompilerAllocTemp(cUnit);
        /* Get len */
        loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
        /* regPtr -> array data */
        opRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
        genBoundsCheck(cUnit, rlIndex.lowReg, regLen, mir->offset,
                       pcrLabel);
        dvmCompilerFreeTemp(cUnit, regLen);
    } else {
        /* regPtr -> array data */
        opRegRegImm(cUnit, kOpAdd, regPtr, rlArray.lowReg, dataOffset);
    }
    if ((size == kLong) || (size == kDouble)) {
        if (scale) {
            int rNewIndex = dvmCompilerAllocTemp(cUnit);
            opRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
            opRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
            dvmCompilerFreeTemp(cUnit, rNewIndex);
        } else {
            opRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
        }
        rlResult = dvmCompilerEvalLoc(cUnit, rlDest, regClass, true);

        HEAP_ACCESS_SHADOW(true);
        loadPair(cUnit, regPtr, rlResult.lowReg, rlResult.highReg);
        HEAP_ACCESS_SHADOW(false);

        dvmCompilerFreeTemp(cUnit, regPtr);
        storeValueWide(cUnit, rlDest, rlResult);
    } else {
        rlResult = dvmCompilerEvalLoc(cUnit, rlDest, regClass, true);

        HEAP_ACCESS_SHADOW(true);
        loadBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlResult.lowReg,
                        scale, size);
        HEAP_ACCESS_SHADOW(false);

        dvmCompilerFreeTemp(cUnit, regPtr);
        storeValue(cUnit, rlDest, rlResult);
    }
}
Exemplo n.º 27
0
/*
 * Generate array store
 *
 */
static void genArrayPut(CompilationUnit *cUnit, MIR *mir, OpSize size,
                        RegLocation rlArray, RegLocation rlIndex,
                        RegLocation rlSrc, int scale)
{
    RegisterClass regClass = dvmCompilerRegClassBySize(size);
    int lenOffset = OFFSETOF_MEMBER(ArrayObject, length);
    int dataOffset = OFFSETOF_MEMBER(ArrayObject, contents);

    int regPtr;
    rlArray = loadValue(cUnit, rlArray, kCoreReg);
    rlIndex = loadValue(cUnit, rlIndex, kCoreReg);

    if (dvmCompilerIsTemp(cUnit, rlArray.lowReg)) {
        dvmCompilerClobber(cUnit, rlArray.lowReg);
        regPtr = rlArray.lowReg;
    } else {
        regPtr = dvmCompilerAllocTemp(cUnit);
        genRegCopy(cUnit, regPtr, rlArray.lowReg);
    }

    /* null object? */
    ArmLIR * pcrLabel = NULL;

    if (!(mir->OptimizationFlags & MIR_IGNORE_NULL_CHECK)) {
        pcrLabel = genNullCheck(cUnit, rlArray.sRegLow, rlArray.lowReg,
                                mir->offset, NULL);
    }

    if (!(mir->OptimizationFlags & MIR_IGNORE_RANGE_CHECK)) {
        int regLen = dvmCompilerAllocTemp(cUnit);
        //NOTE: max live temps(4) here.
        /* Get len */
        loadWordDisp(cUnit, rlArray.lowReg, lenOffset, regLen);
        /* regPtr -> array data */
        opRegImm(cUnit, kOpAdd, regPtr, dataOffset);
        genBoundsCheck(cUnit, rlIndex.lowReg, regLen, mir->offset,
                       pcrLabel);
        dvmCompilerFreeTemp(cUnit, regLen);
    } else {
        /* regPtr -> array data */
        opRegImm(cUnit, kOpAdd, regPtr, dataOffset);
    }
    /* at this point, regPtr points to array, 2 live temps */
    if ((size == kLong) || (size == kDouble)) {
        //TODO: need specific wide routine that can handle fp regs
        if (scale) {
            int rNewIndex = dvmCompilerAllocTemp(cUnit);
            opRegRegImm(cUnit, kOpLsl, rNewIndex, rlIndex.lowReg, scale);
            opRegReg(cUnit, kOpAdd, regPtr, rNewIndex);
        } else {
            opRegReg(cUnit, kOpAdd, regPtr, rlIndex.lowReg);
        }
        rlSrc = loadValueWide(cUnit, rlSrc, regClass);

        HEAP_ACCESS_SHADOW(true);
        storePair(cUnit, regPtr, rlSrc.lowReg, rlSrc.highReg);
        HEAP_ACCESS_SHADOW(false);

        dvmCompilerFreeTemp(cUnit, regPtr);
    } else {
        rlSrc = loadValue(cUnit, rlSrc, regClass);

        HEAP_ACCESS_SHADOW(true);
        storeBaseIndexed(cUnit, regPtr, rlIndex.lowReg, rlSrc.lowReg,
                         scale, size);
        HEAP_ACCESS_SHADOW(false);
    }
}
Exemplo n.º 28
0
GUISliderValue::GUISliderValue(xml_node<>* node) : GUIObject(node)
{
	xml_attribute<>* attr;
	xml_node<>* child;

	mMin = 0;
	mMax = 100;
	mValue = 0;
	mLineH = 2;
	mLinePadding = 10;
	mSliderW = 5;
	mSliderH = 30;
	mLineX = 0;
	mLineY = 0;
	mValueStr = NULL;
	mAction = NULL;
	mShowCurr = true;
	mShowRange = false;
	mChangeOnDrag = false;
	mRendered = false;

	mLabel = NULL;
	ConvertStrToColor("white", &mTextColor);
	ConvertStrToColor("white", &mLineColor);
	ConvertStrToColor("blue", &mSliderColor);

	if (!node)
	{
		LOGERR("GUISliderValue created without XML node\n");
		return;
	}

	mLabel = new GUIText(node);
	if(mLabel->Render() < 0)
	{
		delete mLabel;
		mLabel = NULL;
	}

	mAction = new GUIAction(node);

	child = node->first_node("font");
	if (child)
	{
		attr = child->first_attribute("resource");
		if (attr)
			mFont = PageManager::FindResource(attr->value());

		attr = child->first_attribute("color");
		if (attr)
		{
			std::string color = attr->value();
			ConvertStrToColor(color, &mTextColor);
		}
	}

	// Load the placement
	LoadPlacement(node->first_node("placement"), &mRenderX, &mRenderY, &mRenderW);

	child = node->first_node("colors");
	if (child)
	{
		attr = child->first_attribute("line");
		if (attr)
			ConvertStrToColor(attr->value(), &mLineColor);

		attr = child->first_attribute("slider");
		if (attr)
			ConvertStrToColor(attr->value(), &mSliderColor);
	}

	child = node->first_node("data");
	if (child)
	{
		attr = child->first_attribute("variable");
		if (attr)
			mVariable = attr->value();

		attr = child->first_attribute("min");
		if (attr)
		{
			mMinStr = gui_parse_text(attr->value());
			mMin = atoi(mMinStr.c_str());
		}

		attr = child->first_attribute("max");
		if (attr)
		{
			mMaxStr = gui_parse_text(attr->value());
			mMax = atoi(mMaxStr.c_str());
		}

		if (mMin > mMax)
			mMin = mMax;

		attr = child->first_attribute("default");
		if (attr)
		{
			string parsevalue = gui_parse_text(attr->value());
			int def = atoi(parsevalue.c_str());

			if (def < mMin)      def = mMin;
			else if (def > mMax) def = mMax;
			DataManager::SetValue(mVariable, def);
		}

		attr = child->first_attribute("showrange");
		if (attr)
			mShowRange = atoi(attr->value());

		attr = child->first_attribute("showcurr");
		if (attr)
			mShowCurr = atoi(attr->value());

		attr = child->first_attribute("changeondrag");
		if (attr)
			mChangeOnDrag = atoi(attr->value());
	}

	child = node->first_node("dimensions");
	if (child)
	{
		attr = child->first_attribute("lineh");
		if (attr)
		{
			string parsevalue = gui_parse_text(attr->value());
			mLineH = atoi(parsevalue.c_str());
		}

		attr = child->first_attribute("linepadding");
		if (attr)
		{
			string parsevalue = gui_parse_text(attr->value());
			mPadding = atoi(parsevalue.c_str());
		}

		attr = child->first_attribute("sliderw");
		if (attr)
		{
			string parsevalue = gui_parse_text(attr->value());
			mSliderW = atoi(parsevalue.c_str());
		}

		attr = child->first_attribute("sliderh");
		if (attr)
		{
			string parsevalue = gui_parse_text(attr->value());
			mSliderH = atoi(parsevalue.c_str());
		}
	}

	gr_getFontDetails(mFont ? mFont->GetResource() : NULL, (unsigned*) &mFontHeight, NULL);

	if(mShowCurr)
	{
		int maxLen = std::max(strlen(mMinStr.c_str()), strlen(mMaxStr.c_str()));
		mValueStr = new char[maxLen+1];
	}

	loadValue(true);

	mLinePadding = mPadding;
	if (mShowRange)
	{
		int textW = std::max(measureText(mMaxStr), measureText(mMinStr));
		mLinePadding += textW;
	}

	SetRenderPos(mRenderX, mRenderY, mRenderW);
}
Exemplo n.º 29
0
int16 Expression::parseExpr(byte stopToken, byte *type) {
	Stack stack;
	StackFrame stackFrame(stack);
	byte operation;
	int16 brackStart;
	uint32 varBase;

	while (true) {
		getVarBase(varBase);

		stackFrame.push();

		operation = _vm->_game->_script->readByte();
		if ((operation >= OP_ARRAY_INT8) && (operation <= OP_FUNC)) {

			loadValue(operation, varBase, stackFrame);

			if ((stackFrame.pos > 0) && ((stackFrame.opers[-1] == OP_NEG) || (stackFrame.opers[-1] == OP_NOT))) {
				stackFrame.pop();

				if (*stackFrame.opers == OP_NEG) {
					*stackFrame.opers = OP_LOAD_IMM_INT16;
					stackFrame.values[0] = -stackFrame.values[1];
				} else
					*stackFrame.opers = (stackFrame.opers[1] == GOB_FALSE) ? GOB_TRUE : GOB_FALSE;
			}

			if (stackFrame.pos <= 0)
				continue;

			simpleArithmetic1(stackFrame);

			continue;
		} // (op >= OP_ARRAY_INT8) && (op <= OP_FUNC)

		if ((operation == stopToken) || (operation == OP_OR) ||
				(operation == OP_AND) || (operation == OP_END_EXPR)) {
			while (stackFrame.pos >= 2) {
				if ((stackFrame.opers[-2] == OP_BEGIN_EXPR) &&
						((operation == OP_END_EXPR) || (operation == stopToken))) {
					stackFrame.opers[-2] = stackFrame.opers[-1];
					if ((stackFrame.opers[-2] == OP_LOAD_IMM_INT16) || (stackFrame.opers[-2] == OP_LOAD_IMM_STR))
						stackFrame.values[-2] = stackFrame.values[-1];

					stackFrame.pop();

					simpleArithmetic2(stackFrame);

					if (operation != stopToken)
						break;
				}	// if ((stackFrame.opers[-2] == OP_BEGIN_EXPR) && ...)

				for (brackStart = (stackFrame.pos - 2); (brackStart > 0) &&
				    (stack.opers[brackStart] < OP_OR) && (stack.opers[brackStart] != OP_BEGIN_EXPR);
						brackStart--)
					;

				if ((stack.opers[brackStart] >= OP_OR) || (stack.opers[brackStart] == OP_BEGIN_EXPR))
					brackStart++;

				if (complexArithmetic(stack, stackFrame, brackStart))
					break;

			}	// while (stackFrame.pos >= 2)

			if ((operation == OP_OR) || (operation == OP_AND)) {
				if (stackFrame.opers[-1] == OP_LOAD_IMM_INT16) {
					if (stackFrame.values[-1] != 0)
						stackFrame.opers[-1] = GOB_TRUE;
					else
						stackFrame.opers[-1] = GOB_FALSE;
				}

				if (((operation == OP_OR) && (stackFrame.opers[-1] == GOB_TRUE)) ||
				    ((operation == OP_AND) && (stackFrame.opers[-1] == GOB_FALSE))) {
					if ((stackFrame.pos > 1) && (stackFrame.opers[-2] == OP_BEGIN_EXPR)) {
						skipExpr(OP_END_EXPR);
						stackFrame.opers[-2] = stackFrame.opers[-1];
						stackFrame.pop(2);
					} else {
						skipExpr(stopToken);
					}
					operation = _vm->_game->_script->peekByte(-1);
					if ((stackFrame.pos > 0) && (stackFrame.opers[-1] == OP_NOT)) {
						if (stackFrame.opers[0] == GOB_FALSE)
							stackFrame.opers[-1] = GOB_TRUE;
						else
							stackFrame.opers[-1] = GOB_FALSE;

						stackFrame.pop();
					}
				} else
					stackFrame.opers[0] = operation;
			} else
				stackFrame.pop();

			if (operation != stopToken)
				continue;

			getResult(stack.opers[0], stack.values[0], type);

			return 0;
		}		// (operation == stopToken) || (operation == OP_OR) || (operation == OP_AND) || (operation == OP_END_EXPR)

		if ((operation < OP_NEG) || (operation > OP_NOT)) {
			if ((operation < OP_LESS) || (operation > OP_NEQ))
				continue;

			if (stackFrame.pos > 2) {
				if (stackFrame.opers[-2] == OP_ADD) {
					if (stackFrame.opers[-3] == OP_LOAD_IMM_INT16) {
						stackFrame.values[-3] += stackFrame.values[-1];
					} else if (stackFrame.opers[-3] == OP_LOAD_IMM_STR) {
						if ((char *)decodePtr(stackFrame.values[-3]) != _resultStr) {
							strcpy(_resultStr, (char *)decodePtr(stackFrame.values[-3]));
							stackFrame.values[-3] = encodePtr((byte *)_resultStr, kResStr);
						}
						strcat(_resultStr, (char *)decodePtr(stackFrame.values[-1]));
					}
					stackFrame.pop(2);

				} else if (stackFrame.opers[-2] == OP_SUB) {
					stackFrame.values[-3] -= stackFrame.values[-1];
					stackFrame.pop(2);
				} else if (stackFrame.opers[-2] == OP_BITOR) {
					stackFrame.values[-3] |= stackFrame.values[-1];
					stackFrame.pop(2);
				}
			}
		}
		*stackFrame.opers = operation;
	}
}
Exemplo n.º 30
0
void GUISliderValue::SetPageFocus(int inFocus)
{
	if (inFocus)
		loadValue();
}