void* getFieldValue(int location, int type) { char buffer[8]; long retval = 0; switch(type) { case INT: dread(buffer, location, 2); retval = (long) getSignedInt(buffer); break; case UINT: dread(buffer, location, 2); retval = (long) getUnsignedInt(buffer); break; case ULINT: dread(buffer, location, 3); retval = getUnsignedLong(buffer); break; case DATE: dread(buffer, location, 5); //printf("DEBUG: getFieldValue DATE[%04x] - %d %d %d %d %d\n", location, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4]); retval = (long) strDate(buffer); break; case CHAR: default: dread(buffer, location, 1); retval = (long) buffer[0]; break; } return (void*) retval; }
AXIR AXLexer::getIR(unsigned int index, int *len){ AXIR ir; unsigned short typeWord = 0; bool isLong = 0; typeWord = getUnsignedShort(); ir.type = typeWord & 0x1FFF;/* CSTYPE */ ir.isTop = typeWord & 0x2000;/* EXFLG_1 */ ir.isSepr = typeWord & 0x4000;/* EXFLG_2 */ isLong = typeWord & 0x8000;/* If the IR code of these bytes is Long */ if(isLong){ ir.code = getUnsignedInt(); *len = *len + 6; }else{ ir.code = getUnsignedShort(); *len = *len + 4; } /* TYPE_CMPCMD has an address which is for jumping to else or its end */ if(ir.type == TYPE_CMPCMD){ JumpToQueue rewriter; *len = *len + 2; rewriter.jumpto = index; ir.jump = 0; rewriter.bytes = getUnsignedShort() * 2 + *len; jumpToQueue.push_back(rewriter); } return ir; }
void rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, NativeType* paramTypes, FFIStorage* paramStorage, void** ffiValues, VALUE* callbackParameters, int callbackCount, VALUE enums) { VALUE callbackProc = Qnil; FFIStorage* param = ¶mStorage[0]; int i, argidx, cbidx, argCount; if (paramCount != -1 && paramCount != argc) { if (argc == (paramCount - 1) && callbackCount == 1 && rb_block_given_p()) { callbackProc = rb_block_proc(); } else { rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, paramCount); } } argCount = paramCount != -1 ? paramCount : argc; for (i = 0, argidx = 0, cbidx = 0; i < argCount; ++i) { int type = argidx < argc ? TYPE(argv[argidx]) : T_NONE; ffiValues[i] = param; switch (paramTypes[i]) { case NATIVE_INT8: param->s8 = getSignedInt(argv[argidx++], type, -128, 127, "char", Qnil); ADJ(param, INT8); break; case NATIVE_INT16: param->s16 = getSignedInt(argv[argidx++], type, -0x8000, 0x7fff, "short", Qnil); ADJ(param, INT16); break; case NATIVE_INT32: case NATIVE_ENUM: param->s32 = getSignedInt(argv[argidx++], type, -0x80000000, 0x7fffffff, "int", enums); ADJ(param, INT32); break; case NATIVE_BOOL: if (type != T_TRUE && type != T_FALSE) { rb_raise(rb_eTypeError, "wrong argument type (expected a boolean parameter)"); } param->s8 = argv[argidx++] == Qtrue; ADJ(param, INT8); break; case NATIVE_UINT8: param->u8 = getUnsignedInt(argv[argidx++], type, 0xff, "unsigned char"); ADJ(param, INT8); break; case NATIVE_UINT16: param->u16 = getUnsignedInt(argv[argidx++], type, 0xffff, "unsigned short"); ADJ(param, INT16); break; case NATIVE_UINT32: /* Special handling/checking for unsigned 32 bit integers */ param->u32 = getUnsignedInt32(argv[argidx++], type); ADJ(param, INT32); break; case NATIVE_INT64: if (type != T_FIXNUM && type != T_BIGNUM) { rb_raise(rb_eTypeError, "Expected an Integer parameter"); } param->i64 = NUM2LL(argv[argidx]); ADJ(param, INT64); ++argidx; break; case NATIVE_UINT64: if (type != T_FIXNUM && type != T_BIGNUM) { rb_raise(rb_eTypeError, "Expected an Integer parameter"); } param->u64 = NUM2ULL(argv[argidx]); ADJ(param, INT64); ++argidx; break; case NATIVE_LONG: *(ffi_sarg *) param = NUM2LONG(argv[argidx]); ADJ(param, LONG); ++argidx; break; case NATIVE_ULONG: *(ffi_arg *) param = NUM2ULONG(argv[argidx]); ADJ(param, LONG); ++argidx; break; case NATIVE_FLOAT32: if (type != T_FLOAT && type != T_FIXNUM) { rb_raise(rb_eTypeError, "Expected a Float parameter"); } param->f32 = (float) NUM2DBL(argv[argidx]); ADJ(param, FLOAT32); ++argidx; break; case NATIVE_FLOAT64: if (type != T_FLOAT && type != T_FIXNUM) { rb_raise(rb_eTypeError, "Expected a Float parameter"); } param->f64 = NUM2DBL(argv[argidx]); ADJ(param, FLOAT64); ++argidx; break; case NATIVE_STRING: param->ptr = getString(argv[argidx++], type); ADJ(param, ADDRESS); break; case NATIVE_POINTER: case NATIVE_BUFFER_IN: case NATIVE_BUFFER_OUT: case NATIVE_BUFFER_INOUT: param->ptr = getPointer(argv[argidx++], type); ADJ(param, ADDRESS); break; case NATIVE_FUNCTION: case NATIVE_CALLBACK: if (callbackProc != Qnil) { param->ptr = callback_param(callbackProc, callbackParameters[cbidx++]); } else { param->ptr = callback_param(argv[argidx], callbackParameters[cbidx++]); ++argidx; } ADJ(param, ADDRESS); break; case NATIVE_STRUCT: ffiValues[i] = getPointer(argv[argidx++], type); break; default: rb_raise(rb_eArgError, "Invalid parameter type: %d", paramTypes[i]); } } }
static long rbffi_GetLongValue(int idx, VALUE* argv, FunctionType* fnInfo) { VALUE value = argv[idx]; NativeType nativeType = fnInfo->nativeParameterTypes[idx]; int type = TYPE(value); switch (nativeType) { case NATIVE_INT8: return getSignedInt(value, type, -128, 127, "char", fnInfo->rbEnums); case NATIVE_INT16: return getSignedInt(value, type, -0x8000, 0x7fff, "short", fnInfo->rbEnums); case NATIVE_INT32: case NATIVE_ENUM: return getSignedInt(value, type, -0x80000000, 0x7fffffff, "int", fnInfo->rbEnums); case NATIVE_BOOL: if (type != T_TRUE && type != T_FALSE) { rb_raise(rb_eTypeError, "Expected a Boolean parameter"); } return RTEST(value) ? 1 : 0; case NATIVE_UINT8: return getUnsignedInt(value, type, 0xff, "unsigned char"); case NATIVE_UINT16: return getUnsignedInt(value, type, 0xffff, "unsigned short"); case NATIVE_UINT32: /* Special handling/checking for unsigned 32 bit integers */ return getUnsignedInt32(value, type); case NATIVE_LONG: return NUM2LONG(value); case NATIVE_ULONG: return NUM2ULONG(value); #ifdef __x86_64__ case NATIVE_INT64: if (type != T_FIXNUM && type != T_BIGNUM) { rb_raise(rb_eTypeError, "Expected an Integer parameter"); } return NUM2LL(value); case NATIVE_UINT64: if (type != T_FIXNUM && type != T_BIGNUM) { rb_raise(rb_eTypeError, "Expected an Integer parameter"); } return NUM2ULL(value); #endif case NATIVE_STRING: return (intptr_t) getString(value, type); case NATIVE_POINTER: case NATIVE_BUFFER_IN: case NATIVE_BUFFER_OUT: case NATIVE_BUFFER_INOUT: return (intptr_t) getPointer(value, type); default: rb_raise(rb_eTypeError, "unsupported integer type %d", nativeType); return 0; } }
unsigned int getInterval() { char buffer[2]; dread(buffer, L_INTERVAL, 2); return getUnsignedInt(buffer); }
unsigned int getRecordsStored() { char buffer[2]; dread(buffer, L_RECORDS, 2); return getUnsignedInt(buffer); }
unsigned int getLocationOfCurrent() { char buffer[2]; dread(buffer, L_CURRENT, 2); return getUnsignedInt(buffer); }