void rbarray(double *a) { for (int i = 0; i < sz; i++) { if (RB(i) < i) { double t1 = a[i*2], t2 = a[i*2+1]; a[i*2] = a[RB(i)*2]; a[i*2+1] = a[RB(i)*2+1]; a[RB(i)*2] = t1; a[RB(i)*2+1] = t2; } } }
SSIZE_T parse( BYTE *data, SIZE_T len, Descriptors &descriptors ) { SSIZE_T offset = 0; WORD compatibilityLen = RW(data,offset); if (!compatibilityLen) { // Ignore if not present return 2; } WORD descriptorCount = RW(data,offset); printf( "[dsmcc::compatiblity] Compatibility descriptor: dataLen=%ld, descLen=%d, count=%d\n", len, compatibilityLen, descriptorCount ); // Check if len is ok if (len < compatibilityLen) { printf( "[dsmcc::compatiblity] No data available to parse Compatibility descriptor: descLen=%ld, available=%d\n", len, compatibilityLen ); return compatibilityLen+2; } // Parse descriptors for (WORD desc=0; desc<descriptorCount; desc++) { Descriptor desc; desc.type = RB(data,offset); //BYTE dLen = RB(data,offset); offset += 1; desc.specifier = RDW(data,offset); desc.model = RW(data,offset); desc.version = RW(data,offset); // Parse sub descriptors BYTE subCount = RB(data,offset); for (BYTE sub=0; sub<subCount; sub++) { BYTE subType = RB(data,offset); BYTE subLen = RB(data,offset); // AdditionalInformation offset += subLen; printf( "[dsmcc::compatibility] Warning, subdescriptor not parsed: count=%d, type=%x, len=%x\n", subCount, subType, subLen ); } descriptors.push_back( desc ); } return compatibilityLen+2; }
/******************************************************************************* * * Render backend context functions. * ******************************************************************************/ int rb_create_context (struct mem_allocator* specific_allocator, struct rb_context** out_ctxt) { struct mem_allocator* allocator = NULL; struct rb_context* ctxt = NULL; int err = 0; if(!out_ctxt) goto error; allocator = specific_allocator ? specific_allocator : &mem_default_allocator; ctxt = MEM_CALLOC(allocator, 1, sizeof(struct rb_context)); if(!ctxt) goto error; ctxt->allocator = allocator; ref_init(&ctxt->ref); setup_config(&ctxt->config); exit: if(ctxt) *out_ctxt = ctxt; return err; error: if(ctxt) { RB(context_ref_put(ctxt)); ctxt = NULL; } err = -1; goto exit; }
static void release_vertex_array(struct ref* ref) { struct rb_context* ctxt = NULL; struct rb_vertex_array* varray = NULL; assert(ref); varray = CONTAINER_OF(ref, struct rb_vertex_array, ref); ctxt = varray->ctxt; if(ctxt->state_cache.vertex_array_binding == varray->name) RB(bind_vertex_array(ctxt, NULL)); OGL(DeleteVertexArrays(1, &varray->name)); MEM_FREE(ctxt->allocator, varray); RB(context_ref_put(ctxt)); }
static void release_uniform(struct ref* ref) { struct rb_context* ctxt = NULL; struct rb_uniform* uniform = NULL; assert(ref); uniform = CONTAINER_OF(ref, struct rb_uniform, ref); ctxt = uniform->ctxt; if(uniform->program) RB(program_ref_put(uniform->program)); if(uniform->name) MEM_FREE(ctxt->allocator, uniform->name); MEM_FREE(ctxt->allocator, uniform); RB(context_ref_put(ctxt)); }
void PocketPCLandscapeAspect(const uint8 *srcPtr, uint32 srcPitch, uint8 *dstPtr, uint32 dstPitch, int width, int height) { #define RB(x) ((x & redblueMasks[maskUsed])<<8) #define G(x) ((x & greenMasks[maskUsed])<<3) #define P20(x) (((x)>>2)-((x)>>4)) #define P40(x) (((x)>>1)-((x)>>3)) #define P60(x) (((x)>>1)+((x)>>3)) #define P80(x) (((x)>>1)+((x)>>2)+((x)>>4)) #define MAKEPIXEL(rb,g) ((((rb)>>8) & redblueMasks[maskUsed] | ((g)>>3) & greenMasks[maskUsed])) int i,j; unsigned int p1; unsigned int p2; uint16 * inbuf; uint16 * outbuf; inbuf=(uint16 *)srcPtr; outbuf=(uint16 *)dstPtr; uint16 srcPitch16 = (uint16)(srcPitch / sizeof(uint16)); uint16 dstPitch16 = (uint16)(dstPitch / sizeof(uint16)); for (i=0; i<((height)/6); i++) { for (j=0; j<width; j++) { p1=*((uint16*)inbuf+j); inbuf+=srcPitch16; *((uint16*)outbuf+j)=p1; outbuf+=dstPitch16; p2=*((uint16*)inbuf+j); inbuf+=srcPitch16; *((uint16*)outbuf+j)=MAKEPIXEL(P20(RB(p1))+P80(RB(p2)),P20(G(p1))+P80(G(p2))); outbuf+=dstPitch16; p1=p2; p2=*((uint16*)inbuf+j); inbuf+=srcPitch16; *((uint16*)outbuf+j)=MAKEPIXEL(P40(RB(p1))+P60(RB(p2)),P40(G(p1))+P60(G(p2))); outbuf+=dstPitch16; p1=p2; p2=*((uint16*)inbuf+j); inbuf+=srcPitch16; *((uint16*)outbuf+j)=MAKEPIXEL(P60(RB(p1))+P40(RB(p2)),P60(G(p1))+P40(G(p2))); outbuf+=dstPitch16; p1=p2; p2=*((uint16*)inbuf+j); *((uint16*)outbuf+j)=MAKEPIXEL(P80(RB(p1))+P20(RB(p2)),P80(G(p1))+P20(G(p2))); outbuf+=dstPitch16; *((uint16*)outbuf+j)=p2; inbuf=inbuf-srcPitch16*4; outbuf=outbuf-dstPitch16*5; } inbuf=inbuf+srcPitch16*5; outbuf=outbuf+dstPitch16*6; } }
bool b2WheelJoint::SolvePositionConstraints(float32 baumgarte) { B2_NOT_USED(baumgarte); b2Body* bA = m_bodyA; b2Body* bB = m_bodyB; b2Vec2 xA = bA->m_sweep.c; float32 angleA = bA->m_sweep.a; b2Vec2 xB = bB->m_sweep.c; float32 angleB = bB->m_sweep.a; b2Mat22 RA(angleA), RB(angleB); b2Vec2 rA = b2Mul(RA, m_localAnchorA - m_localCenterA); b2Vec2 rB = b2Mul(RB, m_localAnchorB - m_localCenterB); b2Vec2 d = xB + rB - xA - rA; b2Vec2 ay = b2Mul(RA, m_localYAxisA); float32 sAy = b2Cross(d + rA, ay); float32 sBy = b2Cross(rB, ay); float32 C = b2Dot(d, ay); float32 k = m_invMassA + m_invMassB + m_invIA * m_sAy * m_sAy + m_invIB * m_sBy * m_sBy; float32 impulse; if (k != 0.0f) { impulse = - C / k; } else { impulse = 0.0f; } b2Vec2 P = impulse * ay; float32 LA = impulse * sAy; float32 LB = impulse * sBy; xA -= m_invMassA * P; angleA -= m_invIA * LA; xB += m_invMassB * P; angleB += m_invIB * LB; // TODO_ERIN remove need for this. bA->m_sweep.c = xA; bA->m_sweep.a = angleA; bB->m_sweep.c = xB; bB->m_sweep.a = angleB; bA->SynchronizeTransform(); bB->SynchronizeTransform(); return b2Abs(C) <= b2_linearSlop; }
void packet_print(){ short x = (X_SIGN(packet[0]) ? (packet[1] | (0xff << 8)) : packet[1]); short y = (Y_SIGN(packet[0]) ? (packet[2] | (0xff << 8)) : packet[2]); printf("B1=0x%x B2=0x%x B3=0x%x LB=%d MB=%d RB=%d XOV=%d YOV=%d X=%d Y=%d \n", packet[0], packet[1], packet[2], LB(packet[0]), MB(packet[0]), RB(packet[0]), X_OVF(packet[0]), Y_OVF(packet[0]), x, y); counter = 0; }
vector<Point2F> Square::GetCorners() const { vector<Point2F> v; v.reserve(4); v.push_back(LT()); v.push_back(LB()); v.push_back(RT()); v.push_back(RB()); return v; }
/* Extract quantization threshold from preamble sequence */ int32_t extractThreshold(void) { int32_t threshold = 0; int c; for (c = 0; c < 16 /* 2 * srate */; c++) { //XXX: threshold += (int32_t)_ringbuffer.get(c); threshold += (int32_t)RB(c); } return (int32_t)threshold / 16; // 8 * g_srate }
SSIZE_T parse( BYTE *data, SIZE_T /*len*/, Modules &modules, bool skipVersion/*=false*/ ) { SSIZE_T offset = 0; WORD numberOfModules = RW(data,offset); for (int mod=0; mod<numberOfModules; mod++) { Type module; module.id = RW(data,offset); module.size = RDW(data,offset); module.version = (skipVersion) ? 0 : RB(data,offset); BYTE moduleInfoLen = RB(data,offset); if (moduleInfoLen) { module.info.copy( (char *)(data+offset), moduleInfoLen ); offset += moduleInfoLen; } modules.push_back( module ); } return offset; }
int main() { double *a = calloc(sz*2, sizeof(double)); for (int i = 0; i < 4; i++) { scanf("%lf",&a[RB(i)*2]); a[RB(i)*2+1] = 0; } dft(a, false); for (int i = 0; i < sz; i++) { double rr = a[i*2], ii = a[i*2+1]; a[i*2] = rr*rr-ii*ii; a[i*2+1] = rr*ii+rr*ii; } rbarray(a); dft(a, true); for (int i = 0; i < 7; i++) { printf("%.6f\n", a[i*2] / sz); } free(a); return 0; }
bool feedOne(const uint16_t sample) { //XXX: _ringbuffer.increment(); //_ringbuffer.put((int)sample); RB_inc(); RB(0) = (int)sample; if (--_skip < 1) { if (decodePacket(++_samples)) { _skip = 20; return true; } } return false; }
/******************************************************************************* * * Uniform implementation. * ******************************************************************************/ int rb_get_named_uniform (struct rb_context* ctxt, struct rb_program* program, const char* name, struct rb_uniform** out_uniform) { struct rb_uniform* uniform = NULL; GLuint uniform_index = GL_INVALID_INDEX; size_t name_len = 0; int err = 0; if(!ctxt || !program || !name || !out_uniform) goto error; if(!program->is_linked) goto error; OGL(GetUniformIndices(program->name, 1, &name, &uniform_index)); if(uniform_index == GL_INVALID_INDEX) goto error; err = get_active_uniform(ctxt, program, uniform_index, 0, NULL, &uniform); if(err != 0) goto error; name_len = strlen(name) + 1; uniform->name = MEM_ALLOC(ctxt->allocator, sizeof(char) * name_len); if(!uniform->name) goto error; uniform->name = strncpy(uniform->name, name, name_len); uniform->location = OGL(GetUniformLocation(program->name, uniform->name)); exit: *out_uniform = uniform; return err; error: if(uniform) { RB(uniform_ref_put(uniform)); uniform = NULL; } err = -1; goto exit; }
static void release_buffer(struct ref* ref) { struct rb_buffer* buffer = NULL; struct rb_context* ctxt = NULL; ASSERT(ref); buffer = CONTAINER_OF(ref, struct rb_buffer, ref); ctxt = buffer->ctxt; if(buffer->name == ctxt->state_cache.buffer_binding[buffer->binding]) OGL(BindBuffer(buffer->target, 0)); OGL(DeleteBuffers(1, &buffer->name)); MEM_FREE(ctxt->allocator, buffer); RB(context_ref_put(ctxt)); }
void vm_mini_vm(lua_State *L, LClosure *cl, int count, int pseudo_ops_offset) { const Instruction *pc; StkId base; TValue *k; k = cl->p->k; pc = cl->p->code + pseudo_ops_offset; base = L->base; /* process next 'count' ops */ for (; count > 0; count--) { const Instruction i = *pc++; StkId ra = RA(i); lua_assert(base == L->base && L->base == L->ci->base); lua_assert(base <= L->top && L->top <= L->stack + L->stacksize); lua_assert(L->top == L->ci->top || luaG_checkopenop(i)); switch (GET_OPCODE(i)) { case OP_MOVE: { setobjs2s(L, ra, RB(i)); continue; } case OP_LOADK: { setobj2s(L, ra, KBx(i)); continue; } case OP_GETUPVAL: { int b = GETARG_B(i); setobj2s(L, ra, cl->upvals[b]->v); continue; } case OP_SETUPVAL: { UpVal *uv = cl->upvals[GETARG_B(i)]; setobj(L, uv->v, ra); luaC_barrier(L, uv, ra); continue; } case OP_SETTABLE: { Protect(luaV_settable(L, ra, RKB(i), RKC(i))); continue; } default: { luaG_runerror(L, "Bad opcode: opcode=%d", GET_OPCODE(i)); continue; } } } }
SSIZE_T Object::objectKey( const BYTE *data, SIZE_T len, ObjectKeyType &key ) { SSIZE_T off=0; // Object key len BYTE objectKeyLen = RB(data,off); if (objectKeyLen > 4) { throw std::bad_cast(); } assert(len >= SIZE_T(1+objectKeyLen)); // Object key key = RDW( data, off ); //printf( "[dsmcc::Object] Parsing object key: len=%08lx, key=%08lx\n", len, key ); return off; }
void luaV_execute (lua_State *L) { CallInfo *ci = L->ci; LClosure *cl; TValue *k; StkId base; newframe: /* reentry point when frame changes (call/return) */ lua_assert(ci == L->ci); cl = clLvalue(ci->func); k = cl->p->k; base = ci->u.l.base; //printf( "s:%p\n", ci->u.l.savedpc ); /* main loop of interpreter */ for (;;) { Instruction i = *(ci->u.l.savedpc++); StkId ra; if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { Protect(traceexec(L)); } /* warning!! several calls may realloc the stack and invalidate `ra' */ ra = RA(i); lua_assert(base == ci->u.l.base); lua_assert(base <= L->top && L->top < L->stack + L->stacksize); // 命令出力 //printInst( ci->u.l.savedpc - 1 ); vmdispatch (GET_OPCODE(i)) { vmcase(OP_MOVE, setobjs2s(L, ra, RB(i)); ) vmcase(OP_LOADK, TValue *rb = k + GETARG_Bx(i); setobj2s(L, ra, rb); ) vmcase(OP_LOADKX, TValue *rb; lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); rb = k + GETARG_Ax(*ci->u.l.savedpc++); setobj2s(L, ra, rb); )
int test_config(void) { unsigned long byte; subscribe_mouse(); mouse_write_byte(DISABLE_DATA_PACKETS); mouse_write_byte(STATUS_REQUEST); byte = mouse_read(); if(byte == -1) return 1; printf("byte 1: 0x%X\n", byte); printf("Scaling: "); if(!SCALING(byte)) printf("1:1 "); else printf("2:1 "); printf("Data Reporting: "); if(!DATA_REPORTING(byte)) printf("disable "); else printf("enable "); printf("Mode: "); if(!MODE(byte)) printf("remote mode\n\n"); else printf("stream mode\n\n"); if(LB(byte)) printf("LB: pressed "); else printf("LB: not pressed "); if(RB(byte)) printf("RB: pressed "); else printf("RB: not pressed "); if(MB(byte)) printf("MB: pressed "); else printf("MB: not pressed "); byte = mouse_read(); if(byte == -1) return 1; printf("\n byte 2: 0x%X\n", byte); printf("Resolution: %d\n\n", byte); byte = mouse_read(); if(byte == -1) return 1; printf("byte 3: 0x%X\n", byte); printf("Sample Rate: %d\n\n", byte); }
/******************************************************************************* * * Vertex array functions. * ******************************************************************************/ int rb_create_vertex_array (struct rb_context* ctxt, struct rb_vertex_array** out_array) { struct rb_vertex_array* array = NULL; if(!ctxt || !out_array) return -1; array = MEM_ALLOC(ctxt->allocator, sizeof(struct rb_vertex_array)); if(!array) return -1; ref_init(&array->ref); RB(context_ref_get(ctxt)); array->ctxt = ctxt; OGL(GenVertexArrays(1, &array->name)); *out_array = array; return 0; }
/******************************************************************************* * * Private functions. * ******************************************************************************/ int rb_ogl3_create_buffer (struct rb_context* ctxt, const struct rb_ogl3_buffer_desc* desc, const void* init_data, struct rb_buffer** out_buffer) { struct rb_buffer* buffer = NULL; if(!ctxt || !desc || !out_buffer || (desc->target == RB_OGL3_NB_BUFFER_TARGETS) || (desc->usage == RB_USAGE_IMMUTABLE && init_data == NULL)) return -1; buffer = MEM_ALLOC(ctxt->allocator, sizeof(struct rb_buffer)); if(!buffer) return -1; ref_init(&buffer->ref); RB(context_ref_get(ctxt)); buffer->ctxt = ctxt; buffer->target = rb_to_ogl3_buffer_target(desc->target); buffer->usage = rb_to_ogl3_usage(desc->usage); buffer->size = (GLsizei)desc->size; buffer->binding = desc->target; OGL(GenBuffers(1, &buffer->name)); OGL(BindBuffer(buffer->target, buffer->name)); OGL(BufferData(buffer->target, buffer->size, init_data, buffer->usage)); OGL(BindBuffer (buffer->target, ctxt->state_cache.buffer_binding[buffer->binding])); *out_buffer = buffer; return 0; }
Object *Object::parseObject( ResourceManager *resMgr, Module *module, SSIZE_T &off ) { Object *obj; ObjectLocation loc; BYTE buf[BIOP_MAX_HEADER]; SSIZE_T offset = 0; SIZE_T len = module->read( off, buf, BIOP_MAX_HEADER ); if (len < BIOP_MAX_HEADER) { printf( "[dsmcc::Object] Warning: Not enough buffer: len=%ld, offset=%ld\n", len, offset ); return NULL; } DWORD magic = RDW(buf,offset); if (magic != BIOP_MAGIC) { printf( "[dsmcc::Object] Warning: Bad magic number: magic=%x, found=%lx\n", BIOP_MAGIC, magic ); return NULL; } WORD biopVersion = RW(buf,offset); if (biopVersion != BIOP_VER) { printf( "[dsmcc::Object] Warning: Invalid version\n" ); return NULL; } BYTE byteOrder = RB(buf,offset); if (byteOrder) { printf( "[dsmcc::Object] Warning: Invalid byte order\n" ); return NULL; } BYTE msgType = RB(buf,offset); if (msgType) { printf( "[dsmcc::Object] Warning: Invalid type\n" ); return NULL; } // Check BIOP message size DWORD msgSize = RDW(buf,offset); if (module->size()-off-offset < msgSize) { printf( "[dsmcc::Object] Warning: Not enough bytes for BIOP message: msgSize=%ld, rest%ld\n", msgSize, module->size()-off-offset ); return NULL; } // 12 bytes parsed = BIOP_MIN_HEADER offset += objectKey( buf+offset, len-offset, loc.keyID ); DWORD objectKindLen = RDW(buf,offset); if (objectKindLen != 4) { printf( "[dsmcc::Object] Warning: Invalid object kind\n" ); return NULL; } // Chapter 11: The downloadID field of the DownloadDataBlock messages shall have the same value // as the carouselID field of the U-U Object Carousel loc.carouselID = module->downloadID(); loc.moduleID = module->id(); DWORD objectKind = RDW(buf,offset); switch (objectKind) { case BIOP_OBJECT_FILE: obj = new File( loc ); break; case BIOP_OBJECT_DIR: case BIOP_OBJECT_GW: obj = new Directory( loc ); break; // case BIOP_OBJECT_STR: // break; case BIOP_OBJECT_STE: obj = new StreamEvent( loc ); break; default: obj = NULL; printf( "[dsmcc::Object] Warning: BIOP object kind %lx not processed\n", objectKind ); } WORD objectInfoLen = RW(buf,offset); // Update offset (27 bytes parsed = BIOP_MAX_HEADER) off += offset; if (obj && !obj->parse( resMgr, module, off, objectInfoLen )) { delete obj; obj = NULL; } return obj; }
//-------------------------------------------------------------- void testApp::setup(){ cout << "ITU: " << Ritu_db(1000) << "dB => " << Ritu(6000) << endl; cout << "A: " << RA_db(1000) << "dB => " << RA(1000) << endl; cout << "B: " << RB_db(1000) << "dB => " << RB(1000) << endl; cout << "C: " << RC_db(1000) << "dB => " << RC(1000) << endl; cout << "D: " << RD_db(1000) << "dB => " << RD(1000) << endl; /* some standard setup stuff*/ ofEnableAlphaBlending(); ofSetupScreen(); ofBackground(0, 0, 0); ofSetFrameRate(20); ofSetVerticalSync(false); EscalaF = 1.015; /* This is stuff you always need.*/ sampleRate = 44100; /* Sampling Rate */ initialBufferSize = 512; /* Buffer Size. you have to fill this buffer with sound*/ lAudioOut = new float[initialBufferSize];/* outputs */ rAudioOut = new float[initialBufferSize]; lAudioIn = new float[initialBufferSize];/* inputs */ rAudioIn = new float[initialBufferSize]; /* This is a nice safe piece of code */ memset(lAudioOut, 0, initialBufferSize * sizeof(float)); memset(rAudioOut, 0, initialBufferSize * sizeof(float)); memset(lAudioIn, 0, initialBufferSize * sizeof(float)); memset(rAudioIn, 0, initialBufferSize * sizeof(float)); // samp.load(ofToDataPath("sinetest_stepping2.wav")); // samp.load(ofToDataPath("whitenoise2.wav")); // samp.load(ofToDataPath("additive22.wav")); // samp.load(ofToDataPath("pinknoise2.wav")); // samp.setLength(sampleRate*8); // samp.clear(); samp.load(ofToDataPath("sweep_0_22K.wav")); fftSize = 1024; mfft.setup(fftSize, 512, 256); ifft.setup(fftSize, 512, 256); nAverages = 12; oct.setup(sampleRate, fftSize/2, nAverages); mfccs = (double*) malloc(sizeof(double) * 13); mfcc.setup(512, 42, 13, 1, 22050, sampleRate); ofxMaxiSettings::setup(sampleRate, 2, initialBufferSize); soundStream.setDeviceID(0); soundStream.listDevices(); //ofSoundStreamSetup(2,2, this, sampleRate, initialBufferSize, 4);/* Call this last ! */ soundStream.setup(this,2,2, sampleRate, initialBufferSize, 4); //soundStream.setOutput(this); // Determinação de curvas int bins = fftSize/2; CurvaItu = new float[bins]; CurvaA = new float[bins]; CurvaB = new float[bins]; CurvaC = new float[bins]; CurvaD = new float[bins]; for (int i=0; i<bins; i++){ float f = sampleRate/bins; CurvaItu[i] = Ritu(i); CurvaA[i] = RA_db(i); CurvaB[i] = RB(i); CurvaC[i] = RC(i); CurvaD[i] = RD(i); } // Gravação wavWriter.setFormat(1, sampleRate, 16); IsRecording = false; }
void gauss_seidel ( int nx, int ny, int nz, double u[], double f[], double tol, int it_max, double xlo, double ylo, double zlo, double xhi, double yhi, double zhi, int io_interval, char rb []) { double ax, ay, az, d; double dx, dy, dz, rem; double update_norm, unew; int i, it, j, k, it_used = it_max; double *u_old, diff; double omega; /* Initialize the coefficients. */ dx = (xhi - xlo) / ( double ) ( nx - 1 ); dy = (yhi - ylo) / ( double ) ( ny - 1 ); dz = (zhi - zlo) / ( double ) ( nz - 1 ); ax = 1.0 / (dx * dx); ay = 1.0 / (dy * dy); az = 1.0 / (dz * dz); d = - 2.0 / (dx * dx) - 2.0 / (dy * dy) -2.0 / (dz * dz); omega = 1; for ( it = 1; it <= it_max; it++ ) { update_norm = 0.0; /* Compute stencil, and update. bcs already in u. only update interior of domain */ for ( k = 1; k < nz-1; k++ ) { for ( j = 1; j < ny-1; j++ ) { for ( i = 1; i < nx-1; i++ ) { if('r' == RB(i,j,k)){ rem = U(i,j,k); U(i,j,k) = (F(i,j,k) - ( ax * ( U(i-1,j,k) + U(i+1,j,k) ) + ay * ( U(i,j-1,k) + U(i,j+1,k) ) + az * ( U(i,j,k-1) + U(i,j,k+1) ) ) ) / d; diff = ABS(U(i,j,k)-rem); //update_norm = update_norm + diff*diff; /* using 2 norm */ if (diff > update_norm){ /* using max norm */ update_norm = diff; } } } /* end for i */ } /* end for j */ } /* end for k */ for ( k = 1; k < nz-1; k++ ) { for ( j = 1; j < ny-1; j++ ) { for ( i = 1; i < nx-1; i++ ) { if('b' == RB(i,j,k)){ rem = U(i,j,k); U(i,j,k) = (F(i,j,k) - ( ax * ( U(i-1,j,k) + U(i+1,j,k) ) + ay * ( U(i,j-1,k) + U(i,j+1,k) ) + az * ( U(i,j,k-1) + U(i,j,k+1) ) ) ) / d; diff = ABS(U(i,j,k)-rem); //update_norm = update_norm + diff*diff; /* using 2 norm */ if (diff > update_norm){ /* using max norm */ update_norm = diff; } } } /* end for i */ } /* end for j */ } /* end for k */ if (0 == it% io_interval) printf ( " iteration %5d norm update %14.4e\n", it, update_norm ); if ( update_norm <= tol ) { it_used = it; break; } } /* end for it iterations */ printf ( " Final iteration %5d norm update %14.6e\n", it_used, update_norm ); return; }
static void Arith (lua_State *L, StkId ra, const TValue *rb, const TValue *rc, TMS op) { TValue tempb, tempc; const TValue *b, *c; #if LUA_REFCOUNT luarc_newvalue(&tempb); luarc_newvalue(&tempc); if ((b = luaV_tonumber(L, rb, &tempb)) != NULL && (c = luaV_tonumber(L, rc, &tempc)) != NULL) { #else if ((b = luaV_tonumber(rb, &tempb)) != NULL && (c = luaV_tonumber(rc, &tempc)) != NULL) { #endif /* LUA_REFCOUNT */ lua_Number nb = nvalue(b), nc = nvalue(c); #if LUA_REFCOUNT luarc_cleanvalue(&tempb); luarc_cleanvalue(&tempc); #endif /* LUA_REFCOUNT */ switch (op) { case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break; case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break; case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break; case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break; case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break; case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break; case TM_UNM: setnvalue(ra, luai_numunm(nb)); break; default: lua_assert(0); break; } } #if LUA_REFCOUNT else if (!call_binTM(L, rb, rc, ra, op)) { luarc_cleanvalue(&tempb); luarc_cleanvalue(&tempc); luaG_aritherror(L, rb, rc); } #else else if (!call_binTM(L, rb, rc, ra, op)) luaG_aritherror(L, rb, rc); #endif /* LUA_REFCOUNT */ } /* ** some macros for common tasks in `luaV_execute' */ #define runtime_check(L, c) { if (!(c)) break; } #define RA(i) (base+GETARG_A(i)) /* to be used after possible stack reallocation */ #define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i)) #define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i)) #define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \ ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i)) #define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \ ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i)) #define KBx(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i)) #define dojump(L,pc,i) {(pc) += (i); luai_threadyield(L);} #define Protect(x) { L->savedpc = pc; {x;}; base = L->base; } #define arith_op(op,tm) { \ TValue *rb = RKB(i); \ TValue *rc = RKC(i); \ if (ttisnumber(rb) && ttisnumber(rc)) { \ lua_Number nb = nvalue(rb), nc = nvalue(rc); \ setnvalue(ra, op(nb, nc)); \ } \ else \ Protect(Arith(L, ra, rb, rc, tm)); \ } #if LUA_BITFIELD_OPS #define bit_op(op) { \ TValue *rb = RKB(i); \ TValue *rc = RKC(i); \ if (ttisnumber(rb) && ttisnumber(rc)) { \ unsigned int nb = (unsigned int)nvalue(rb), nc = (unsigned int)nvalue(rc); \ setnvalue(ra, nb op nc); \ } \ else \ luaG_aritherror(L, rb, rc); \ } #endif /* LUA_BITFIELD_OPS */ void luaV_execute (lua_State *L, int nexeccalls) { LClosure *cl; StkId base; TValue *k; const Instruction *pc; reentry: /* entry point */ lua_assert(isLua(L->ci)); pc = L->savedpc; cl = &clvalue(L->ci->func)->l; base = L->base; k = cl->p->k; /* main loop of interpreter */ for (;;) { const Instruction i = *pc++; StkId ra; if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { traceexec(L, pc); if (L->status == LUA_YIELD) { /* did hook yield? */ L->savedpc = pc - 1; return; } base = L->base; } /* warning!! several calls may realloc the stack and invalidate `ra' */ ra = RA(i); lua_assert(base == L->base && L->base == L->ci->base); lua_assert(base <= L->top && L->top <= L->stack + L->stacksize); lua_assert(L->top == L->ci->top || luaG_checkopenop(i)); switch (GET_OPCODE(i)) { case OP_MOVE: { setobjs2s(L, ra, RB(i)); continue; } case OP_LOADK: { setobj2s(L, ra, KBx(i)); continue; } case OP_LOADBOOL: { setbvalue(ra, GETARG_B(i)); if (GETARG_C(i)) pc++; /* skip next instruction (if C) */ continue; } case OP_LOADNIL: { TValue *rb = RB(i); do { setnilvalue(rb--); } while (rb >= ra); continue; } case OP_GETUPVAL: { int b = GETARG_B(i); setobj2s(L, ra, cl->upvals[b]->v); continue; } case OP_GETGLOBAL: { TValue g; TValue *rb = KBx(i); #if LUA_REFCOUNT sethvalue2n(L, &g, cl->env); #else sethvalue(L, &g, cl->env); #endif /* LUA_REFCOUNT */ lua_assert(ttisstring(rb)); Protect(luaV_gettable(L, &g, rb, ra)); #if LUA_REFCOUNT setnilvalue(&g); #endif /* LUA_REFCOUNT */ continue; } case OP_GETTABLE: { Protect(luaV_gettable(L, RB(i), RKC(i), ra)); continue; } case OP_SETGLOBAL: { TValue g; #if LUA_REFCOUNT sethvalue2n(L, &g, cl->env); #else sethvalue(L, &g, cl->env); #endif /* LUA_REFCOUNT */ lua_assert(ttisstring(KBx(i))); Protect(luaV_settable(L, &g, KBx(i), ra)); #if LUA_REFCOUNT setnilvalue(&g); #endif /* LUA_REFCOUNT */ continue; } case OP_SETUPVAL: { UpVal *uv = cl->upvals[GETARG_B(i)]; setobj(L, uv->v, ra); luaC_barrier(L, uv, ra); continue; } case OP_SETTABLE: { Protect(luaV_settable(L, ra, RKB(i), RKC(i))); continue; } case OP_NEWTABLE: { int b = GETARG_B(i); int c = GETARG_C(i); sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c))); Protect(luaC_checkGC(L)); continue; } case OP_SELF: { StkId rb = RB(i); setobjs2s(L, ra+1, rb); Protect(luaV_gettable(L, rb, RKC(i), ra)); continue; } case OP_ADD: { arith_op(luai_numadd, TM_ADD); continue; } case OP_SUB: { arith_op(luai_numsub, TM_SUB); continue; } case OP_MUL: { arith_op(luai_nummul, TM_MUL); continue; } case OP_DIV: { arith_op(luai_numdiv, TM_DIV); continue; } case OP_MOD: { arith_op(luai_nummod, TM_MOD); continue; } case OP_POW: { arith_op(luai_numpow, TM_POW); continue; } case OP_UNM: { TValue *rb = RB(i); if (ttisnumber(rb)) { lua_Number nb = nvalue(rb); setnvalue(ra, luai_numunm(nb)); } else { Protect(Arith(L, ra, rb, rb, TM_UNM)); } continue; } case OP_NOT: { int res = l_isfalse(RB(i)); /* next assignment may change this value */ setbvalue(ra, res); continue; } #if LUA_BITFIELD_OPS case OP_BAND: { bit_op(&); continue; } case OP_BOR: { bit_op(|); continue; } case OP_BXOR: { bit_op(^); continue; } case OP_BSHL: { bit_op(<<); continue; } case OP_BSHR: { bit_op(>>); continue; } #endif /* LUA_BITFIELD_OPS */ case OP_LEN: { const TValue *rb = RB(i); switch (ttype(rb)) { case LUA_TTABLE: { setnvalue(ra, cast_num(luaH_getn(hvalue(rb)))); break; } case LUA_TSTRING: { setnvalue(ra, cast_num(tsvalue(rb)->len)); break; } #if LUA_WIDESTRING case LUA_TWSTRING: { setnvalue(ra, cast_num(tsvalue(rb)->len)); break; } #endif /* LUA_WIDESTRING */ default: { /* try metamethod */ Protect( if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN)) luaG_typeerror(L, rb, "get length of"); ) } } continue; } case OP_CONCAT: { int b = GETARG_B(i); int c = GETARG_C(i); Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L)); setobjs2s(L, RA(i), base+b); continue; } case OP_JMP: { dojump(L, pc, GETARG_sBx(i)); continue; } case OP_EQ: { TValue *rb = RKB(i); TValue *rc = RKC(i); Protect( if (equalobj(L, rb, rc) == GETARG_A(i)) dojump(L, pc, GETARG_sBx(*pc)); ) pc++; continue; } case OP_LT: { Protect( if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i)) dojump(L, pc, GETARG_sBx(*pc)); ) pc++; continue; } case OP_LE: { Protect( if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i)) dojump(L, pc, GETARG_sBx(*pc)); ) pc++; continue; }
static int get_active_uniform (struct rb_context* ctxt, struct rb_program* program, GLuint index, GLsizei bufsize, GLchar* buffer, struct rb_uniform** out_uniform) { struct rb_uniform* uniform = NULL; GLsizei uniform_namelen = 0; GLint uniform_size = 0; GLenum uniform_type; int err = 0; if(!ctxt || !program || !out_uniform || bufsize < 0 || (bufsize && !buffer)) goto error; OGL(GetActiveUniform (program->name, index, bufsize, &uniform_namelen, &uniform_size, &uniform_type, buffer)); uniform = MEM_CALLOC(ctxt->allocator, 1, sizeof(struct rb_uniform)); if(!uniform) goto error; ref_init(&uniform->ref); RB(context_ref_get(ctxt)); uniform->ctxt = ctxt; RB(program_ref_get(program)); uniform->program = program; uniform->index = index; uniform->type = uniform_type; uniform->set = get_uniform_setter(uniform_type); if(buffer) { /* Add 1 to namelen <=> include the null character. */ ++uniform_namelen; uniform->name = MEM_ALLOC (ctxt->allocator, sizeof(char) * uniform_namelen); if(!uniform->name) goto error; uniform->name = strncpy(uniform->name, buffer, uniform_namelen); uniform->location = OGL(GetUniformLocation(program->name, uniform->name)); } exit: *out_uniform = uniform; return err; error: if(uniform) { RB(uniform_ref_put(uniform)); uniform = NULL; } err = -1; goto exit; }
int rb_get_uniforms (struct rb_context* ctxt, struct rb_program* prog, size_t* out_nb_uniforms, struct rb_uniform* dst_uniform_list[]) { GLchar* uniform_buffer = NULL; int uniform_buflen = 0; int nb_uniforms = 0; int uniform_id = 0; int err = 0; if(!ctxt || !prog || !out_nb_uniforms) goto error; if(!prog->is_linked) goto error; OGL(GetProgramiv(prog->name, GL_ACTIVE_UNIFORMS, &nb_uniforms)); assert(nb_uniforms >= 0); if(dst_uniform_list) { OGL(GetProgramiv (prog->name, GL_ACTIVE_UNIFORM_MAX_LENGTH, &uniform_buflen)); uniform_buffer = MEM_ALLOC (ctxt->allocator, sizeof(GLchar) * uniform_buflen); if(!uniform_buffer) goto error; for(uniform_id = 0; uniform_id < nb_uniforms; ++uniform_id) { struct rb_uniform* uniform = NULL; err = get_active_uniform (ctxt, prog, uniform_id, uniform_buflen, uniform_buffer, &uniform); if(err != 0) goto error; dst_uniform_list[uniform_id] = uniform; } } exit: if(uniform_buffer) MEM_FREE(ctxt->allocator, uniform_buffer); if(out_nb_uniforms) *out_nb_uniforms = nb_uniforms; return err; error: if(dst_uniform_list) { /* NOTE: uniform_id <=> nb uniforms in dst_uniform_list; */ int i = 0; for(i = 0; i < uniform_id; ++i) { RB(uniform_ref_put(dst_uniform_list[i])); dst_uniform_list[i] = NULL; } } nb_uniforms = 0; err = -1; goto exit; }
int crl2pkcs7_main(int argc, char **argv) { BIO *in = NULL, *out = NULL; PKCS7 *p7 = NULL; PKCS7_SIGNED *p7s = NULL; STACK_OF(OPENSSL_STRING) *certflst = NULL; STACK_OF(X509) *cert_stack = NULL; STACK_OF(X509_CRL) *crl_stack = NULL; X509_CRL *crl = NULL; char *infile = NULL, *outfile = NULL, *prog, *certfile; int i = 0, informat = FORMAT_PEM, outformat = FORMAT_PEM, ret = 1, nocrl = 0; OPTION_CHOICE o; prog = opt_init(argc, argv, crl2pkcs7_options); while ((o = opt_next()) != OPT_EOF) { switch (o) { case OPT_EOF: case OPT_ERR: opthelp: BIO_printf(bio_err, "%s: Use -help for summary.\n", prog); goto end; case OPT_HELP: opt_help(crl2pkcs7_options); ret = 0; goto end; case OPT_INFORM: if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat)) goto opthelp; break; case OPT_OUTFORM: if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &outformat)) goto opthelp; break; case OPT_IN: infile = opt_arg(); break; case OPT_OUT: outfile = opt_arg(); break; case OPT_NOCRL: nocrl = 1; break; case OPT_CERTFILE: if ((certflst == NULL) && (certflst = sk_OPENSSL_STRING_new_null()) == NULL) goto end; if (!sk_OPENSSL_STRING_push(certflst, *(++argv))) { sk_OPENSSL_STRING_free(certflst); goto end; } break; } } argc = opt_num_rest(); argv = opt_rest(); if (!app_load_modules(NULL)) goto end; if (!nocrl) { in = bio_open_default(infile, RB(informat)); if (in == NULL) goto end; if (informat == FORMAT_ASN1) crl = d2i_X509_CRL_bio(in, NULL); else if (informat == FORMAT_PEM) crl = PEM_read_bio_X509_CRL(in, NULL, NULL, NULL); if (crl == NULL) { BIO_printf(bio_err, "unable to load CRL\n"); ERR_print_errors(bio_err); goto end; } } if ((p7 = PKCS7_new()) == NULL) goto end; if ((p7s = PKCS7_SIGNED_new()) == NULL) goto end; p7->type = OBJ_nid2obj(NID_pkcs7_signed); p7->d.sign = p7s; p7s->contents->type = OBJ_nid2obj(NID_pkcs7_data); if (!ASN1_INTEGER_set(p7s->version, 1)) goto end; if ((crl_stack = sk_X509_CRL_new_null()) == NULL) goto end; p7s->crl = crl_stack; if (crl != NULL) { sk_X509_CRL_push(crl_stack, crl); crl = NULL; /* now part of p7 for OPENSSL_freeing */ } if ((cert_stack = sk_X509_new_null()) == NULL) goto end; p7s->cert = cert_stack; if (certflst) for (i = 0; i < sk_OPENSSL_STRING_num(certflst); i++) { certfile = sk_OPENSSL_STRING_value(certflst, i); if (add_certs_from_file(cert_stack, certfile) < 0) { BIO_printf(bio_err, "error loading certificates\n"); ERR_print_errors(bio_err); goto end; } } sk_OPENSSL_STRING_free(certflst); out = bio_open_default(outfile, WB(outformat)); if (out == NULL) goto end; if (outformat == FORMAT_ASN1) i = i2d_PKCS7_bio(out, p7); else if (outformat == FORMAT_PEM) i = PEM_write_bio_PKCS7(out, p7); if (!i) { BIO_printf(bio_err, "unable to write pkcs7 object\n"); ERR_print_errors(bio_err); goto end; } ret = 0; end: BIO_free(in); BIO_free_all(out); PKCS7_free(p7); X509_CRL_free(crl); return (ret); }
void luaV_execute (lua_State *L, int nexeccalls) { LClosure *cl; StkId base; TValue *k; const Instruction *pc; reentry: /* entry point */ lua_assert(isLua(L->ci)); pc = L->savedpc; cl = &clvalue(L->ci->func)->l; base = L->base; k = cl->p->k; /* main loop of interpreter */ for (;;) { const Instruction i = *pc++; StkId ra; if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { traceexec(L, pc); if (L->status == LUA_YIELD) { /* did hook yield? */ L->savedpc = pc - 1; return; } base = L->base; } /* warning!! several calls may realloc the stack and invalidate `ra' */ ra = RA(i); lua_assert(base == L->base && L->base == L->ci->base); lua_assert(base <= L->top && L->top <= L->stack + L->stacksize); lua_assert(L->top == L->ci->top || luaG_checkopenop(i)); switch (GET_OPCODE(i)) { case OP_MOVE: { setobjs2s(L, ra, RB(i)); continue; } case OP_LOADK: { setobj2s(L, ra, KBx(i)); continue; } case OP_LOADBOOL: { setbvalue(ra, GETARG_B(i)); if (GETARG_C(i)) pc++; /* skip next instruction (if C) */ continue; } case OP_LOADNIL: { TValue *rb = RB(i); do { setnilvalue(rb--); } while (rb >= ra); continue; } case OP_GETUPVAL: { int b = GETARG_B(i); setobj2s(L, ra, cl->upvals[b]->v); continue; } case OP_GETGLOBAL: { TValue g; TValue *rb = KBx(i); sethvalue(L, &g, cl->env); lua_assert(ttisstring(rb)); Protect(luaV_gettable(L, &g, rb, ra)); continue; } case OP_GETTABLE: { Protect(luaV_gettable(L, RB(i), RKC(i), ra)); continue; } case OP_SETGLOBAL: { TValue g; sethvalue(L, &g, cl->env); lua_assert(ttisstring(KBx(i))); Protect(luaV_settable(L, &g, KBx(i), ra)); continue; } case OP_SETUPVAL: { UpVal *uv = cl->upvals[GETARG_B(i)]; setobj(L, uv->v, ra); luaC_barrier(L, uv, ra); continue; } case OP_SETTABLE: { Protect(luaV_settable(L, ra, RKB(i), RKC(i))); continue; } case OP_NEWTABLE: { int b = GETARG_B(i); int c = GETARG_C(i); sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c))); Protect(luaC_checkGC(L)); continue; } case OP_SELF: { StkId rb = RB(i); setobjs2s(L, ra+1, rb); Protect(luaV_gettable(L, rb, RKC(i), ra)); continue; } case OP_ADD: { arith_op(luai_numadd, TM_ADD); continue; } case OP_SUB: { arith_op(luai_numsub, TM_SUB); continue; } case OP_MUL: { arith_op(luai_nummul, TM_MUL); continue; } case OP_DIV: { arith_op(luai_numdiv, TM_DIV); continue; } case OP_MOD: { arith_op(luai_nummod, TM_MOD); continue; } case OP_POW: { arith_op(luai_numpow, TM_POW); continue; } case OP_UNM: { TValue *rb = RB(i); if (ttisnumber(rb)) { lua_Number nb = nvalue(rb); setnvalue(ra, luai_numunm(nb)); } else { Protect(luaV_arith(L, ra, rb, rb, TM_UNM)); } continue; } case OP_NOT: { int res = l_isfalse(RB(i)); /* next assignment may change this value */ setbvalue(ra, res); continue; } case OP_LEN: { const TValue *rb = RB(i); switch (ttype(rb)) { case LUA_TTABLE: { setnvalue(ra, cast_num(luaH_getn(hvalue(rb)))); break; } case LUA_TSTRING: { setnvalue(ra, cast_num(tsvalue(rb)->len)); break; } default: { /* try metamethod */ Protect( if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN)) luaG_typeerror(L, rb, "get length of"); ) } } continue; } case OP_CONCAT: { int b = GETARG_B(i); int c = GETARG_C(i); Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L)); setobjs2s(L, RA(i), base+b); continue; } case OP_JMP: { dojump(L, pc, GETARG_sBx(i)); continue; } case OP_EQ: { TValue *rb = RKB(i); TValue *rc = RKC(i); Protect( if (equalobj(L, rb, rc) == GETARG_A(i)) dojump(L, pc, GETARG_sBx(*pc)); ) pc++; continue; } case OP_LT: { Protect( if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i)) dojump(L, pc, GETARG_sBx(*pc)); ) pc++; continue; } case OP_LE: { Protect( if (luaV_lessequal(L, RKB(i), RKC(i)) == GETARG_A(i)) dojump(L, pc, GETARG_sBx(*pc)); ) pc++; continue; }
StkId luaV_execute (lua_State *L) { LClosure *cl; TObject *k; const Instruction *pc; callentry: /* entry point when calling new functions */ L->ci->u.l.pc = &pc; if (L->hookmask & LUA_MASKCALL) luaD_callhook(L, LUA_HOOKCALL, -1); retentry: /* entry point when returning to old functions */ lua_assert(L->ci->state == CI_SAVEDPC || L->ci->state == (CI_SAVEDPC | CI_CALLING)); L->ci->state = CI_HASFRAME; /* activate frame */ pc = L->ci->u.l.savedpc; cl = &clvalue(L->base - 1)->l; k = cl->p->k; /* main loop of interpreter */ for (;;) { const Instruction i = *pc++; StkId base, ra; if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { traceexec(L); if (L->ci->state & CI_YIELD) { /* did hook yield? */ L->ci->u.l.savedpc = pc - 1; L->ci->state = CI_YIELD | CI_SAVEDPC; return NULL; } } /* warning!! several calls may realloc the stack and invalidate `ra' */ base = L->base; ra = RA(i); lua_assert(L->ci->state & CI_HASFRAME); lua_assert(base == L->ci->base); lua_assert(L->top <= L->stack + L->stacksize && L->top >= base); lua_assert(L->top == L->ci->top || GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL || GET_OPCODE(i) == OP_RETURN || GET_OPCODE(i) == OP_SETLISTO); switch (GET_OPCODE(i)) { case OP_MOVE: { setobjs2s(ra, RB(i)); break; } case OP_LOADK: { setobj2s(ra, KBx(i)); break; } case OP_LOADBOOL: { setbvalue(ra, GETARG_B(i)); if (GETARG_C(i)) pc++; /* skip next instruction (if C) */ break; } case OP_LOADNIL: { TObject *rb = RB(i); do { setnilvalue(rb--); } while (rb >= ra); break; } case OP_GETUPVAL: { int b = GETARG_B(i); setobj2s(ra, cl->upvals[b]->v); break; } case OP_GETGLOBAL: { TObject *rb = KBx(i); const TObject *v; lua_assert(ttisstring(rb) && ttistable(&cl->g)); v = luaH_getstr(hvalue(&cl->g), tsvalue(rb)); if (!ttisnil(v)) { setobj2s(ra, v); } else setobj2s(XRA(i), luaV_index(L, &cl->g, rb, 0)); break; } case OP_GETTABLE: { StkId rb = RB(i); TObject *rc = RKC(i); if (ttistable(rb)) { const TObject *v = luaH_get(hvalue(rb), rc); if (!ttisnil(v)) { setobj2s(ra, v); } else setobj2s(XRA(i), luaV_index(L, rb, rc, 0)); } else setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0)); break; } case OP_SETGLOBAL: { lua_assert(ttisstring(KBx(i)) && ttistable(&cl->g)); luaV_settable(L, &cl->g, KBx(i), ra); break; } case OP_SETUPVAL: { int b = GETARG_B(i); setobj(cl->upvals[b]->v, ra); /* write barrier */ break; } case OP_SETTABLE: { luaV_settable(L, ra, RKB(i), RKC(i)); break; } case OP_NEWTABLE: { int b = GETARG_B(i); b = fb2int(b); sethvalue(ra, luaH_new(L, b, GETARG_C(i))); luaC_checkGC(L); break; } case OP_SELF: { StkId rb = RB(i); TObject *rc = RKC(i); runtime_check(L, ttisstring(rc)); setobjs2s(ra+1, rb); if (ttistable(rb)) { const TObject *v = luaH_getstr(hvalue(rb), tsvalue(rc)); if (!ttisnil(v)) { setobj2s(ra, v); } else setobj2s(XRA(i), luaV_index(L, rb, rc, 0)); } else setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0)); break; } case OP_ADD: { TObject *rb = RKB(i); TObject *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { setnvalue(ra, nvalue(rb) + nvalue(rc)); } else Arith(L, ra, rb, rc, TM_ADD); break; } case OP_SUB: { TObject *rb = RKB(i); TObject *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { setnvalue(ra, nvalue(rb) - nvalue(rc)); } else Arith(L, ra, rb, rc, TM_SUB); break; } case OP_MUL: { TObject *rb = RKB(i); TObject *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { setnvalue(ra, nvalue(rb) * nvalue(rc)); } else Arith(L, ra, rb, rc, TM_MUL); break; } case OP_DIV: { TObject *rb = RKB(i); TObject *rc = RKC(i); if (ttisnumber(rb) && ttisnumber(rc)) { setnvalue(ra, nvalue(rb) / nvalue(rc)); } else Arith(L, ra, rb, rc, TM_DIV); break; } case OP_POW: { Arith(L, ra, RKB(i), RKC(i), TM_POW); break; } case OP_UNM: { const TObject *rb = RB(i); TObject temp; if (tonumber(rb, &temp)) { setnvalue(ra, -nvalue(rb)); } else { setnilvalue(&temp); if (!call_binTM(L, RB(i), &temp, ra, TM_UNM)) luaG_aritherror(L, RB(i), &temp); } break; } case OP_NOT: { int res = l_isfalse(RB(i)); /* next assignment may change this value */ setbvalue(ra, res); break; } case OP_CONCAT: { int b = GETARG_B(i); int c = GETARG_C(i); luaV_concat(L, c-b+1, c); /* may change `base' (and `ra') */ base = L->base; setobjs2s(RA(i), base+b); luaC_checkGC(L); break; } case OP_JMP: { dojump(pc, GETARG_sBx(i)); break; } case OP_EQ: { if (equalobj(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++; else dojump(pc, GETARG_sBx(*pc) + 1); break; } case OP_LT: { if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++; else dojump(pc, GETARG_sBx(*pc) + 1); break; } case OP_LE: { if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++; else dojump(pc, GETARG_sBx(*pc) + 1); break; } case OP_TEST: { TObject *rb = RB(i); if (l_isfalse(rb) == GETARG_C(i)) pc++; else { setobjs2s(ra, rb); dojump(pc, GETARG_sBx(*pc) + 1); } break; } case OP_CALL: case OP_TAILCALL: { StkId firstResult; int b = GETARG_B(i); int nresults; if (b != 0) L->top = ra+b; /* else previous instruction set top */ nresults = GETARG_C(i) - 1; firstResult = luaD_precall(L, ra); if (firstResult) { if (firstResult > L->top) { /* yield? */ lua_assert(L->ci->state == (CI_C | CI_YIELD)); (L->ci - 1)->u.l.savedpc = pc; (L->ci - 1)->state = CI_SAVEDPC; return NULL; } /* it was a C function (`precall' called it); adjust results */ luaD_poscall(L, nresults, firstResult); if (nresults >= 0) L->top = L->ci->top; } else { /* it is a Lua function */ if (GET_OPCODE(i) == OP_CALL) { /* regular call? */ (L->ci-1)->u.l.savedpc = pc; /* save `pc' to return later */ (L->ci-1)->state = (CI_SAVEDPC | CI_CALLING); } else { /* tail call: put new frame in place of previous one */ int aux; base = (L->ci - 1)->base; /* `luaD_precall' may change the stack */ ra = RA(i); if (L->openupval) luaF_close(L, base); for (aux = 0; ra+aux < L->top; aux++) /* move frame down */ setobjs2s(base+aux-1, ra+aux); (L->ci - 1)->top = L->top = base+aux; /* correct top */ lua_assert(L->ci->state & CI_SAVEDPC); (L->ci - 1)->u.l.savedpc = L->ci->u.l.savedpc; (L->ci - 1)->u.l.tailcalls++; /* one more call lost */ (L->ci - 1)->state = CI_SAVEDPC; L->ci--; /* remove new frame */ L->base = L->ci->base; } goto callentry; } break; } case OP_RETURN: { CallInfo *ci = L->ci - 1; /* previous function frame */ int b = GETARG_B(i); if (b != 0) L->top = ra+b-1; lua_assert(L->ci->state & CI_HASFRAME); if (L->openupval) luaF_close(L, base); L->ci->state = CI_SAVEDPC; /* deactivate current function */ L->ci->u.l.savedpc = pc; /* previous function was running `here'? */ if (!(ci->state & CI_CALLING)) { lua_assert((ci->state & CI_C) || ci->u.l.pc != &pc); return ra; /* no: return */ } else { /* yes: continue its execution */ int nresults; lua_assert(ci->u.l.pc == &pc && ttisfunction(ci->base - 1) && (ci->state & CI_SAVEDPC)); lua_assert(GET_OPCODE(*(ci->u.l.savedpc - 1)) == OP_CALL); nresults = GETARG_C(*(ci->u.l.savedpc - 1)) - 1; luaD_poscall(L, nresults, ra); if (nresults >= 0) L->top = L->ci->top; goto retentry; } } case OP_FORLOOP: { lua_Number step, idx, limit; const TObject *plimit = ra+1; const TObject *pstep = ra+2; if (!ttisnumber(ra)) luaG_runerror(L, "`for' initial value must be a number"); if (!tonumber(plimit, ra+1)) luaG_runerror(L, "`for' limit must be a number"); if (!tonumber(pstep, ra+2)) luaG_runerror(L, "`for' step must be a number"); step = nvalue(pstep); idx = nvalue(ra) + step; /* increment index */ limit = nvalue(plimit); if (step > 0 ? idx <= limit : idx >= limit) { dojump(pc, GETARG_sBx(i)); /* jump back */ chgnvalue(ra, idx); /* update index */ } break; } case OP_TFORLOOP: { int nvar = GETARG_C(i) + 1; StkId cb = ra + nvar + 2; /* call base */ setobjs2s(cb, ra); setobjs2s(cb+1, ra+1); setobjs2s(cb+2, ra+2); L->top = cb+3; /* func. + 2 args (state and index) */ luaD_call(L, cb, nvar); L->top = L->ci->top; ra = XRA(i) + 2; /* final position of first result */ cb = ra + nvar; do { /* move results to proper positions */ nvar--; setobjs2s(ra+nvar, cb+nvar); } while (nvar > 0); if (ttisnil(ra)) /* break loop? */ pc++; /* skip jump (break loop) */ else dojump(pc, GETARG_sBx(*pc) + 1); /* jump back */ break; } case OP_TFORPREP: { /* for compatibility only */ if (ttistable(ra)) { setobjs2s(ra+1, ra); setobj2s(ra, luaH_getstr(hvalue(gt(L)), luaS_new(L, "next"))); } dojump(pc, GETARG_sBx(i)); break; } case OP_SETLIST: case OP_SETLISTO: { int bc; int n; Table *h; runtime_check(L, ttistable(ra)); h = hvalue(ra); bc = GETARG_Bx(i); if (GET_OPCODE(i) == OP_SETLIST) n = (bc&(LFIELDS_PER_FLUSH-1)) + 1; else { n = L->top - ra - 1; L->top = L->ci->top; } bc &= ~(LFIELDS_PER_FLUSH-1); /* bc = bc - bc%FPF */ for (; n > 0; n--) setobj2t(luaH_setnum(L, h, bc+n), ra+n); /* write barrier */ break; } case OP_CLOSE: { luaF_close(L, ra); break; } case OP_CLOSURE: { Proto *p; Closure *ncl; int nup, j; p = cl->p->p[GETARG_Bx(i)]; nup = p->nups; ncl = luaF_newLclosure(L, nup, &cl->g); ncl->l.p = p; for (j=0; j<nup; j++, pc++) { if (GET_OPCODE(*pc) == OP_GETUPVAL) ncl->l.upvals[j] = cl->upvals[GETARG_B(*pc)]; else { lua_assert(GET_OPCODE(*pc) == OP_MOVE); ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc)); } } setclvalue(ra, ncl); luaC_checkGC(L); break; } } } }