///; Process this file with uvgen.scm to generate uvect.c ///; Lines beginning with '///' are directives for ugven.scm. ///;; Prologue ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ///(define *tmpl-prologue* (list /* * uvector.c.tmpl - uniform vector support code template * * Copyright (c) 1999-2007 Shiro Kawai, All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the authors nor the names of its contributors * may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include /* for memmove() */ #include #include #include #include #include #include #include #define EXTUVECTOR_EXPORTS #include "gauche/uvector.h" #include "uvectorP.h" /* * Generic aliasing */ ScmObj Scm_UVectorAlias(ScmClass *klass, ScmUVector *v, ScmSmallInt start, ScmSmallInt end) { ScmSmallInt len = SCM_UVECTOR_SIZE(v), dstsize; SCM_CHECK_START_END(start, end, len); int reqalign = Scm_UVectorElementSize(klass); int srcalign = Scm_UVectorElementSize(Scm_ClassOf(SCM_OBJ(v))); if (reqalign < 0) { Scm_Error("uvector-alias requires uniform vector class, but got %S", klass); } if ((start*srcalign)%reqalign != 0 || (end*srcalign)%reqalign != 0) { Scm_Error("aliasing %S of range (%d, %d) to %S doesn't satisfy alignment requirement.", Scm_ClassOf(SCM_OBJ(v)), start, end, klass); } if (reqalign >= srcalign) dstsize = (end-start) / (reqalign/srcalign); else dstsize = (end-start) * (srcalign/reqalign); SCM_RETURN(Scm_MakeUVectorFull(klass, dstsize, (char*)v->elements + start*srcalign, SCM_UVECTOR_IMMUTABLE_P(v), SCM_UVECTOR_OWNER(v))); } /*=========================================================== * Helper functions */ static void size_mismatch(const char *name, ScmObj x, ScmObj y) { Scm_Error("%s: argument object sizes do not match: %S vs %S", name, x, y); } /* many numeric op procedures takes either uvector, vector, list or a constant number as the second arg. this factors out the common code. */ typedef enum { ARGTYPE_UVECTOR, ARGTYPE_VECTOR, ARGTYPE_LIST, ARGTYPE_CONST } ArgType; static ArgType arg2_check(const char *name, ScmObj x, ScmObj y, int const_ok) { int size = SCM_UVECTOR_SIZE(x); if (SCM_UVECTORP(y)) { if (SCM_UVECTOR_SIZE(y) != size) size_mismatch(name, SCM_OBJ(x), y); return ARGTYPE_UVECTOR; } else if (SCM_VECTORP(y)) { if (SCM_VECTOR_SIZE(y) != size) size_mismatch(name, SCM_OBJ(x), y); return ARGTYPE_VECTOR; } else if (SCM_LISTP(y)) { if (Scm_Length(y) != size) size_mismatch(name, SCM_OBJ(x), y); return ARGTYPE_LIST; } else if (!const_ok) { Scm_Error("%s: second operand must be either a matching uvector, a vector, or a list, but got %S", name, y); } else if (!SCM_REALP(y)) { Scm_Error("%s: second operand must be either a matching uvector, a vector, a list or a number, but got %S", name, y); } return ARGTYPE_CONST; } ///)) ;; End prologue ///;; Begin template ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ///;; ///;; Straight substitutions ///;; ${t} -> s8, u8, s16, ... ///;; ${T} -> S8, U8, S16, ... ///;; ${etype} -> char, u_char, short, ... ///;; ${ntype} -> long, long, long, ... (type big enough to hold element) ///;; ///;; Parameterized substitutions ///;; ${UNBOX dst src clamp} where dst::${etype}, src::ScmObj, clamp::int ///;; -> C stmt that unboxes src and set it to dst. ///;; ${BOX dst src} where dst::ScmObj, src::${etype} ///;; -> C stmt that boxes src and set it to dst. ///;; ${VMBOX dst src} where dst::ScmObj, src::${etype} ///;; -> C stmt that boxes src and set it to dst. ///;; (used in Scm_VM* API) ///;; ${NBOX dst src} where dst::ScmObj, src::${ntype} ///;; -> Like BOX, but the source value is given in ntype. ///;; Can be implemented with CAST_N2E and BOX, but some types may ///;; have a shortcut. ///;; ${REF_NTYPE array i} ///;; -> C expr to extract i-th element of etype array *as ntype*. ///;; ${CAST_N2E expr} ///;; -> convert ntype expr into etype. ///;; ${PRINT out elt} where out::ScmPort*, elt::${etype} ///;; -> C stmt to print elt ///;; ${EQ x y} where x, y ::${etype} ///;; -> compare two values ///(define *tmpl-body* '( /*--------------------------------------------------------------- * ${T}Vector */ /* * Class stuff */ /* * Converters */ ScmObj Scm_ObjArrayTo${T}Vector(ScmObj *arr, int size, int clamp SCM_UNUSED) { ScmUVector *vec = (ScmUVector*)Scm_Make${T}Vector(size, ${ZERO}); for (int i=0; i= dlen) return SCM_OBJ(dst); if (dlen - dstart > send - sstart) size = send - sstart; else size = dlen - dstart; memmove(SCM_${T}VECTOR_ELEMENTS(dst) + dstart, SCM_${T}VECTOR_ELEMENTS(src) + sstart, size * sizeof(${etype})); return SCM_OBJ(dst); } ///)) ;; end of tmpl-body ///;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ///;; Numeric operator template ///(append! *tmpl-prologue* (list /****** Add, sub, mul and div (f32 and f64 only) *****/ #define s8s8_add(x, y, clamp) clamp_s8(x+y, clamp) #define s8s8_sub(x, y, clamp) clamp_s8(x-y, clamp) #define s8s8_mul(x, y, clamp) clamp_s8(x*y, clamp) static inline long s8g_add(long x, long y, int clamp) { if (y > 255) return range_s8hi(0, clamp); if (y < -256) return range_s8lo(0, clamp); return clamp_s8(x+y, clamp); } static inline long s8g_sub(long x, long y, int clamp) { if (y < -255) return range_s8hi(0, clamp); if (y > 256) return range_s8lo(0, clamp); return clamp_s8(x-y, clamp); } static inline long s8g_mul(long x, long y, int clamp) { if (x == 0) return 0; if (y > 128) return (x>0)?range_s8hi(0, clamp):range_s8lo(0, clamp); return clamp_s8(x*y, clamp); } #define u8u8_add(x, y, clamp) clamp_u8(x+y, clamp) #define u8u8_sub(x, y, clamp) clamp_u8((long)(x-y), clamp) #define u8u8_mul(x, y, clamp) clamp_u8(x*y, clamp) static inline u_long u8g_add(u_long x, u_long y, int clamp) { if (y > 255) return range_u8hi(0, clamp); return clamp_u8(x+y, clamp); } static inline u_long u8g_sub(u_long x, u_long y, int clamp) { if (y > x) return range_u8lo(0, clamp); return x-y; /* never overflows */ } static inline u_long u8g_mul(u_long x, u_long y, int clamp) { if (x == 0) return 0; if (y > 255) return range_u8hi(0, clamp); return clamp_u8(x*y, clamp); } #define s16s16_add(x, y, clamp) clamp_s16(x+y, clamp) #define s16s16_sub(x, y, clamp) clamp_s16(x-y, clamp) #define s16s16_mul(x, y, clamp) clamp_s16(x*y, clamp) static inline long s16g_add(long x, long y, int clamp) { if (y > 65535) return range_s16hi(0, clamp); if (y < -65536) return range_s16lo(0, clamp); return clamp_s16(x+y, clamp); } static inline long s16g_sub(long x, long y, int clamp) { if (y < -65535) return range_s16hi(0, clamp); if (y > 65536) return range_s16lo(0, clamp); return clamp_s16(x-y, clamp); } static inline long s16g_mul(long x, long y, int clamp) { if (x == 0) return 0; if (y > 32767) return (x>0)?range_s16hi(0, clamp):range_s16lo(0, clamp); return clamp_s16(x*y, clamp); } #define u16u16_add(x, y, clamp) clamp_u16(x+y, clamp) #define u16u16_sub(x, y, clamp) clamp_u16((long)(x-y), clamp) #define u16u16_mul(x, y, clamp) clamp_u16(x*y, clamp) static inline u_long u16g_add(u_long x, u_long y, int clamp) { if (y > 65535) return range_u16hi(0, clamp); return clamp_u16(x+y, clamp); } static inline u_long u16g_sub(u_long x, u_long y, int clamp) { if (y > x) return range_u16lo(0, clamp); return x-y; /* never overflows */ } static inline u_long u16g_mul(u_long x, u_long y, int clamp) { if (x == 0) return 0; if (y > 65535) return range_u16hi(0, clamp); return clamp_u16(x*y, clamp); } #if SIZEOF_LONG == 4 #define s32s32_add(x, y, clamp) s32_add_safe(x, y, clamp) #define s32s32_sub(x, y, clamp) s32_sub_safe(x, y, clamp) #define s32s32_mul(x, y, clamp) s32_mul_safe(x, y, clamp) #define s32g_add(x, y, clamp) s32_add_safe(x, y, clamp) #define s32g_sub(x, y, clamp) s32_sub_safe(x, y, clamp) #define s32g_mul(x, y, clamp) s32_mul_safe(x, y, clamp) #else /* SIZEOF_LONG >= 8 */ #define s32s32_add(x, y, clamp) clamp_s32(x+y, clamp) #define s32s32_sub(x, y, clamp) clamp_s32(x-y, clamp) #define s32s32_mul(x, y, clamp) clamp_s32(x*y, clamp) #define s32g_add(x, y, clamp) s32_add_safe(x, y, clamp) #define s32g_sub(x, y, clamp) s32_sub_safe(x, y, clamp) #define s32g_mul(x, y, clamp) s32_mul_safe(x, y, clamp) #endif /* SIZEOF_LONG >= 8 */ static inline long s32_add_safe(long x, long y, int clamp) { long r, v; SADDOV(r, v, x, y); if (v == 0) return clamp_s32(r, clamp); if (v > 0) return range_s32hi(0, clamp); else return range_s32lo(0, clamp); } static inline long s32_sub_safe(long x, long y, int clamp) { long r, v; SSUBOV(r, v, x, y); if (v == 0) return clamp_s32(r, clamp); if (v > 0) return range_s32hi(0, clamp); else return range_s32lo(0, clamp); } static inline long s32_mul_safe(long x, long y, int clamp) { long r, v; SMULOV(r, v, x, y); if (v == 0) return clamp_s32(r, clamp); if (v > 0) return range_s32hi(0, clamp); else return range_s32lo(0, clamp); } #if SIZEOF_LONG == 4 #define u32u32_add(x, y, clamp) u32_add_safe(x, y, clamp) #define u32u32_sub(x, y, clamp) u32_sub_safe(x, y, clamp) #define u32u32_mul(x, y, clamp) u32_mul_safe(x, y, clamp) #define u32g_add(x, y, clamp) u32_add_safe(x, y, clamp) #define u32g_sub(x, y, clamp) u32_sub_safe(x, y, clamp) #define u32g_mul(x, y, clamp) u32_mul_safe(x, y, clamp) #else /* SIZEOF_LONG >= 8 */ #define u32u32_add(x, y, clamp) clamp_u32(x+y, clamp) #define u32u32_sub(x, y, clamp) u32_sub_safe(x, y, clamp) #define u32u32_mul(x, y, clamp) clamp_u32(x*y, clamp) #define u32g_add(x, y, clamp) u32_add_safe(x, y, clamp) #define u32g_sub(x, y, clamp) u32_sub_safe(x, y, clamp) #define u32g_mul(x, y, clamp) u32_mul_safe(x, y, clamp) #endif /* SIZEOF_LONG >= 8 */ static inline u_long u32_add_safe(u_long x, u_long y, int clamp) { u_long r, v; UADDOV(r, v, x, y); if (v == 0) return clamp_u32(r, clamp); else return range_u32hi(0, clamp); } static inline u_long u32_sub_safe(u_long x, u_long y, int clamp) { u_long r, v; USUBOV(r, v, x, y); if (v == 0) return clamp_u32(r, clamp); else return range_u32lo(0, clamp); } static inline u_long u32_mul_safe(u_long x, u_long y, int clamp) { u_long r, v; UMULOV(r, v, x, y); if (v == 0) return clamp_u32(r, clamp); else return range_u32hi(0, clamp); } #define s64s64_add(x, y, clamp) s64g_add(x, y, clamp) #define s64s64_sub(x, y, clamp) s64g_sub(x, y, clamp) #define s64s64_mul(x, y, clamp) s64g_mul(x, y, clamp) static inline int64_t s64g_add(int64_t x, int64_t y, int clamp) { #if SIZEOF_LONG == 4 ScmObj xx = Scm_MakeInteger64(x); ScmObj yy = Scm_MakeInteger64(y); ScmObj r = Scm_Add(xx, yy); return Scm_GetInteger64Clamp(r, clamp, NULL); #else long r, v; SADDOV(r, v, x, y); if (v == 0) return r; if (v > 0) return range_s64hi(0, clamp); else return range_s64lo(0, clamp); #endif } static inline int64_t s64g_sub(int64_t x, int64_t y, int clamp) { #if SIZEOF_LONG == 4 ScmObj xx = Scm_MakeInteger64(x); ScmObj yy = Scm_MakeInteger64(y); ScmObj r = Scm_Sub(xx, yy); return Scm_GetInteger64Clamp(r, clamp, NULL); #else long r, v; SSUBOV(r, v, x, y); if (v == 0) return r; if (v > 0) return range_s64hi(0, clamp); else return range_s64lo(0, clamp); #endif } static inline int64_t s64g_mul(int64_t x, int64_t y, int clamp) { #if SIZEOF_LONG == 4 ScmObj xx = Scm_MakeInteger64(x); ScmObj yy = Scm_MakeInteger64(y); ScmObj r = Scm_Mul(xx, yy); return Scm_GetInteger64Clamp(r, clamp, NULL); #else long r, v; SMULOV(r, v, x, y); if (v == 0) return r; if (v > 0) return range_s64hi(0, clamp); else return range_s64lo(0, clamp); #endif } #define u64u64_add(x, y, clamp) u64g_add(x, y, clamp) #define u64u64_sub(x, y, clamp) u64g_sub(x, y, clamp) #define u64u64_mul(x, y, clamp) u64g_mul(x, y, clamp) static inline uint64_t u64g_add(uint64_t x, uint64_t y, int clamp) { #if SIZEOF_LONG == 4 ScmObj xx = Scm_MakeIntegerU64(x); ScmObj yy = Scm_MakeIntegerU64(y); ScmObj r = Scm_Add(xx, yy); return Scm_GetIntegerU64Clamp(r, clamp, NULL); #else u_long r, v; UADDOV(r, v, x, y); if (v == 0) return r; else return range_u64hi(0, clamp); #endif } static inline uint64_t u64g_sub(uint64_t x, uint64_t y, int clamp) { #if SIZEOF_LONG == 4 ScmObj xx = Scm_MakeIntegerU64(x); ScmObj yy = Scm_MakeIntegerU64(y); ScmObj r = Scm_Sub(xx, yy); return Scm_GetIntegerU64Clamp(r, clamp, NULL); #else u_long r, v; USUBOV(r, v, x, y); if (v == 0) return r; else return range_u64lo(0, clamp); #endif } static inline uint64_t u64g_mul(uint64_t x, uint64_t y, int clamp) { #if SIZEOF_LONG == 4 ScmObj xx = Scm_MakeIntegerU64(x); ScmObj yy = Scm_MakeIntegerU64(y); ScmObj r = Scm_Mul(xx, yy); return Scm_GetIntegerU64Clamp(r, clamp, NULL); #else u_long r, v; UMULOV(r, v, x, y); if (v == 0) return r; else return range_u64hi(0, clamp); #endif } #define f16f16_add(x, y, clamp) (x+y) #define f16f16_sub(x, y, clamp) (x-y) #define f16f16_mul(x, y, clamp) (x*y) #define f16f16_div(x, y, clamp) (x/y) #define f16g_add(x, y, clamp) (x+y) #define f16g_sub(x, y, clamp) (x-y) #define f16g_mul(x, y, clamp) (x*y) #define f16g_div(x, y, clamp) (x/y) #define f32f32_add(x, y, clamp) (x+y) #define f32f32_sub(x, y, clamp) (x-y) #define f32f32_mul(x, y, clamp) (x*y) #define f32f32_div(x, y, clamp) (x/y) #define f32g_add(x, y, clamp) (x+y) #define f32g_sub(x, y, clamp) (x-y) #define f32g_mul(x, y, clamp) (x*y) #define f32g_div(x, y, clamp) (x/y) #define f64f64_add(x, y, clamp) (x+y) #define f64f64_sub(x, y, clamp) (x-y) #define f64f64_mul(x, y, clamp) (x*y) #define f64f64_div(x, y, clamp) (x/y) #define f64g_add(x, y, clamp) (x+y) #define f64g_sub(x, y, clamp) (x-y) #define f64g_mul(x, y, clamp) (x*y) #define f64g_div(x, y, clamp) (x/y) static inline ScmDoubleComplex complex_half_to_double(ScmHalfComplex x) { return (ScmDoubleComplex)(Scm_HalfToDouble(x.r) + Scm_HalfToDouble(x.i) * _Complex_I); } static inline ScmHalfComplex complex_double_to_half(ScmDoubleComplex x) { return (ScmHalfComplex){Scm_DoubleToHalf(creal(x)), Scm_DoubleToHalf(cimag(x))}; } static inline ScmHalfComplex c32c32_add(ScmHalfComplex x, ScmHalfComplex y, int clamp SCM_UNUSED) { ScmDoubleComplex cx = complex_half_to_double(x); ScmDoubleComplex cy = complex_half_to_double(y); return complex_double_to_half(cx+cy); } static inline ScmHalfComplex c32c32_sub(ScmHalfComplex x, ScmHalfComplex y, int clamp SCM_UNUSED) { ScmDoubleComplex cx = complex_half_to_double(x); ScmDoubleComplex cy = complex_half_to_double(y); return complex_double_to_half(cx-cy); } static inline ScmHalfComplex c32c32_mul(ScmHalfComplex x, ScmHalfComplex y, int clamp SCM_UNUSED) { ScmDoubleComplex cx = complex_half_to_double(x); ScmDoubleComplex cy = complex_half_to_double(y); return complex_double_to_half(cx*cy); } static inline ScmHalfComplex c32c32_div(ScmHalfComplex x, ScmHalfComplex y, int clamp SCM_UNUSED) { ScmDoubleComplex cx = complex_half_to_double(x); ScmDoubleComplex cy = complex_half_to_double(y); return complex_double_to_half(cx/cy); } #define c32g_add(x, y, clamp) c32c32_add(x, y, clamp) #define c32g_sub(x, y, clamp) c32c32_sub(x, y, clamp) #define c32g_mul(x, y, clamp) c32c32_mul(x, y, clamp) #define c32g_div(x, y, clamp) c32c32_div(x, y, clamp) #define c64c64_add(x, y, clamp) (x+y) #define c64c64_sub(x, y, clamp) (x-y) #define c64c64_mul(x, y, clamp) (x*y) #define c64c64_div(x, y, clamp) (x/y) #define c64g_add(x, y, clamp) (x+y) #define c64g_sub(x, y, clamp) (x-y) #define c64g_mul(x, y, clamp) (x*y) #define c64g_div(x, y, clamp) (x/y) #define c128c128_add(x, y, clamp) (x+y) #define c128c128_sub(x, y, clamp) (x-y) #define c128c128_mul(x, y, clamp) (x*y) #define c128c128_div(x, y, clamp) (x/y) #define c128g_add(x, y, clamp) (x+y) #define c128g_sub(x, y, clamp) (x-y) #define c128g_mul(x, y, clamp) (x*y) #define c128g_div(x, y, clamp) (x/y) /****** Number extraction *****/ /* like unbox, but not as strict. sets *oor = TRUE if x is out of range. */ static inline long s8num(ScmObj x, int *oor) { return Scm_GetIntegerClamp(x, SCM_CLAMP_NONE, oor); } #define s16num(x, oor) s8num(x, oor) #define s32num(x, oor) s8num(x, oor) static inline u_long u8num(ScmObj x, int *oor) { return Scm_GetIntegerUClamp(x, SCM_CLAMP_NONE, oor); } #define u16num(x, oor) u8num(x, oor) #define u32num(x, oor) u8num(x, oor) static inline int64_t s64num(ScmObj x, int *oor) { return Scm_GetInteger64Clamp(x, SCM_CLAMP_NONE, oor); } static inline uint64_t u64num(ScmObj x, int *oor) { return Scm_GetIntegerU64Clamp(x, SCM_CLAMP_NONE, oor); } #define f16num(x, oor) ((*oor = FALSE), Scm_GetDouble(x)) #define f32num(x, oor) ((*oor = FALSE),((float)Scm_GetDouble(x))) #define f64num(x, oor) ((*oor = FALSE), Scm_GetDouble(x)) #define c32num(x, oor) ((*oor = FALSE), Scm_GetHalfComplex(x)) #define c64num(x, oor) ((*oor = FALSE), Scm_GetFloatComplex(x)) #define c128num(x, oor) ((*oor = FALSE), Scm_GetDoubleComplex(x)) ///)) ///(define *tmpl-numop* '( /* NB: s1 can be a register flonum. */ static void ${t}vector_${opname}(const char *name, ScmObj d, ScmObj s0, ScmObj s1, int clamp SCM_UNUSED) /* clamp appears in macro call below, but the macro may not use it. */ { int size = SCM_${T}VECTOR_SIZE(d), oor; ${ntype} r, v0, v1; ScmObj rr, vv1; switch (arg2_check(name, s0, s1, TRUE)) { case ARGTYPE_UVECTOR: for (int i=0; i 0) { return SCM_BIGNUM(x)->values[0]; } else { return ~(SCM_BIGNUM(x)->values[0]) + 1; } } Scm_Error("integer required, but got %S", x); return 0; } static inline uint64_t bitext64(ScmObj x) { uint64_t r = 0; if (SCM_INTP(x)) r = SCM_INT_VALUE(x); else if (SCM_BIGNUMP(x)) { ScmObj xx = Scm_LogAnd(x, SCM_2_64_MINUS_1); r = Scm_GetIntegerU64(xx); } else { Scm_Error("integer required, but got %S", x); } return r; } #define INT64BITOP(r, x, op, y) (r = x op y) ///)) ///(define *tmpl-bitop* '( static void ${t}vector_${opname}(const char *name, ScmObj d, ScmObj s0, ScmObj s1) { int size = SCM_${T}VECTOR_SIZE(d); ${ntype} r, v0, v1; ScmObj vv1; switch(arg2_check(name, s0, s1, TRUE)) { case ARGTYPE_UVECTOR: for (int i=0; i= 1); ScmSize r = Scm_Getz((char*)v->elements + start*eltsize, (end-start)*eltsize, port); if (r == EOF) SCM_RETURN(SCM_EOF); #ifdef DOUBLE_ARMENDIAN if (Scm_IsArmLE(Scm_NativeEndian())) { if (Scm_IsLE(SCM_OBJ(endian))) { /* arm-le and le is equivalent when eltsize <= 4 */ if (eltsize == 8) { Scm_UVectorSwapBytesX(SCM_UVECTOR(v), SWAPB_ARM_LE); } } else if (Scm_IsBE(SCM_OBJ(endian))) { Scm_UVectorSwapBytesX(SCM_UVECTOR(v), SWAPB_ARM_BE); } } else #endif /*!DOUBLE_ARMENDIAN*/ { #ifdef WORDS_BIGENDIAN if (Scm_IsLE(SCM_OBJ(endian))) { Scm_UVectorSwapBytesX(SCM_UVECTOR(v), SWAPB_STD); } else if (Scm_IsArmLE(SCM_OBJ(endian))) { Scm_UVectorSwapBytesX(SCM_UVECTOR(v), SWAPB_ARM_BE); } #else /*!WORDS_BIGENDIAN*/ if (Scm_IsBE(SCM_OBJ(endian))) { Scm_UVectorSwapBytesX(SCM_UVECTOR(v), SWAPB_STD); } else if (Scm_IsArmLE(SCM_OBJ(endian))) { if (eltsize == 8) { Scm_UVectorSwapBytesX(SCM_UVECTOR(v), SWAPB_ARM_LE); } } #endif /*!WORDS_BIGENDIAN*/ } SCM_RETURN(Scm_MakeInteger(r/eltsize)); } ScmObj Scm_WriteBlock(ScmUVector *v, ScmPort *port, ScmSmallInt start, ScmSmallInt end, ScmSymbol *endian) { ScmSmallInt len = SCM_UVECTOR_SIZE(v); int swap_needed = FALSE, swap_type; SCM_CHECK_START_END(start, end, len); SCM_CHECK_ENDIAN(endian); int eltsize = Scm_UVectorElementSize(Scm_ClassOf(SCM_OBJ(v))); SCM_ASSERT(eltsize >= 1); #ifdef DOUBLE_ARMENDIAN if (Scm_IsArmLE(Scm_NativeEndian())) { if (Scm_IsBE(SCM_OBJ(endian))) { swap_needed = TRUE; swap_type = SWAPB_ARM_BE; } else if (Scm_IsLE(SCM_OBJ(endian)) && eltsize == 8) { swap_needed = TRUE; swap_type = SWAPB_ARM_LE; } } else #endif /*DOUBLE_ARMENDIAN*/ { #ifdef WORDS_BIGENDIAN if (Scm_IsLE(SCM_OBJ(endian))) { swap_needed = TRUE; swap_type = SWAPB_STD; } else if (Scm_IsArmLE(SCM_OBJ(endian))) { swap_needed = TRUE; swap_type = SWAPB_ARM_BE; } #else /*!WORDS_BIGENDIAN*/ if (Scm_IsBE(SCM_OBJ(endian))) { swap_needed = TRUE; swap_type = SWAPB_STD; } else if (Scm_IsArmLE(SCM_OBJ(endian)) && eltsize == 8) { swap_needed = TRUE; swap_type = SWAPB_ARM_LE; } #endif /*!WORDS_BIGENDIAN*/ } if (!swap_needed || eltsize == 1) { Scm_Putz((const char*)v->elements + start*eltsize, (end-start)*eltsize, port); } else { /* ugly */ switch (eltsize) { case 2: { swap_u16_t d; for (ScmSmallInt i=start; ielements)[i]; SWAP_2(d); Scm_Putz((const char*)d.buf, 2, port); } break; } case 4: { swap_u32_t d; for (ScmSmallInt i=start; ielements)[i]; SWAP_4(d); Scm_Putz((const char*)d.buf, 4, port); } break; } case 8:{ swap_u64_t d; switch (swap_type) { case SWAPB_STD: for (ScmSmallInt i=start; ielements)[i]; SWAP_8(d); Scm_Putz((const char*)d.buf, 8, port); } break; case SWAPB_ARM_LE: for (ScmSmallInt i=start; ielements)[i]; SWAP_ARM2LE(d); Scm_Putz((const char*)d.buf, 8, port); } break; case SWAPB_ARM_BE: for (ScmSmallInt i=start; ielements)[i]; SWAP_ARM2BE(d); Scm_Putz((const char*)d.buf, 8, port); } break; } break; } } } SCM_RETURN(SCM_UNDEFINED); } ///)) ;; end of tmpl-epilogue ///; Local variables: ///; mode: c ///; end: