n 215 ext/auxsys/auxsyslib.c ScmObj n = Scm_MakeFlonum(samples[i]);
n 216 ext/auxsys/auxsyslib.c SCM_APPEND1(h, t, n);
n 465 ext/auxsys/auxsyslib.c int i, n = getgroups(size, pglist);
n 466 ext/auxsys/auxsyslib.c if (n >= 0) {
n 468 ext/auxsys/auxsyslib.c for (i=0; i<n; i++) SCM_APPEND1(head, tail, Scm_MakeInteger(pglist[i]));
n 131 ext/binary/binary.c #define CSWAP(buf, tmp, n, m) (tmp=buf[n], buf[n]=buf[m], buf[m]=tmp)
n 52 ext/charconv/jconv.c #define INCHK(n) do{if (inroom < (n)) return INPUT_NOT_ENOUGH;}while(0)
n 53 ext/charconv/jconv.c #define OUTCHK(n) do{if (outroom < (n)) return OUTPUT_NOT_ENOUGH;}while(0)
n 55 ext/charconv/jconv.c #define ERRP(n) ((n)==INPUT_NOT_ENOUGH||(n)==OUTPUT_NOT_ENOUGH||(n)==ILLEGAL_SEQUENCE)
n 69 ext/dbm/ndbm.c ScmNdbm *n = SCM_NDBM(obj);
n 70 ext/dbm/ndbm.c if (n->dbf) { dbm_close(n->dbf); n->dbf = NULL; }
n 94 ext/digest/sha.c #define ROTL(n,X) ( (X << n) | (X >> (32-n)) )
n 99 ext/fcntl/fcntl.c #define FLAG_NAME(n) case n: return #n
n 138 ext/mt-random/mt-lib.c ScmObj n;
n 144 ext/mt-random/mt-lib.c n = (n_scm);
n 148 ext/mt-random/mt-lib.c SCM_RESULT = Scm_MTGenrandInt(mt, n);
n 186 ext/mt-random/mt-random.c static inline int xlog2(unsigned long n)
n 198 ext/mt-random/mt-random.c if (n < m) {
n 202 ext/mt-random/mt-random.c if (n == m) return e;
n 203 ext/mt-random/mt-random.c } while (e >= 0 && n < m);
n 204 ext/mt-random/mt-random.c } else if (n > m) {
n 208 ext/mt-random/mt-random.c if (n == m) return e;
n 209 ext/mt-random/mt-random.c } while (e < MAX_BIT && n > m);
n 220 ext/mt-random/mt-random.c static ScmObj genrand_int_small(ScmMersenneTwister *mt, unsigned long n)
n 224 ext/mt-random/mt-random.c if ((e = xlog2(n)) == 0) {
n 232 ext/mt-random/mt-random.c double q = floor((double)0xffffffff / (double)n);
n 233 ext/mt-random/mt-random.c double qn = q * n;
n 241 ext/mt-random/mt-random.c ScmObj Scm_MTGenrandInt(ScmMersenneTwister *mt, ScmObj n)
n 243 ext/mt-random/mt-random.c if (SCM_INTP(n)) {
n 244 ext/mt-random/mt-random.c long m = SCM_INT_VALUE(n);
n 249 ext/mt-random/mt-random.c if (SCM_BIGNUMP(n)) {
n 250 ext/mt-random/mt-random.c if (SCM_BIGNUM_SIGN(n) <= 0) goto err;
n 251 ext/mt-random/mt-random.c if (SCM_BIGNUM_SIZE(n) == 1) {
n 252 ext/mt-random/mt-random.c return genrand_int_small(mt, SCM_BIGNUM(n)->values[0]);
n 254 ext/mt-random/mt-random.c if (SCM_BIGNUM_SIZE(n) == 2
n 255 ext/mt-random/mt-random.c && SCM_BIGNUM(n)->values[0] == 0
n 256 ext/mt-random/mt-random.c && SCM_BIGNUM(n)->values[1] == 1) {
n 262 ext/mt-random/mt-random.c Scm_Error("bad type of argument for n: positive integer up to 2^32 is required, but got %S", n);
n 75 ext/mt-random/mt-random.h extern ScmObj Scm_MTGenrandInt(ScmMersenneTwister *mt, ScmObj n);
n 9730 ext/uvector/uvector.c unsigned short n;
n 9734 ext/uvector/uvector.c d.n = ((unsigned short*)v->elements)[i];
n 9735 ext/uvector/uvector.c swapb16(&d.n);
n 9741 ext/uvector/uvector.c ScmUInt32 n;
n 9745 ext/uvector/uvector.c d.n = ((ScmUInt32*)v->elements)[i];
n 9746 ext/uvector/uvector.c swapb32(&d.n);
n 9752 ext/uvector/uvector.c ScmUInt64 n;
n 9756 ext/uvector/uvector.c d.n = ((ScmUInt64*)v->elements)[i];
n 9757 ext/uvector/uvector.c swapb64(&d.n);
n 130 ext/vport/vport.c int n, i;
n 138 ext/vport/vport.c n = SCM_CHAR_NFOLLOWS(p->scratch[0]);
n 139 ext/vport/vport.c for (i=0; i<n; i++) {
n 246 ext/vport/vport.c int i, n=SCM_CHAR_NBYTES(c);
n 248 ext/vport/vport.c for (i=0; i<n; i++) {
n 59 gc/allchblk.c static GC_bool GC_enough_large_bytes_left(bytes,n)
n 61 gc/allchblk.c int n;
n 64 gc/allchblk.c for (i = N_HBLK_FLS; i >= n; --i) {
n 71 gc/allchblk.c # define INCR_FREE_BYTES(n, b) GC_free_bytes[n] += (b);
n 77 gc/allchblk.c # define INCR_FREE_BYTES(n, b)
n 258 gc/allchblk.c void GC_remove_from_fl(hhdr, n)
n 260 gc/allchblk.c int n;
n 267 gc/allchblk.c if (FL_UNKNOWN == n) {
n 270 gc/allchblk.c index = n;
n 275 gc/allchblk.c if (FL_UNKNOWN == n) {
n 278 gc/allchblk.c index = n;
n 500 gc/allchblk.c void GC_split_block(h, hhdr, n, nhdr, index)
n 503 gc/allchblk.c struct hblk *n;
n 508 gc/allchblk.c word h_size = (word)n - (word)h;
n 518 gc/allchblk.c HDR(prev) -> hb_next = n;
n 520 gc/allchblk.c GC_hblkfreelist[index] = n;
n 523 gc/allchblk.c HDR(next) -> hb_prev = n;
n 572 gc/allchblk.c GC_allochblk_nth(sz, kind, flags, n)
n 576 gc/allchblk.c int n;
n 588 gc/allchblk.c hbp = GC_hblkfreelist[n];
n 606 gc/allchblk.c if (!GC_enough_large_bytes_left(GC_large_allocd_bytes, n)) {
n 664 gc/allchblk.c GC_split_block(hbp, hhdr, thishbp, thishdr, n);
n 705 gc/allchblk.c GC_remove_from_fl(hhdr, n);
n 720 gc/allchblk.c return GC_allochblk_nth(sz, kind, flags, n);
n 736 gc/allchblk.c hbp = GC_get_first_part(hbp, hhdr, size_needed, n);
n 419 gc/alloc.c void GC_collect_a_little_inner(n)
n 420 gc/alloc.c int n;
n 426 gc/alloc.c for (i = GC_deficit; i < GC_RATE*n; i++) {
n 449 gc/alloc.c if (GC_deficit > 0) GC_deficit -= GC_RATE*n;
n 882 gc/alloc.c void GC_set_max_heap_size(GC_word n)
n 884 gc/alloc.c void GC_set_max_heap_size(n)
n 885 gc/alloc.c GC_word n;
n 888 gc/alloc.c GC_max_heapsize = n;
n 900 gc/alloc.c GC_bool GC_expand_hp_inner(n)
n 901 gc/alloc.c word n;
n 908 gc/alloc.c if (n < MINHINCR) n = MINHINCR;
n 909 gc/alloc.c bytes = n * HBLKSIZE;
n 104 gc/cord/cordbscs.c void CORD_dump_inner(CORD x, unsigned n)
n 108 gc/cord/cordbscs.c for (i = 0; i < (size_t)n; i++) {
n 125 gc/cord/cordbscs.c CORD_dump_inner(conc -> left, n+1);
n 126 gc/cord/cordbscs.c CORD_dump_inner(conc -> right, n+1);
n 342 gc/cord/cordbscs.c CORD CORD_substr_closure(CORD x, size_t i, size_t n, CORD_fn f)
n 350 gc/cord/cordbscs.c result = CORD_from_fn(f, (void *)sa, n);
n 361 gc/cord/cordbscs.c CORD CORD_substr_checked(CORD x, size_t i, size_t n)
n 364 gc/cord/cordbscs.c if (n > SUBSTR_LIMIT) {
n 365 gc/cord/cordbscs.c return(CORD_substr_closure(x, i, n, CORD_index_access_fn));
n 367 gc/cord/cordbscs.c register char * result = GC_MALLOC_ATOMIC(n+1);
n 370 gc/cord/cordbscs.c strncpy(result, x+i, n);
n 371 gc/cord/cordbscs.c result[n] = '\0';
n 383 gc/cord/cordbscs.c if (n == right_len) return(conc -> right);
n 384 gc/cord/cordbscs.c return(CORD_substr_checked(conc -> right, i - left_len, n));
n 385 gc/cord/cordbscs.c } else if (i+n <= left_len) {
n 386 gc/cord/cordbscs.c if (n == left_len) return(conc -> left);
n 387 gc/cord/cordbscs.c return(CORD_substr_checked(conc -> left, i, n));
n 399 gc/cord/cordbscs.c if (i + n == right_len + left_len) {
n 403 gc/cord/cordbscs.c n - left_part_len);
n 408 gc/cord/cordbscs.c if (n > SUBSTR_LIMIT) {
n 417 gc/cord/cordbscs.c n, f -> fn));
n 419 gc/cord/cordbscs.c return(CORD_substr_closure(x, i, n, CORD_apply_access_fn));
n 428 gc/cord/cordbscs.c register int lim = i + n;
n 433 gc/cord/cordbscs.c return(CORD_substr_closure(x, i, n, CORD_apply_access_fn));
n 438 gc/cord/cordbscs.c result = GC_MALLOC_ATOMIC(n+1);
n 446 gc/cord/cordbscs.c CORD CORD_substr(CORD x, size_t i, size_t n)
n 450 gc/cord/cordbscs.c if (i >= len || n <= 0) return(0);
n 453 gc/cord/cordbscs.c if (i + n > len) n = len - i;
n 459 gc/cord/cordbscs.c return(CORD_substr_checked(x, i, n));
n 496 gc/cord/cordxtra.c # define MOD_CACHE_SZ(n) ((n) & (CACHE_SZ - 1))
n 497 gc/cord/cordxtra.c # define DIV_CACHE_SZ(n) ((n) >> LOG_CACHE_SZ)
n 498 gc/cord/cordxtra.c # define MOD_LINE_SZ(n) ((n) & (LINE_SZ - 1))
n 499 gc/cord/cordxtra.c # define DIV_LINE_SZ(n) ((n) >> LOG_LINE_SZ)
n 500 gc/cord/cordxtra.c # define LINE_START(n) ((n) & ~(LINE_SZ - 1))
n 99 gc/include/cord.h CORD CORD_substr(CORD x, size_t i, size_t n);
n 209 gc/include/cord.h CORD CORD_catn(int n, /* CORD */ ...);
n 339 gc/include/gc.h GC_API void GC_set_max_heap_size GC_PROTO((GC_word n));
n 371 gc/include/gc.h GC_API void GC_register_displacement GC_PROTO((GC_word n));
n 375 gc/include/gc.h GC_API void GC_debug_register_displacement GC_PROTO((GC_word n));
n 579 gc/include/gc.h # define GC_REGISTER_DISPLACEMENT(n) GC_debug_register_displacement(n)
n 601 gc/include/gc.h # define GC_REGISTER_DISPLACEMENT(n) GC_register_displacement(n)
n 820 gc/include/gc.h # define GC_PTR_ADD3(x, n, type_of_result) \
n 821 gc/include/gc.h ((type_of_result)GC_same_obj((x)+(n), (x)))
n 822 gc/include/gc.h # define GC_PRE_INCR3(x, n, type_of_result) \
n 823 gc/include/gc.h ((type_of_result)GC_pre_incr(&(x), (n)*sizeof(*x))
n 827 gc/include/gc.h # define GC_PTR_ADD(x, n) \
n 828 gc/include/gc.h GC_PTR_ADD3(x, n, typeof(x))
n 829 gc/include/gc.h # define GC_PRE_INCR(x, n) \
n 830 gc/include/gc.h GC_PRE_INCR3(x, n, typeof(x))
n 831 gc/include/gc.h # define GC_POST_INCR(x, n) \
n 838 gc/include/gc.h # define GC_PTR_ADD(x, n) ((x)+(n))
n 841 gc/include/gc.h # define GC_PTR_ADD3(x, n, type_of_result) ((x)+(n))
n 842 gc/include/gc.h # define GC_PTR_ADD(x, n) ((x)+(n))
n 843 gc/include/gc.h # define GC_PRE_INCR3(x, n, type_of_result) ((x) += (n))
n 844 gc/include/gc.h # define GC_PRE_INCR(x, n) ((x) += (n))
n 845 gc/include/gc.h # define GC_POST_INCR2(x, n, type_of_result) ((x)++)
n 846 gc/include/gc.h # define GC_POST_INCR(x, n) ((x)++)
n 54 gc/include/gc_alloc.h static T *allocate(size_t n)
n 55 gc/include/gc_alloc.h { return 0 == n? 0 : (T*) alloc::allocate(n * sizeof (T)); }
n 58 gc/include/gc_alloc.h static void deallocate(T *p, size_t n)
n 59 gc/include/gc_alloc.h { if (0 != n) alloc::deallocate(p, n * sizeof (T)); }
n 101 gc/include/gc_alloc.h inline size_t GC_round_up(size_t n)
n 103 gc/include/gc_alloc.h return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment;
n 107 gc/include/gc_alloc.h inline size_t GC_round_up_uncollectable(size_t n)
n 109 gc/include/gc_alloc.h return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment;
n 176 gc/include/gc_alloc.h static void * allocate(size_t n)
n 178 gc/include/gc_alloc.h size_t nwords = GC_round_up(n);
n 182 gc/include/gc_alloc.h if (n > GC_max_fast_bytes) return GC_malloc(n);
n 191 gc/include/gc_alloc.h static void * ptr_free_allocate(size_t n)
n 193 gc/include/gc_alloc.h size_t nwords = GC_round_up(n);
n 197 gc/include/gc_alloc.h if (n > GC_max_fast_bytes) return GC_malloc_atomic(n);
n 206 gc/include/gc_alloc.h static void deallocate(void *p, size_t n)
n 208 gc/include/gc_alloc.h size_t nwords = GC_round_up(n);
n 211 gc/include/gc_alloc.h if (n > GC_max_fast_bytes) {
n 222 gc/include/gc_alloc.h static void ptr_free_deallocate(void *p, size_t n)
n 224 gc/include/gc_alloc.h size_t nwords = GC_round_up(n);
n 227 gc/include/gc_alloc.h if (n > GC_max_fast_bytes) {
n 244 gc/include/gc_alloc.h static void * allocate(size_t n)
n 246 gc/include/gc_alloc.h size_t nwords = GC_round_up_uncollectable(n);
n 250 gc/include/gc_alloc.h if (n > GC_max_fast_bytes) return GC_malloc_uncollectable(n);
n 259 gc/include/gc_alloc.h static void * ptr_free_allocate(size_t n)
n 261 gc/include/gc_alloc.h size_t nwords = GC_round_up_uncollectable(n);
n 265 gc/include/gc_alloc.h if (n > GC_max_fast_bytes) return GC_malloc_atomic_uncollectable(n);
n 274 gc/include/gc_alloc.h static void deallocate(void *p, size_t n)
n 276 gc/include/gc_alloc.h size_t nwords = GC_round_up_uncollectable(n);
n 279 gc/include/gc_alloc.h if (n > GC_max_fast_bytes) {
n 288 gc/include/gc_alloc.h static void ptr_free_deallocate(void *p, size_t n)
n 290 gc/include/gc_alloc.h size_t nwords = GC_round_up_uncollectable(n);
n 293 gc/include/gc_alloc.h if (n > GC_max_fast_bytes) {
n 309 gc/include/gc_alloc.h static void * allocate(size_t n) { return GC_malloc(n); }
n 310 gc/include/gc_alloc.h static void * ptr_free_allocate(size_t n)
n 311 gc/include/gc_alloc.h { return GC_malloc_atomic(n); }
n 321 gc/include/gc_alloc.h static void * allocate(size_t n) { return GC_malloc_uncollectable(n); }
n 322 gc/include/gc_alloc.h static void * ptr_free_allocate(size_t n)
n 323 gc/include/gc_alloc.h { return GC_malloc_atomic_uncollectable(n); }
n 340 gc/include/gc_alloc.h static T *allocate(size_t n) \
n 341 gc/include/gc_alloc.h { return 0 == n? 0 : \
n 342 gc/include/gc_alloc.h (T*) alloc::ptr_free_allocate(n * sizeof (T)); } \
n 345 gc/include/gc_alloc.h static void deallocate(T *p, size_t n) \
n 346 gc/include/gc_alloc.h { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
n 82 gc/include/gc_allocator.h inline void * GC_selective_alloc(size_t n, GC_Tp) {
n 83 gc/include/gc_allocator.h return GC_MALLOC(n);
n 87 gc/include/gc_allocator.h inline void * GC_selective_alloc<GC_true_type>(size_t n, GC_true_type) {
n 88 gc/include/gc_allocator.h return GC_MALLOC_ATOMIC(n);
n 45 gc/include/gc_inl.h # define GC_MALLOC_WORDS(result,n) \
n 51 gc/include/gc_inl.h opp = &(GC_objfreelist[n]); \
n 55 gc/include/gc_inl.h (result) = GC_generic_malloc_words_small((n), NORMAL); \
n 59 gc/include/gc_inl.h GC_words_allocd += (n); \
n 67 gc/include/gc_inl.h # define GC_MALLOC_ATOMIC_WORDS(result,n) \
n 73 gc/include/gc_inl.h opp = &(GC_aobjfreelist[n]); \
n 77 gc/include/gc_inl.h (result) = GC_generic_malloc_words_small((n), PTRFREE); \
n 81 gc/include/gc_inl.h GC_words_allocd += (n); \
n 100 gc/include/gc_typed.h # define GC_CALLOC_EXPLICITLY_TYPED(n, bytes, d) GC_MALLOC(n*bytes)
n 104 gc/include/gc_typed.h # define GC_CALLOC_EXPLICITLY_TYPED(n, bytes, d) \
n 105 gc/include/gc_typed.h GC_calloc_explicitly_typed(n, bytes, d)
n 3 gc/include/leak_detector.h #define malloc(n) GC_MALLOC(n)
n 4 gc/include/leak_detector.h #define calloc(m,n) GC_MALLOC((m)*(n))
n 6 gc/include/leak_detector.h #define realloc(p,n) GC_REALLOC((p),(n))
n 116 gc/include/new_gc_alloc.h inline size_t GC_round_up(size_t n)
n 118 gc/include/new_gc_alloc.h return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment;
n 122 gc/include/new_gc_alloc.h inline size_t GC_round_up_uncollectable(size_t n)
n 124 gc/include/new_gc_alloc.h return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment;
n 191 gc/include/new_gc_alloc.h static void * allocate(size_t n)
n 193 gc/include/new_gc_alloc.h size_t nwords = GC_round_up(n);
n 197 gc/include/new_gc_alloc.h if (n > GC_max_fast_bytes) return GC_malloc(n);
n 206 gc/include/new_gc_alloc.h static void * ptr_free_allocate(size_t n)
n 208 gc/include/new_gc_alloc.h size_t nwords = GC_round_up(n);
n 212 gc/include/new_gc_alloc.h if (n > GC_max_fast_bytes) return GC_malloc_atomic(n);
n 221 gc/include/new_gc_alloc.h static void deallocate(void *p, size_t n)
n 223 gc/include/new_gc_alloc.h size_t nwords = GC_round_up(n);
n 226 gc/include/new_gc_alloc.h if (n > GC_max_fast_bytes) {
n 237 gc/include/new_gc_alloc.h static void ptr_free_deallocate(void *p, size_t n)
n 239 gc/include/new_gc_alloc.h size_t nwords = GC_round_up(n);
n 242 gc/include/new_gc_alloc.h if (n > GC_max_fast_bytes) {
n 259 gc/include/new_gc_alloc.h static void * allocate(size_t n)
n 261 gc/include/new_gc_alloc.h size_t nwords = GC_round_up_uncollectable(n);
n 265 gc/include/new_gc_alloc.h if (n > GC_max_fast_bytes) return GC_malloc_uncollectable(n);
n 274 gc/include/new_gc_alloc.h static void * ptr_free_allocate(size_t n)
n 276 gc/include/new_gc_alloc.h size_t nwords = GC_round_up_uncollectable(n);
n 280 gc/include/new_gc_alloc.h if (n > GC_max_fast_bytes) return GC_malloc_atomic_uncollectable(n);
n 289 gc/include/new_gc_alloc.h static void deallocate(void *p, size_t n)
n 291 gc/include/new_gc_alloc.h size_t nwords = GC_round_up_uncollectable(n);
n 294 gc/include/new_gc_alloc.h if (n > GC_max_fast_bytes) {
n 303 gc/include/new_gc_alloc.h static void ptr_free_deallocate(void *p, size_t n)
n 305 gc/include/new_gc_alloc.h size_t nwords = GC_round_up_uncollectable(n);
n 308 gc/include/new_gc_alloc.h if (n > GC_max_fast_bytes) {
n 324 gc/include/new_gc_alloc.h static void * allocate(size_t n) { return GC_malloc(n); }
n 325 gc/include/new_gc_alloc.h static void * ptr_free_allocate(size_t n)
n 326 gc/include/new_gc_alloc.h { return GC_malloc_atomic(n); }
n 336 gc/include/new_gc_alloc.h static void * allocate(size_t n) { return GC_malloc_uncollectable(n); }
n 337 gc/include/new_gc_alloc.h static void * ptr_free_allocate(size_t n)
n 338 gc/include/new_gc_alloc.h { return GC_malloc_atomic_uncollectable(n); }
n 353 gc/include/new_gc_alloc.h static T *allocate(size_t n) \
n 354 gc/include/new_gc_alloc.h { return 0 == n? 0 : \
n 355 gc/include/new_gc_alloc.h reinterpret_cast<T*>(alloc::ptr_free_allocate(n * sizeof (T))); } \
n 358 gc/include/new_gc_alloc.h static void deallocate(T *p, size_t n) \
n 359 gc/include/new_gc_alloc.h { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
n 110 gc/include/private/cord_pos.h #define CORD_pos_advance(p,n) ((p)[0].cur_pos += (n) - 1, CORD_next(p))
n 128 gc/include/private/dbg_mlc.h #define SIMPLE_ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + WORDS_TO_BYTES(1) - 1)
n 107 gc/include/private/gc_locks.h long oldval, n = 1;
n 111 gc/include/private/gc_locks.h : "r"(n), "1"(*addr) : "memory");
n 113 gc/include/private/gc_locks.h oldval = _InterlockedExchange(addr, n);
n 362 gc/include/private/gc_priv.h # define BCOPY(x,y,n) memcpy(y, x, (size_t)(n))
n 363 gc/include/private/gc_priv.h # define BZERO(x,n) memset(x, 0, (size_t)(n))
n 365 gc/include/private/gc_priv.h # define BCOPY(x,y,n) bcopy((char *)(x),(char *)(y),(int)(n))
n 366 gc/include/private/gc_priv.h # define BZERO(x,n) bzero((char *)(x),(int)(n))
n 478 gc/include/private/gc_priv.h # define modWORDSZ(n) ((n) & 0x1f) /* n mod size of word */
n 488 gc/include/private/gc_priv.h # define modWORDSZ(n) ((n) & 0x3f) /* n mod size of word */
n 498 gc/include/private/gc_priv.h #define divWORDSZ(n) ((n) >> LOGWL) /* divide n by size of word */
n 556 gc/include/private/gc_priv.h # define divHBLKSZ(n) ((n) >> LOG_HBLKSIZE)
n 566 gc/include/private/gc_priv.h # define modHBLKSZ(n) ((n) & (HBLKSIZE-1))
n 573 gc/include/private/gc_priv.h # define ROUNDED_UP_WORDS(n) \
n 574 gc/include/private/gc_priv.h BYTES_TO_WORDS((n) + (WORDS_TO_BYTES(1) - 1 + EXTRA_BYTES))
n 576 gc/include/private/gc_priv.h # define ALIGNED_WORDS(n) \
n 577 gc/include/private/gc_priv.h (BYTES_TO_WORDS((n) + WORDS_TO_BYTES(2) - 1 + EXTRA_BYTES) & ~1)
n 579 gc/include/private/gc_priv.h # define ALIGNED_WORDS(n) ROUNDED_UP_WORDS(n)
n 1254 gc/include/private/gc_priv.h # define mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[(n) >> 1])
n 1255 gc/include/private/gc_priv.h # define set_mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[(n)>>1]) = 1
n 1256 gc/include/private/gc_priv.h # define clear_mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[(n)>>1]) = 0
n 1258 gc/include/private/gc_priv.h # define mark_bit_from_hdr(hhdr,n) (((hhdr)->hb_marks[divWORDSZ(n)] \
n 1259 gc/include/private/gc_priv.h >> (modWORDSZ(n))) & (word)1)
n 1260 gc/include/private/gc_priv.h # define set_mark_bit_from_hdr(hhdr,n) \
n 1261 gc/include/private/gc_priv.h OR_WORD((hhdr)->hb_marks+divWORDSZ(n), \
n 1262 gc/include/private/gc_priv.h (word)1 << modWORDSZ(n))
n 1263 gc/include/private/gc_priv.h # define clear_mark_bit_from_hdr(hhdr,n) (hhdr)->hb_marks[divWORDSZ(n)] \
n 1264 gc/include/private/gc_priv.h &= ~((word)1 << modWORDSZ(n))
n 1562 gc/include/private/gc_priv.h GC_bool GC_expand_hp_inner GC_PROTO((word n));
n 1613 gc/include/private/gc_priv.h void GC_collect_a_little_inner GC_PROTO((int n));
n 1783 gc/include/private/gc_priv.h void GC_is_fresh GC_PROTO((struct hblk *h, word n));
n 61 gc/include/private/pthread_support.h # define INDEX_FROM_BYTES(n) ((ADD_SLOP(n) + GRANULARITY - 1)/GRANULARITY)
n 22 gc/include/private/specific.h #define MALLOC_CLEAR(n) GC_INTERNAL_MALLOC(n, NORMAL)
n 26 gc/include/private/specific.h #define CACHE_HASH(n) (((((long)n) >> 8) ^ (long)n) & (TS_CACHE_SIZE - 1))
n 28 gc/include/private/specific.h #define HASH(n) (((((long)n) >> 8) ^ (long)n) & (TS_HASH_SIZE - 1))
n 353 gc/malloc.c GC_PTR calloc(size_t n, size_t lb)
n 355 gc/malloc.c GC_PTR calloc(n, lb)
n 356 gc/malloc.c size_t n, lb;
n 359 gc/malloc.c return((GC_PTR)REDIRECT_MALLOC(n*lb));
n 248 gc/mallocx.c void GC_incr_words_allocd(size_t n)
n 250 gc/mallocx.c GC_words_allocd += n;
n 254 gc/mallocx.c void GC_incr_mem_freed(size_t n)
n 256 gc/mallocx.c GC_mem_freed += n;
n 535 gc/mark.c # define PROF(n) GC_prof_array[n]++
n 537 gc/mark.c # define PROF(n)
n 915 gc/mark.c unsigned n;
n 924 gc/mark.c for (n = 0; n < N_LOCAL_ITERS; ++n) {
n 1135 gc/mark.c static void alloc_mark_stack(n)
n 1136 gc/mark.c word n;
n 1138 gc/mark.c mse * new_stack = (mse *)GC_scratch_alloc(n * sizeof(struct GC_ms_entry));
n 1154 gc/mark.c GC_mark_stack_size = n;
n 1155 gc/mark.c GC_mark_stack_limit = new_stack + n;
n 1166 gc/mark.c (unsigned long) n);
n 1176 gc/mark.c GC_mark_stack_size = n;
n 1177 gc/mark.c GC_mark_stack_limit = new_stack + n;
n 2142 gc/os_dep.c void GC_is_fresh(h, n)
n 2144 gc/os_dep.c word n;
n 3047 gc/os_dep.c void GC_is_fresh(h, n)
n 3049 gc/os_dep.c word n;
n 3284 gc/os_dep.c void GC_is_fresh(h, n)
n 3286 gc/os_dep.c word n;
n 3295 gc/os_dep.c for (i = 0; i < n; i++) {
n 835 gc/reclaim.c static int set_bits(n)
n 836 gc/reclaim.c word n;
n 838 gc/reclaim.c register word m = n;
n 81 gc/solaris_pthreads.c int n;
n 119 gc/solaris_pthreads.c (void)pthread_attr_getscope(attr_in, &n);
n 120 gc/solaris_pthreads.c (void)pthread_attr_setscope(&attr, n);
n 123 gc/solaris_pthreads.c (void)pthread_attr_getschedpolicy(attr_in, &n);
n 124 gc/solaris_pthreads.c (void)pthread_attr_setschedpolicy(&attr, n);
n 125 gc/solaris_pthreads.c (void)pthread_attr_getinheritsched(attr_in, &n);
n 126 gc/solaris_pthreads.c (void)pthread_attr_setinheritsched(&attr, n);
n 81 gc/solaris_threads.c void GC_msec_sleep(int n)
n 86 gc/solaris_threads.c ts.tv_nsec = 1000000*n;
n 185 gc/solaris_threads.c #define ROUNDUP(n) WORDS_TO_BYTES(ROUNDED_UP_WORDS(n))
n 187 gc/solaris_threads.c static void set_max_lwps(GC_word n)
n 191 gc/solaris_threads.c int required_bytes = ROUNDUP(n * sizeof(struct lwp_cache_entry))
n 192 gc/solaris_threads.c + ROUNDUP(n * sizeof(prgregset_t))
n 193 gc/solaris_threads.c + ROUNDUP((n + 1) * sizeof(lwpid_t))
n 194 gc/solaris_threads.c + ROUNDUP((n + 1) * sizeof(lwpid_t));
n 205 gc/solaris_threads.c mem += ROUNDUP(n * sizeof(struct lwp_cache_entry));
n 209 gc/solaris_threads.c mem += ROUNDUP(n * sizeof(prgregset_t));
n 213 gc/solaris_threads.c mem += ROUNDUP((n + 1) * sizeof(lwpid_t));
n 216 gc/solaris_threads.c mem += ROUNDUP((n + 1)* sizeof(lwpid_t));
n 221 gc/solaris_threads.c max_lwps = n;
n 794 gc/tests/test.c tn * mktree(n)
n 795 gc/tests/test.c int n;
n 821 gc/tests/test.c if (n == 0) return(0);
n 826 gc/tests/test.c result -> level = n;
n 827 gc/tests/test.c result -> lchild = mktree(n-1);
n 828 gc/tests/test.c result -> rchild = mktree(n-1);
n 829 gc/tests/test.c if (counter++ % 17 == 0 && n >= 2) {
n 872 gc/tests/test.c GC_REGISTER_FINALIZER((GC_PTR)result, finalizer, (GC_PTR)(GC_word)n,
n 901 gc/tests/test.c void chktree(t,n)
n 903 gc/tests/test.c int n;
n 905 gc/tests/test.c if (n == 0 && t != 0) {
n 909 gc/tests/test.c if (n == 0) return;
n 910 gc/tests/test.c if (t -> level != n) {
n 912 gc/tests/test.c (unsigned long)n);
n 919 gc/tests/test.c chktree(t -> lchild, n-1);
n 924 gc/tests/test.c chktree(t -> rchild, n-1);
n 1009 gc/tests/test.c void alloc_small(n)
n 1010 gc/tests/test.c int n;
n 1014 gc/tests/test.c for (i = 0; i < n; i += 8) {
n 1176 gc/tests/test.c int n = 0, i, j;
n 1177 gc/tests/test.c q[n++] = p;
n 1179 gc/tests/test.c for (;(q[n] = va_arg(a,void *));n++) ;
n 1181 gc/tests/test.c for (i=0; i<n; i++)
n 1195 gc/tests/test.c # define TEST_FAIL_COUNT(n) 1
n 1197 gc/tests/test.c # define TEST_FAIL_COUNT(n) (fail_count >= (n))
n 1484 gc/tests/test.c int APIENTRY WinMain(HINSTANCE instance, HINSTANCE prev, LPTSTR cmd, int n)
n 1634 gc/tests/test.c int APIENTRY GC_WinMain(HINSTANCE instance, HINSTANCE prev, LPWSTR cmd, int n)
n 1636 gc/tests/test.c int APIENTRY WinMain(HINSTANCE instance, HINSTANCE prev, LPSTR cmd, int n)
n 202 gc/tests/test_cpp.cc int i, iters, n;
n 218 gc/tests/test_cpp.cc if (argc != 2 || (0 >= (n = atoi( argv[ 1 ] )))) {
n 220 gc/tests/test_cpp.cc n = 10;}
n 222 gc/tests/test_cpp.cc for (iters = 1; iters <= n; iters++) {
n 719 gc/typd_mlc.c void * GC_calloc_explicitly_typed(size_t n,
n 723 gc/typd_mlc.c char * GC_calloc_explicitly_typed(n, lb, d)
n 724 gc/typd_mlc.c size_t n;
n 738 gc/typd_mlc.c descr_type = GC_make_array_descriptor((word)n, (word)lb, d,
n 742 gc/typd_mlc.c case SIMPLE: return(GC_malloc_explicitly_typed(n*lb, simple_descr));
n 744 gc/typd_mlc.c lb *= n;
n 748 gc/typd_mlc.c lb *= n;
n 805 gc/typd_mlc.c return(GC_malloc(n*lb));
n 943 src/bignum.c int j, k, n, m;
n 946 src/bignum.c #define DIGIT(num, n) (((n)%2)? HI((num)->values[(n)/2]) : LO((num)->values[(n)/2]))
n 947 src/bignum.c #define DIGIT2(num, n) \
n 948 src/bignum.c (((n)%2)? \
n 949 src/bignum.c ((LO((num)->values[(n)/2+1])<<HALF_BITS)|HI((num)->values[(n)/2])): \
n 950 src/bignum.c (num)->values[(n)/2])
n 951 src/bignum.c #define SETDIGIT(num, n, v) \
n 952 src/bignum.c (((n)%2)? \
n 953 src/bignum.c (num->values[(n)/2] = (num->values[(n)/2] & LOMASK)|((v) << HALF_BITS)) :\
n 954 src/bignum.c (num->values[(n)/2] = (num->values[(n)/2] & HIMASK)|((v) & LOMASK)))
n 955 src/bignum.c #define SETDIGIT2(num, n, v) \
n 956 src/bignum.c (((n)%2)? \
n 957 src/bignum.c ((num->values[(n)/2] = LO(num->values[(n)/2])|((v)<<HALF_BITS)), \
n 958 src/bignum.c (num->values[(n)/2+1] = (num->values[(n)/2+1] & HIMASK)|HI(v))) : \
n 959 src/bignum.c (num->values[(n)/2] = (v)))
n 966 src/bignum.c n = divisor->size*2 - 1;
n 967 src/bignum.c m = dividend->size*2 - n;
n 969 src/bignum.c n = divisor->size*2;
n 970 src/bignum.c m = dividend->size*2 - n;
n 974 src/bignum.c vn_1 = DIGIT(v, n-1);
n 975 src/bignum.c vn_2 = DIGIT(v, n-2);
n 978 src/bignum.c Scm_Printf(SCM_CUROUT, "shift=%d, n=%d, m=%d\n", d, n, m);
n 985 src/bignum.c u_long uu = (DIGIT(u, j+n) << HALF_BITS) + DIGIT(u, j+n-1);
n 993 src/bignum.c while ((qq*vn_2 > (rr<<HALF_BITS)+DIGIT(u, j+n-2)) && (rr < HALF_WORD)) {
n 1001 src/bignum.c for (k = 0; k < n; k++) {
n 1016 src/bignum.c for (k = 0; k < n; k++) {
n 1022 src/bignum.c uj = DIGIT(u, j+n) + cy;
n 1023 src/bignum.c SETDIGIT(u, j+n, uj);
n 1040 src/bignum.c int n = dividend->size - 1;
n 1044 src/bignum.c for (; n > 0; n--) {
n 1045 src/bignum.c q1 = pu[n] / divisor + q0;
n 1046 src/bignum.c r1 = ((pu[n] % divisor) << HALF_BITS) + HI(pu[n-1]);
n 1049 src/bignum.c pu[n] = q1;
n 1050 src/bignum.c pu[n-1] = (r0 << HALF_BITS) + LO(pu[n-1]);
n 97 src/char.c ScmChar Scm_IntToDigit(int n, int radix)
n 99 src/char.c if (n < 0) return SCM_CHAR_INVALID;
n 101 src/char.c if (n < radix) return (ScmChar)(n + '0');
n 104 src/char.c if (n < 10) return (ScmChar)(n + '0');
n 105 src/char.c if (n < radix) return (ScmChar)(n - 10 + 'a');
n 117 src/char.c ScmChar Scm_UcsToChar(int n)
n 119 src/char.c if (n < 0) Scm_Error("bad character code: %d", n);
n 121 src/char.c return (ScmChar)n;
n 123 src/char.c if (n < 0x80) return (ScmChar)n; /*ASCII range*/
n 132 src/char.c return Scm_UcsToCharHook(n);
n 134 src/char.c if (n < 0x100) return (ScmChar)n; /* ISO8859-1 */
n 398 src/char.c struct ScmCharSetRange *n = SCM_NEW(struct ScmCharSetRange);
n 399 src/char.c n->next = next;
n 400 src/char.c n->lo = lo;
n 401 src/char.c n->hi = hi;
n 402 src/char.c return n;
n 851 src/char.c #define CS(n) predef_charsets[n]
n 1757 src/class.c int n = 0;
n 1758 src/class.c if (!SCM_INTP(val) || ((n = SCM_INT_VALUE(val)) < 0))
n 1760 src/class.c sa->slotNumber = n;
n 1995 src/class.c int n;
n 1999 src/class.c for (ap = args, sp = m->specializers, n = 0;
n 2000 src/class.c n < m->common.required;
n 2001 src/class.c ap++, sp++, n++) {
n 2004 src/class.c if (n == m->common.required) SCM_APPEND1(h, t, SCM_OBJ(m));
n 2017 src/class.c int n = Scm_Length(arglist), i;
n 2018 src/class.c if (n < 0) Scm_Error("bad argument list: %S", arglist);
n 2020 src/class.c argv = SCM_NEW_ARRAY(ScmObj, n);
n 2023 src/class.c return Scm_ComputeApplicableMethods(gf, argv, n);
n 1013 src/code.c const char *n;
n 1021 src/code.c n = Scm_GetStringConst(SCM_STRING(name));
n 1024 src/code.c if (strcmp(insn_table[i].name, n) == 0) {
n 1164 src/extlib.c int n;
n 1173 src/extlib.c n = SCM_INT_VALUE(n_scm);
n 1187 src/extlib.c r = Scm_IntToDigit(n, radix);
n 1200 src/extlib.c int n;
n 1204 src/extlib.c n = Scm_GetInteger(n_scm);
n 1206 src/extlib.c ScmChar ch = Scm_UcsToChar(n);
n 4148 src/extlib.c int n = Scm_WriteLimited(obj, port, SCM_WRITE_WRITE, limit);
n 4149 src/extlib.c SCM_RETURN(SCM_MAKE_INT(n));
n 4175 src/extlib.c int n = Scm_WriteCircular(obj, port, SCM_WRITE_WRITE, 0);
n 4176 src/extlib.c SCM_RETURN(SCM_MAKE_INT(n));
n 267 src/gauche.h SCM_EXTERN ScmChar Scm_IntToDigit(int n, int radix);
n 64 src/gauche/memory.h #define SCM_MALLOC_WORDS(p, n, type) \
n 67 src/gauche/memory.h GC_MALLOC_WORDS(SCMMW__tmpptr, n); \
n 71 src/gauche/memory.h #define SCM_MALLOC_ATOMIC_WORDS(p, n) \
n 74 src/gauche/memory.h GC_MALLOC_ATOMIC_WORDS(SCMMW__tmpptr, n); \
n 107 src/gauche/memory.h #define SCM_MALLOC_WORDS(p, n, type) \
n 108 src/gauche/memory.h (p = (type)SCM_MALLOC(n * sizeof(GC_word)))
n 110 src/gauche/memory.h #define SCM_MALLOC_ATOMIC_WORDS(p, n, type) \
n 111 src/gauche/memory.h (p = (type)SCM_MALLOC_ATOMIC(n * sizeof(GC_word)))
n 84 src/hash.c unsigned int n = 1;
n 85 src/hash.c while (n < val) {
n 86 src/hash.c n <<= 1;
n 87 src/hash.c SCM_ASSERT(n > 1); /* check overflow */
n 89 src/hash.c return n;
n 331 src/macro.c ScmObj n;
n 333 src/macro.c n = SCM_OBJ(SCM_IDENTIFIER(name)->name);
n 335 src/macro.c n = name;
n 530 src/module.c int n = SCM_CHAR_NFOLLOWS(*p);
n 532 src/module.c else p += n+1;
n 546 src/module.c int n = SCM_CHAR_NFOLLOWS(*p);
n 549 src/module.c else p += n+1;
n 1876 src/number.c static inline u_long ipow(int r, int n)
n 1879 src/number.c for (k=1; n>0; n--) k *= r;
n 1888 src/number.c static double raise_pow10(double x, int n)
n 1895 src/number.c if (n >= 0) {
n 1896 src/number.c while (n > 23) {
n 1898 src/number.c n -= 24;
n 1900 src/number.c return x*dpow10[n];
n 1902 src/number.c while (n < -23) {
n 1904 src/number.c n += 24;
n 1906 src/number.c return x/dpow10[-n];
n 2706 src/number.c u_long n;
n 2712 src/number.c for (i = 0, n = 1; ; i++, n *= radix) {
n 2713 src/number.c if (n >= LONG_MAX/radix) {
n 2715 src/number.c bigdig[radix-RADIX_MIN] = n;
n 652 src/portapi.c int i, n = 0;
n 662 src/portapi.c SAFE_CALL(p, n = Scm_Getz(buf+i, buflen-i, p));
n 663 src/portapi.c return i + n;
n 685 src/regexp.c ScmObj n = SCM_CADR(token), m = SCM_CDDR(token);
n 689 src/regexp.c SCM_ASSERT(SCM_INTP(n));
n 690 src/regexp.c item = Scm_MakeList(SCM_INT_VALUE(n), SCM_CAR(stack));
n 701 src/regexp.c m_n = SCM_INT_VALUE(m)-SCM_INT_VALUE(n);
n 1253 src/regexp.c int count, n, j0 = 0, jn;
n 1263 src/regexp.c for (n=0; n<count; n++) {
n 1264 src/regexp.c if (n>0) rc3_fill_offset(ctx, j0, ctx->codep);
n 1294 src/regexp.c for (n=0; n<count; n++) {
n 96 src/string.c int n = SCM_CHAR_NFOLLOWS(*p) + 1;
n 97 src/string.c for (; n > 0 && s > 0; p++, n--, s--, i++) {
n 447 src/string.c int n;
n 450 src/string.c n = SCM_CHAR_NFOLLOWS(*current);
n 451 src/string.c current += n + 1;
n 62 src/symbol.c ScmObj n = Scm_CopyStringWithFlags(name, SCM_STRING_IMMUTABLE,
n 65 src/symbol.c INITSYM(sym, n);
n 66 src/symbol.c Scm_HashTablePut(obtable, n, SCM_OBJ(sym));
n 2556 src/syslib.c int n;
n 2557 src/syslib.c SCM_SYSCALL(n, readlink(path, buf, READLINK_PATH_MAX));
n 2558 src/syslib.c if (n < 0) Scm_SysError("readlink failed");
n 2559 src/syslib.c if (n == READLINK_PATH_MAX) Scm_Error("readlink result too long");
n 2560 src/syslib.c return Scm_MakeString(buf, n, -1, SCM_MAKSTR_COPYING);
n 306 src/vm.c #define CHECK_STACK_PARANOIA(n) CHECK_STACK(n)
n 308 src/vm.c #define CHECK_STACK_PARANOIA(n) /*empty*/
n 938 src/vm.c ScmNextMethod *n = SCM_NEXT_METHOD(VAL0);
n 940 src/vm.c CHECK_STACK(n->nargs+1);
n 941 src/vm.c memcpy(SP, n->args, sizeof(ScmObj)*n->nargs);
n 942 src/vm.c SP += n->nargs;
n 943 src/vm.c argc = n->nargs;
n 945 src/vm.c if (SCM_NULLP(n->methods)) {
n 946 src/vm.c VAL0 = SCM_OBJ(n->generic);
n 949 src/vm.c nm = Scm_MakeNextMethod(n->generic,
n 950 src/vm.c SCM_CDR(n->methods),
n 952 src/vm.c VAL0 = SCM_CAR(n->methods);
n 1101 src/write.c int n = Scm_WriteCircular(val, SCM_OBJ(out), mode, width);
n 1102 src/write.c if (n < 0 && prec > 0) {
n 1105 src/write.c if (n > 0) {
n 1106 src/write.c for (; n < prec; n++) Scm_PutcUnsafe(' ', out);
n 1111 src/write.c int n = Scm_WriteLimited(val, SCM_OBJ(out), mode, width);
n 1112 src/write.c if (n < 0 && prec > 0) {
n 1115 src/write.c if (n > 0) {
n 1116 src/write.c for (; n < prec; n++) Scm_PutcUnsafe(' ', out);