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; }
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; }
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"); }
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(); }
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; }
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; }
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); }
/* 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; }
/* * 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); }
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; }
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"); }
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; }
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); }
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() )); } } }
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"); }
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; }
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 ); } }
/*! 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(); };
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); }
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() ); } } }
void WSI_Appearance::revert() { mUseOpenGlCheckBox->setChecked(loadValue("appearance_use_opengl", false).toBool()); }
void input::tickUpdate() { if (inArr->setRequest(INPUT_ID)) loadValue(); return; }
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; }
/* * 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); } }
/* * 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); } }
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); }
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; } }
void GUISliderValue::SetPageFocus(int inFocus) { if (inFocus) loadValue(); }