p 236 ext/charconv/charconv.c ScmConvInfo *info = (ScmConvInfo*)p->src.buf.data;
p 1169 ext/charconv/jconv.c const char *p, *q;
p 1170 ext/charconv/jconv.c for (p=s, q=t; *p && *q; p++, q++) {
p 1171 ext/charconv/jconv.c if (*p == '-' || *p == '_') {
p 1174 ext/charconv/jconv.c if (tolower(*p) != tolower(*q)) return FALSE;
p 1177 ext/charconv/jconv.c if (*p || *q) return FALSE;
p 72 ext/digest/md5c.c unsigned char *p = (unsigned char *) ctx->in + t;
p 76 ext/digest/md5c.c memcpy(p, buf, len);
p 79 ext/digest/md5c.c memcpy(p, buf, t);
p 107 ext/digest/md5c.c unsigned char *p;
p 114 ext/digest/md5c.c p = ctx->in + count;
p 115 ext/digest/md5c.c *p++ = 0x80;
p 123 ext/digest/md5c.c memset(p, 0, count);
p 131 ext/digest/md5c.c memset(p, 0, count - 8);
p 320 ext/digest/sha.c u_char *p = (u_char *) ctx->key + i; /* First unused byte */
p 324 ext/digest/sha.c *p++ = 0x80;
p 331 ext/digest/sha.c memset (p, 0, i);
p 334 ext/digest/sha.c p = (u_char *) ctx->key;
p 337 ext/digest/sha.c memset (p, 0, i - 8);
p 192 ext/mt-random/mt-lib.c ScmUInt32 *p = SCM_U32VECTOR_ELEMENTS(v);
p 193 ext/mt-random/mt-lib.c for (i=0; i<len; i++) *p++ = Scm_MTGenrandU32(mt);
p 216 ext/mt-random/mt-lib.c float *p = SCM_F32VECTOR_ELEMENTS(v);
p 217 ext/mt-random/mt-lib.c for (i=0; i<len; i++) *p++ = Scm_MTGenrandF32(mt, TRUE);
p 240 ext/mt-random/mt-lib.c double *p = SCM_F64VECTOR_ELEMENTS(v);
p 241 ext/mt-random/mt-lib.c for (i=0; i<len; i++) *p++ = Scm_MTGenrandF64(mt, TRUE);
p 69 ext/net/netdb.c char **p;
p 73 ext/net/netdb.c for (p = he->h_aliases; *p; p++) {
p 74 ext/net/netdb.c SCM_APPEND1(h, t, SCM_MAKE_STR_COPYING(*p));
p 79 ext/net/netdb.c for (p = he->h_addr_list; *p; p++) {
p 81 ext/net/netdb.c struct in_addr *addr = (struct in_addr*)*p;
p 230 ext/net/netdb.c char **p;
p 234 ext/net/netdb.c for (p = pe->p_aliases; *p; p++) {
p 235 ext/net/netdb.c SCM_APPEND1(h, t, SCM_MAKE_STR_COPYING(*p));
p 354 ext/net/netdb.c char **p;
p 358 ext/net/netdb.c for (p = se->s_aliases; *p; p++) {
p 359 ext/net/netdb.c SCM_APPEND1(h, t, SCM_MAKE_STR_COPYING(*p));
p 247 ext/net/netlib.c u_long *p = (u_long*)a->addr.sin6_addr.s6_addr;
p 251 ext/net/netlib.c for (i = 0; i < BN_SIZE; i++) values[BN_SIZE-i-1] = ntohl(*p++);
p 86 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 109 ext/vport/vport.c Scm_UngetbUnsafe(buf[i], p);
p 124 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 138 ext/vport/vport.c n = SCM_CHAR_NFOLLOWS(p->scratch[0]);
p 161 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 181 ext/vport/vport.c byte = vport_getb(p);
p 195 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 213 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 224 ext/vport/vport.c Scm_PortError(p, SCM_PORT_ERROR_UNIT,
p 225 ext/vport/vport.c "cannot perform binary output to the port %S", p);
p 237 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 242 ext/vport/vport.c Scm_PortError(p, SCM_PORT_ERROR_OTHER,
p 243 ext/vport/vport.c "cannot perform output to the port %S", p);
p 262 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 276 ext/vport/vport.c Scm_PortError(p, SCM_PORT_ERROR_UNIT,
p 277 ext/vport/vport.c "cannot perform binary output to the port %S", p);
p 286 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 296 ext/vport/vport.c vport_putz(SCM_STRING_BODY_START(b), SCM_STRING_BODY_SIZE(b), p);
p 307 ext/vport/vport.c Scm_PortError(p, SCM_PORT_ERROR_OTHER,
p 308 ext/vport/vport.c "cannot perform output to the port %S", p);
p 317 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 329 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 341 ext/vport/vport.c vport *data = (vport*)p->src.vt.data;
p 411 ext/vport/vport.c static ScmObj SCM_CPP_CAT3(vport_,name,_get) (ScmObj p) \
p 413 ext/vport/vport.c vport *data = (vport*)SCM_PORT(p)->src.vt.data; \
p 417 ext/vport/vport.c static void SCM_CPP_CAT3(vport_,name,_set) (ScmObj p, ScmObj v) \
p 419 ext/vport/vport.c vport *data = (vport*)SCM_PORT(p)->src.vt.data; \
p 510 ext/vport/vport.c bport *data = (bport*)p->src.buf.data;
p 517 ext/vport/vport.c (unsigned char*)p->src.buf.buffer);
p 529 ext/vport/vport.c bport *data = (bport*)p->src.buf.data;
p 536 ext/vport/vport.c (unsigned char*)p->src.buf.buffer);
p 548 ext/vport/vport.c bport *data = (bport*)p->src.buf.data;
p 560 ext/vport/vport.c bport *data = (bport*)p->src.buf.data;
p 577 ext/vport/vport.c bport *data = (bport*)p->src.buf.data;
p 594 ext/vport/vport.c bport *data = (bport*)p->src.buf.data;
p 659 ext/vport/vport.c static ScmObj SCM_CPP_CAT3(bport_,name,_get) (ScmObj p) \
p 661 ext/vport/vport.c bport *data = (bport*)SCM_PORT(p)->src.buf.data; \
p 665 ext/vport/vport.c static void SCM_CPP_CAT3(bport_,name,_set) (ScmObj p, ScmObj v) \
p 667 ext/vport/vport.c bport *data = (bport*)SCM_PORT(p)->src.buf.data; \
p 197 gc/aix_irix_threads.c register GC_thread p = GC_threads[hv];
p 201 gc/aix_irix_threads.c while (p != gc_id) {
p 202 gc/aix_irix_threads.c prev = p;
p 203 gc/aix_irix_threads.c p = p -> next;
p 206 gc/aix_irix_threads.c GC_threads[hv] = p -> next;
p 208 gc/aix_irix_threads.c prev -> next = p -> next;
p 221 gc/aix_irix_threads.c register GC_thread p = GC_threads[hv];
p 228 gc/aix_irix_threads.c while (p != 0 && !pthread_equal(p -> id, id)) p = p -> next;
p 229 gc/aix_irix_threads.c return(p);
p 237 gc/aix_irix_threads.c register GC_thread p;
p 243 gc/aix_irix_threads.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 244 gc/aix_irix_threads.c if (p -> id != my_thread) {
p 245 gc/aix_irix_threads.c pthread_suspend_np(p->id);
p 254 gc/aix_irix_threads.c GC_thread p;
p 261 gc/aix_irix_threads.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 262 gc/aix_irix_threads.c if (p -> id != my_thread) {
p 263 gc/aix_irix_threads.c pthread_continue_np(p->id);
p 276 gc/aix_irix_threads.c register GC_thread p;
p 282 gc/aix_irix_threads.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 283 gc/aix_irix_threads.c if (p -> id != my_thread) {
p 284 gc/aix_irix_threads.c if (p -> flags & FINISHED) {
p 285 gc/aix_irix_threads.c p -> stop = STOPPED;
p 288 gc/aix_irix_threads.c p -> stop = PLEASE_STOP;
p 289 gc/aix_irix_threads.c result = pthread_kill(p -> id, SIG_SUSPEND);
p 294 gc/aix_irix_threads.c p -> stop = STOPPED;
p 306 gc/aix_irix_threads.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 307 gc/aix_irix_threads.c while (p -> id != my_thread && p -> stop != STOPPED) {
p 320 gc/aix_irix_threads.c result = pthread_kill(p -> id, SIG_SUSPEND);
p 332 gc/aix_irix_threads.c GC_thread p;
p 338 gc/aix_irix_threads.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 339 gc/aix_irix_threads.c p -> stop = NOT_STOPPED;
p 357 gc/aix_irix_threads.c register GC_thread p;
p 369 gc/aix_irix_threads.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 370 gc/aix_irix_threads.c if (p -> flags & FINISHED) continue;
p 371 gc/aix_irix_threads.c cold = p->stack_cold;
p 373 gc/aix_irix_threads.c if (pthread_equal(p -> id, me)) {
p 380 gc/aix_irix_threads.c pthread_t id = p -> id;
p 404 gc/aix_irix_threads.c hot = p -> stack_hot;
p 169 gc/allchblk.c ptr_t p;
p 182 gc/allchblk.c for (p = start; p < end;) {
p 183 gc/allchblk.c hhdr = HDR(p);
p 184 gc/allchblk.c GC_printf1("\t0x%lx ", (unsigned long)p);
p 187 gc/allchblk.c p += HBLKSIZE;
p 210 gc/allchblk.c p += hhdr -> hb_sz;
p 214 gc/allchblk.c p += HBLKSIZE * OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
p 304 gc/allchblk.c struct hblk * p = h - 1;
p 307 gc/allchblk.c GET_HDR(p, phdr);
p 309 gc/allchblk.c p = FORWARDED_ADDR(p,phdr);
p 310 gc/allchblk.c phdr = HDR(p);
p 314 gc/allchblk.c return p;
p 319 gc/allchblk.c p = GC_prev_block(h - 1);
p 320 gc/allchblk.c if (0 != p) {
p 321 gc/allchblk.c phdr = HDR(p);
p 322 gc/allchblk.c if (HBLK_IS_FREE(phdr) && (ptr_t)p + phdr -> hb_sz == (ptr_t)h) {
p 323 gc/allchblk.c return p;
p 587 gc/alloc.c ptr_t p;
p 592 gc/alloc.c for (p = q; p != 0; p = obj_link(p)){
p 593 gc/alloc.c h = HBLKPTR(p);
p 598 gc/alloc.c word_no = (((word *)p) - ((word *)h));
p 612 gc/alloc.c ptr_t p;
p 617 gc/alloc.c for (p = q; p != 0; p = obj_link(p)){
p 618 gc/alloc.c h = HBLKPTR(p);
p 623 gc/alloc.c word_no = (((word *)p) - ((word *)h));
p 814 gc/alloc.c phdr = GC_install_header(p);
p 821 gc/alloc.c GC_heap_sects[GC_n_heap_sects].hs_start = (ptr_t)p;
p 828 gc/alloc.c GC_freehblk(p);
p 830 gc/alloc.c if ((ptr_t)p <= (ptr_t)GC_least_plausible_heap_addr
p 832 gc/alloc.c GC_least_plausible_heap_addr = (GC_PTR)((ptr_t)p - sizeof(word));
p 838 gc/alloc.c if ((ptr_t)p + bytes >= (ptr_t)GC_greatest_plausible_heap_addr) {
p 839 gc/alloc.c GC_greatest_plausible_heap_addr = (GC_PTR)((ptr_t)p + bytes);
p 106 gc/backgraph.c back_edges *last = p;
p 110 gc/backgraph.c avail_back_edges = p;
p 141 gc/backgraph.c in_progress_space[n_in_progress++] = p;
p 148 gc/backgraph.c if (in_progress_space[i] == p) return TRUE;
p 156 gc/backgraph.c GC_ASSERT(in_progress_space[n_in_progress] == p);
p 160 gc/backgraph.c (ptr_t)REVEAL_POINTER(((oh *)(p)) -> oh_bg_ptr)
p 161 gc/backgraph.c #define SET_OH_BG_PTR(p,q) (((oh *)(p)) -> oh_bg_ptr) = HIDE_POINTER(q)
p 167 gc/backgraph.c ptr_t q = GET_OH_BG_PTR(p); \
p 189 gc/backgraph.c ptr_t old_back_ptr = GET_OH_BG_PTR(p);
p 203 gc/backgraph.c SET_OH_BG_PTR(p, (word)be | FLAG_MANY);
p 222 gc/backgraph.c GC_ASSERT(p == GC_base(p) && q == GC_base(q));
p 223 gc/backgraph.c if (!GC_HAS_DEBUG_INFO(q) || !GC_HAS_DEBUG_INFO(p)) {
p 229 gc/backgraph.c SET_OH_BG_PTR(q, p);
p 234 gc/backgraph.c FOR_EACH_PRED(pred, q, { if (p == pred) return; });
p 245 gc/backgraph.c be_cont -> edges[i] = p;
p 281 gc/backgraph.c if (GC_HAS_DEBUG_INFO(p)) {
p 282 gc/backgraph.c ptr_t old_back_ptr = GET_OH_BG_PTR(p);
p 287 gc/backgraph.c SET_OH_BG_PTR(p, 0);
p 291 gc/backgraph.c GC_ASSERT(GC_is_marked(p));
p 302 gc/backgraph.c GC_ASSERT(GC_is_marked(p));
p 309 gc/backgraph.c SET_OH_BG_PTR(p, 0);
p 316 gc/backgraph.c word *currentp = (word *)(p + sizeof(oh));
p 322 gc/backgraph.c while (currentp < (word *)(p + gc_descr)) {
p 329 gc/backgraph.c add_edge(p, target);
p 348 gc/backgraph.c ptr_t back_ptr = GET_OH_BG_PTR(p);
p 353 gc/backgraph.c if (is_in_progress(p)) return 0; /* DFS back edge, i.e. we followed */
p 356 gc/backgraph.c push_in_progress(p);
p 358 gc/backgraph.c pop_in_progress(p);
p 368 gc/backgraph.c FOR_EACH_PRED(q, p, {
p 370 gc/backgraph.c if (GC_is_marked(q) && !(FLAG_MANY & (word)GET_OH_BG_PTR(p))) {
p 372 gc/backgraph.c GC_printf2("Found bogus pointer from 0x%lx to 0x%lx\n", q, p);
p 397 gc/backgraph.c if (GC_is_marked(p) && GC_HAS_DEBUG_INFO(p)) {
p 407 gc/backgraph.c back_ptr = GET_OH_BG_PTR(p);
p 412 gc/backgraph.c FOR_EACH_PRED(q, p, {
p 426 gc/backgraph.c ensure_struct(p);
p 427 gc/backgraph.c back_ptr = GET_OH_BG_PTR(p);
p 62 gc/blacklst.c ptr_t base = GC_base(p);
p 73 gc/blacklst.c ptr_t base = GC_base(p);
p 75 gc/blacklst.c if (0 == p) {
p 180 gc/blacklst.c if (!(GC_modws_valid_offsets[p & (sizeof(word)-1)])) return;
p 182 gc/blacklst.c register int index = PHT_HASH(p);
p 184 gc/blacklst.c if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_normal_bl, index)) {
p 189 gc/blacklst.c (unsigned long) p, (unsigned long) source);
p 209 gc/blacklst.c register int index = PHT_HASH(p);
p 211 gc/blacklst.c if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_stack_bl, index)) {
p 216 gc/blacklst.c (unsigned long)p, (unsigned long)source);
p 40 gc/checksums.c register word *p = (word *)h;
p 44 gc/checksums.c while (p < lim) {
p 45 gc/checksums.c result += *p++;
p 58 gc/checksums.c ptr_t p;
p 61 gc/checksums.c for (p = GC_sobjfreelist[sz]; p != 0; p = obj_link(p)) {
p 62 gc/checksums.c if (HBLKPTR(p) == h) return(TRUE);
p 425 gc/cord/cordbscs.c register char * p = buf;
p 435 gc/cord/cordbscs.c *p++ = c;
p 437 gc/cord/cordbscs.c *p = '\0';
p 468 gc/cord/cordbscs.c register const char *p = x+i;
p 470 gc/cord/cordbscs.c if (*p == '\0') ABORT("2nd arg to CORD_iter5 too big");
p 472 gc/cord/cordbscs.c return((*f2)(p, client_data));
p 474 gc/cord/cordbscs.c while (*p) {
p 475 gc/cord/cordbscs.c if ((*f1)(*p, client_data)) return(1);
p 476 gc/cord/cordbscs.c p++;
p 521 gc/cord/cordbscs.c register const char *p = x + i;
p 525 gc/cord/cordbscs.c c = *p;
p 528 gc/cord/cordbscs.c if (p == x) break;
p 529 gc/cord/cordbscs.c p--;
p 732 gc/cord/cordbscs.c register struct CORD_pe * current_pe = &(p[0].path[p[0].path_len]);
p 734 gc/cord/cordbscs.c register size_t pos = p[0].cur_pos;
p 755 gc/cord/cordbscs.c p[0].path_len++;
p 759 gc/cord/cordbscs.c p[0].cur_leaf = top;
p 760 gc/cord/cordbscs.c p[0].cur_start = top_pos;
p 761 gc/cord/cordbscs.c p[0].cur_end = top_pos + top_len;
p 763 gc/cord/cordbscs.c p[0].cur_end = 0;
p 765 gc/cord/cordbscs.c if (pos >= top_pos + top_len) p[0].path_len = CORD_POS_INVALID;
p 771 gc/cord/cordbscs.c struct CORD_pe * pe = &((p)[0].path[(p)[0].path_len]);
p 776 gc/cord/cordbscs.c return ((*(f -> fn))(p[0].cur_pos - pe -> pe_start_pos, f -> client_data));
p 781 gc/cord/cordbscs.c register size_t cur_pos = p[0].cur_pos + 1;
p 782 gc/cord/cordbscs.c register struct CORD_pe * current_pe = &((p)[0].path[(p)[0].path_len]);
p 786 gc/cord/cordbscs.c p[0].cur_pos = cur_pos;
p 804 gc/cord/cordbscs.c p[0].function_buf[i - cur_pos] =
p 807 gc/cord/cordbscs.c p[0].cur_start = cur_pos;
p 808 gc/cord/cordbscs.c p[0].cur_leaf = p[0].function_buf;
p 809 gc/cord/cordbscs.c p[0].cur_end = limit;
p 817 gc/cord/cordbscs.c while (p[0].path_len > 0
p 819 gc/cord/cordbscs.c p[0].path_len--;
p 822 gc/cord/cordbscs.c if (p[0].path_len == 0) {
p 823 gc/cord/cordbscs.c p[0].path_len = CORD_POS_INVALID;
p 827 gc/cord/cordbscs.c p[0].path_len--;
p 828 gc/cord/cordbscs.c CORD__extend_path(p);
p 833 gc/cord/cordbscs.c register struct CORD_pe * pe = &(p[0].path[p[0].path_len]);
p 835 gc/cord/cordbscs.c if (p[0].cur_pos == 0) {
p 836 gc/cord/cordbscs.c p[0].path_len = CORD_POS_INVALID;
p 839 gc/cord/cordbscs.c p[0].cur_pos--;
p 840 gc/cord/cordbscs.c if (p[0].cur_pos >= pe -> pe_start_pos) return;
p 847 gc/cord/cordbscs.c register struct CORD_pe * current_pe = &((p)[0].path[(p)[0].path_len]);
p 849 gc/cord/cordbscs.c while (p[0].path_len > 0
p 851 gc/cord/cordbscs.c p[0].path_len--;
p 855 gc/cord/cordbscs.c p[0].path_len--;
p 856 gc/cord/cordbscs.c CORD__extend_path(p);
p 868 gc/cord/cordbscs.c if (p[0].cur_start <= p[0].cur_pos && p[0].cur_pos < p[0].cur_end) {
p 869 gc/cord/cordbscs.c return(p[0].cur_leaf[p[0].cur_pos - p[0].cur_start]);
p 871 gc/cord/cordbscs.c return(CORD__pos_fetch(p));
p 877 gc/cord/cordbscs.c if (p[0].cur_pos < p[0].cur_end - 1) {
p 878 gc/cord/cordbscs.c p[0].cur_pos++;
p 880 gc/cord/cordbscs.c CORD__next(p);
p 886 gc/cord/cordbscs.c if (p[0].cur_end != 0 && p[0].cur_pos > p[0].cur_start) {
p 887 gc/cord/cordbscs.c p[0].cur_pos--;
p 889 gc/cord/cordbscs.c CORD__prev(p);
p 895 gc/cord/cordbscs.c return(p[0].cur_pos);
p 900 gc/cord/cordbscs.c return(p[0].path[0].pe_cord);
p 905 gc/cord/cordbscs.c return(p[0].path_len != CORD_POS_INVALID);
p 911 gc/cord/cordbscs.c p[0].path_len = CORD_POS_INVALID;
p 914 gc/cord/cordbscs.c p[0].path[0].pe_cord = x;
p 915 gc/cord/cordbscs.c p[0].path[0].pe_start_pos = 0;
p 916 gc/cord/cordbscs.c p[0].path_len = 0;
p 917 gc/cord/cordbscs.c p[0].cur_pos = i;
p 918 gc/cord/cordbscs.c CORD__extend_path(p);
p 57 gc/cord/cordtest.c CORD_pos p;
p 76 gc/cord/cordtest.c CORD_set_pos(p, x, 64*1024-1);
p 77 gc/cord/cordtest.c while(CORD_pos_valid(p)) {
p 78 gc/cord/cordtest.c (void) test_fn(CORD_pos_fetch(p), (void *)13);
p 79 gc/cord/cordtest.c CORD_next(p);
p 109 gc/cord/cordtest.c CORD_set_pos(p, y, i);
p 110 gc/cord/cordtest.c while(CORD_pos_valid(p)) {
p 111 gc/cord/cordtest.c c = CORD_pos_fetch(p);
p 113 gc/cord/cordtest.c CORD_next(p); i++;
p 211 gc/cord/de.c CORD_pos p;
p 227 gc/cord/de.c CORD_FOR (p, s) {
p 228 gc/cord/de.c c = CORD_pos_fetch(p) & 0x7f;
p 87 gc/cord/de_win.c char *p = command_line;
p 89 gc/cord/de_win.c while (*p != 0 && !isspace(*p)) p++;
p 91 gc/cord/de_win.c CORD_substr(command_line, 0, p - command_line));
p 73 gc/darwin_stop_world.c GC_thread p;
p 83 gc/darwin_stop_world.c for(p=GC_threads[i];p!=0;p=p->next) {
p 84 gc/darwin_stop_world.c if(p -> flags & FINISHED) continue;
p 85 gc/darwin_stop_world.c if(pthread_equal(p->id,me)) {
p 90 gc/darwin_stop_world.c p->stop_info.mach_thread,
p 130 gc/darwin_stop_world.c if(p->flags & MAIN_THREAD)
p 133 gc/darwin_stop_world.c hi = p->stack_end;
p 136 gc/darwin_stop_world.c (unsigned long) p -> id,
p 351 gc/darwin_stop_world.c GC_thread p;
p 417 gc/darwin_stop_world.c GC_thread p;
p 38 gc/dbg_mlc.c register oh * ohdr = (oh *)p;
p 176 gc/dbg_mlc.c void *current = p;
p 237 gc/dbg_mlc.c (((word)(p + sizeof(oh) + sz - 1) ^ (word)p) >= HBLKSIZE)
p 246 gc/dbg_mlc.c register word * result = (word *)((oh *)p + 1);
p 253 gc/dbg_mlc.c GC_ASSERT(GC_size(p) >= sizeof(oh) + sz);
p 254 gc/dbg_mlc.c GC_ASSERT(!(SMALL_OBJ(sz) && CROSSES_HBLK(p, sz)));
p 256 gc/dbg_mlc.c ((oh *)p) -> oh_back_ptr = HIDE_BACK_PTR(NOT_MARKED);
p 259 gc/dbg_mlc.c ((oh *)p) -> oh_bg_ptr = HIDE_BACK_PTR((ptr_t)0);
p 261 gc/dbg_mlc.c ((oh *)p) -> oh_string = string;
p 262 gc/dbg_mlc.c ((oh *)p) -> oh_int = integer;
p 264 gc/dbg_mlc.c ((oh *)p) -> oh_sz = sz;
p 265 gc/dbg_mlc.c ((oh *)p) -> oh_sf = START_FLAG ^ (word)result;
p 266 gc/dbg_mlc.c ((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] =
p 282 gc/dbg_mlc.c register word * result = (word *)((oh *)p + 1);
p 287 gc/dbg_mlc.c GC_ASSERT(GC_size(p) >= sizeof(oh) + sz);
p 288 gc/dbg_mlc.c GC_ASSERT(!(SMALL_OBJ(sz) && CROSSES_HBLK(p, sz)));
p 290 gc/dbg_mlc.c ((oh *)p) -> oh_back_ptr = HIDE_BACK_PTR(NOT_MARKED);
p 293 gc/dbg_mlc.c ((oh *)p) -> oh_bg_ptr = HIDE_BACK_PTR((ptr_t)0);
p 295 gc/dbg_mlc.c ((oh *)p) -> oh_string = string;
p 296 gc/dbg_mlc.c ((oh *)p) -> oh_int = integer;
p 298 gc/dbg_mlc.c ((oh *)p) -> oh_sz = sz;
p 299 gc/dbg_mlc.c ((oh *)p) -> oh_sf = START_FLAG ^ (word)result;
p 300 gc/dbg_mlc.c ((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] =
p 347 gc/dbg_mlc.c hdr * hhdr = GC_find_header(p);
p 351 gc/dbg_mlc.c if (0 != GC_describe_type_fns[kind] && GC_is_marked(GC_base(p))) {
p 355 gc/dbg_mlc.c (GC_describe_type_fns[kind])(p, buffer);
p 388 gc/dbg_mlc.c register oh * ohdr = (oh *)GC_base(p);
p 412 gc/dbg_mlc.c if (GC_HAS_DEBUG_INFO(p)) {
p 413 gc/dbg_mlc.c GC_print_obj(p);
p 415 gc/dbg_mlc.c GC_default_print_heap_obj_proc(p);
p 423 gc/dbg_mlc.c register oh * ohdr = (oh *)GC_base(p);
p 427 gc/dbg_mlc.c (unsigned long)p);
p 628 gc/dbg_mlc.c register GC_PTR q = GC_base(p);
p 633 gc/dbg_mlc.c (unsigned long) p);
p 639 gc/dbg_mlc.c (unsigned long) p);
p 648 gc/dbg_mlc.c register GC_PTR q = GC_base(p);
p 653 gc/dbg_mlc.c (unsigned long) p);
p 659 gc/dbg_mlc.c (unsigned long) p);
p 780 gc/dbg_mlc.c if (0 == p) return;
p 781 gc/dbg_mlc.c base = GC_base(p);
p 784 gc/dbg_mlc.c (unsigned long)p);
p 787 gc/dbg_mlc.c if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
p 790 gc/dbg_mlc.c (unsigned long)p);
p 801 gc/dbg_mlc.c GC_print_smashed_obj(p, clobbered);
p 810 gc/dbg_mlc.c register hdr * hhdr = HDR(p);
p 827 gc/dbg_mlc.c for (i = 0; i < obj_sz; ++i) ((word *)p)[i] = 0xdeadbeef;
p 828 gc/dbg_mlc.c GC_ASSERT((word *)p + i == (word *)base + hhdr -> hb_sz);
p 840 gc/dbg_mlc.c GC_free_inner(GC_base(p));
p 854 gc/dbg_mlc.c register GC_PTR base = GC_base(p);
p 861 gc/dbg_mlc.c if (p == 0) return(GC_debug_malloc(lb, OPT_RA s, i));
p 864 gc/dbg_mlc.c "Attempt to reallocate invalid pointer %lx\n", (unsigned long)p);
p 867 gc/dbg_mlc.c if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
p 870 gc/dbg_mlc.c (unsigned long)p);
p 871 gc/dbg_mlc.c return(GC_realloc(p, lb));
p 904 gc/dbg_mlc.c GC_print_smashed_obj(p, clobbered);
p 910 gc/dbg_mlc.c BCOPY(p, result, copy_sz);
p 911 gc/dbg_mlc.c GC_debug_free(p);
p 968 gc/dbg_mlc.c register word *p, *plim;
p 970 gc/dbg_mlc.c p = (word *)(hbp->hb_body);
p 973 gc/dbg_mlc.c plim = p;
p 978 gc/dbg_mlc.c while( p <= plim ) {
p 980 gc/dbg_mlc.c && GC_HAS_DEBUG_INFO((ptr_t)p)) {
p 981 gc/dbg_mlc.c ptr_t clobbered = GC_check_annotated_obj((oh *)p);
p 986 gc/dbg_mlc.c p += sz;
p 1184 gc/dbg_mlc.c return GC_debug_realloc(p, lb, RA "unknown", 0);
p 243 gc/dyn_load.c ElfW(Phdr) * p;
p 249 gc/dyn_load.c p = ((ElfW(Phdr) *)(((char *)(e)) + e->e_phoff));
p 251 gc/dyn_load.c for( i = 0; i < (int)(e->e_phnum); ((i++),(p++)) ) {
p 252 gc/dyn_load.c switch( p->p_type ) {
p 255 gc/dyn_load.c if( !(p->p_flags & PF_W) ) break;
p 256 gc/dyn_load.c start = ((char *)(p->p_vaddr)) + offset;
p 259 gc/dyn_load.c start + p->p_memsz,
p 398 gc/dyn_load.c const ElfW(Phdr) * p;
p 407 gc/dyn_load.c p = info->dlpi_phdr;
p 408 gc/dyn_load.c for( i = 0; i < (int)(info->dlpi_phnum); ((i++),(p++)) ) {
p 409 gc/dyn_load.c switch( p->p_type ) {
p 412 gc/dyn_load.c if( !(p->p_flags & PF_W) ) break;
p 413 gc/dyn_load.c start = ((char *)(p->p_vaddr)) + info->dlpi_addr;
p 414 gc/dyn_load.c GC_add_roots_inner(start, start + p->p_memsz, TRUE);
p 537 gc/dyn_load.c ElfW(Phdr) * p;
p 543 gc/dyn_load.c p = ((ElfW(Phdr) *)(((char *)(e)) + e->e_phoff));
p 545 gc/dyn_load.c for( i = 0; i < (int)(e->e_phnum); ((i++),(p++)) ) {
p 546 gc/dyn_load.c switch( p->p_type ) {
p 549 gc/dyn_load.c if( !(p->p_flags & PF_W) ) break;
p 550 gc/dyn_load.c start = ((char *)(p->p_vaddr)) + offset;
p 551 gc/dyn_load.c GC_add_roots_inner(start, start + p->p_memsz, TRUE);
p 852 gc/dyn_load.c LPVOID p;
p 859 gc/dyn_load.c base = limit = p = GC_sysinfo.lpMinimumApplicationAddress;
p 862 gc/dyn_load.c while (p < (LPVOID)0x02000000) {
p 863 gc/dyn_load.c result = VirtualQuery(p, &buf, sizeof(buf));
p 867 gc/dyn_load.c (((DWORD) p + GC_sysinfo.dwAllocationGranularity)
p 871 gc/dyn_load.c while (p < GC_sysinfo.lpMaximumApplicationAddress) {
p 872 gc/dyn_load.c result = VirtualQuery(p, &buf, sizeof(buf));
p 878 gc/dyn_load.c new_limit = (char *)p + buf.RegionSize;
p 892 gc/dyn_load.c if ((char *)p != limit) {
p 894 gc/dyn_load.c base = p;
p 899 gc/dyn_load.c if (p > (LPVOID)new_limit /* overflow */) break;
p 900 gc/dyn_load.c p = (LPVOID)new_limit;
p 1254 gc/dyn_load.c PCR_IL_LoadedFile * p = PCR_IL_GetLastLoadedFile();
p 1258 gc/dyn_load.c while (p != NIL && !(p -> lf_commitPoint)) {
p 1264 gc/dyn_load.c p = p -> lf_prev;
p 1266 gc/dyn_load.c for (; p != NIL; p = p -> lf_prev) {
p 1267 gc/dyn_load.c for (q = p -> lf_ls; q != NIL; q = q -> ls_next) {
p 106 gc/finalize.c register struct hash_chain_entry *p;
p 123 gc/finalize.c p = (*table)[i];
p 124 gc/finalize.c while (p != 0) {
p 125 gc/finalize.c register ptr_t real_key = (ptr_t)REVEAL_POINTER(p -> hidden_key);
p 126 gc/finalize.c register struct hash_chain_entry *next = p -> next;
p 129 gc/finalize.c p -> next = new_table[new_hash];
p 130 gc/finalize.c new_table[new_hash] = p;
p 131 gc/finalize.c p = next;
p 281 gc/finalize.c hdr * hhdr = HDR(p);
p 283 gc/finalize.c PUSH_OBJ((word *)p, hhdr, GC_mark_stack_top,
p 293 gc/finalize.c hdr * hhdr = HDR(p);
p 297 gc/finalize.c ptr_t target_limit = p + WORDS_TO_BYTES(hhdr -> hb_sz) - 1;
p 300 gc/finalize.c scan_limit = p + descr - sizeof(word);
p 304 gc/finalize.c for (q = p; q <= scan_limit; q += ALIGNMENT) {
p 306 gc/finalize.c if (r < p || r > target_limit) {
p 157 gc/headers.c bottom_index * p;
p 165 gc/headers.c old = p = GC_top_index[i];
p 166 gc/headers.c while(p != GC_all_nils) {
p 167 gc/headers.c if (p -> key == hi) return(TRUE);
p 168 gc/headers.c p = p -> hash_link;
p 186 gc/headers.c while ((p = *prev) != 0 && p -> key < hi) {
p 187 gc/headers.c pi = p;
p 188 gc/headers.c prev = &(p -> asc_link);
p 191 gc/headers.c if (0 == p) {
p 194 gc/headers.c p -> desc_link = r;
p 196 gc/headers.c r -> asc_link = p;
p 567 gc/include/gc.h # define GC_FREE(p) GC_debug_free(p)
p 569 gc/include/gc.h GC_debug_register_finalizer(p, f, d, of, od)
p 571 gc/include/gc.h GC_debug_register_finalizer_ignore_self(p, f, d, of, od)
p 573 gc/include/gc.h GC_debug_register_finalizer_no_order(p, f, d, of, od)
p 575 gc/include/gc.h # define GC_CHANGE_STUBBORN(p) GC_debug_change_stubborn(p)
p 576 gc/include/gc.h # define GC_END_STUBBORN_CHANGE(p) GC_debug_end_stubborn_change(p)
p 589 gc/include/gc.h # define GC_FREE(p) GC_free(p)
p 591 gc/include/gc.h GC_register_finalizer(p, f, d, of, od)
p 593 gc/include/gc.h GC_register_finalizer_ignore_self(p, f, d, of, od)
p 595 gc/include/gc.h GC_register_finalizer_no_order(p, f, d, of, od)
p 597 gc/include/gc.h # define GC_CHANGE_STUBBORN(p) GC_change_stubborn(p)
p 598 gc/include/gc.h # define GC_END_STUBBORN_CHANGE(p) GC_end_stubborn_change(p)
p 754 gc/include/gc.h GC_API GC_warn_proc GC_set_warn_proc GC_PROTO((GC_warn_proc p));
p 771 gc/include/gc.h # define HIDE_POINTER(p) (~(GC_hidden_pointer)(p))
p 772 gc/include/gc.h # define REVEAL_POINTER(p) ((GC_PTR)(HIDE_POINTER(p)))
p 791 gc/include/gc.h GC_API GC_PTR GC_same_obj GC_PROTO((GC_PTR p, GC_PTR q));
p 797 gc/include/gc.h GC_API GC_PTR GC_pre_incr GC_PROTO((GC_PTR *p, size_t how_much));
p 798 gc/include/gc.h GC_API GC_PTR GC_post_incr GC_PROTO((GC_PTR *p, size_t how_much));
p 808 gc/include/gc.h GC_API GC_PTR GC_is_visible GC_PROTO((GC_PTR p));
p 815 gc/include/gc.h GC_API GC_PTR GC_is_valid_displacement GC_PROTO((GC_PTR p));
p 853 gc/include/gc.h (*(void **)GC_is_visible(p) = GC_is_valid_displacement(q))
p 856 gc/include/gc.h (*(char **)GC_is_visible(p) = GC_is_valid_displacement(q))
p 859 gc/include/gc.h # define GC_PTR_STORE(p, q) *((p) = (q))
p 863 gc/include/gc.h GC_API void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR p, GC_PTR q));
p 866 gc/include/gc.h GC_PROTO((GC_PTR p));
p 869 gc/include/gc.h GC_PROTO((GC_PTR p));
p 890 gc/include/gc.h #define GC_NEXT(p) (*(GC_PTR *)(p)) /* Retrieve the next element */
p 58 gc/include/gc_alloc.h static void deallocate(T *p, size_t n)
p 59 gc/include/gc_alloc.h { if (0 != n) alloc::deallocate(p, n * sizeof (T)); }
p 60 gc/include/gc_alloc.h static void deallocate(T *p)
p 61 gc/include/gc_alloc.h { alloc::deallocate(p, sizeof (T)); }
p 97 gc/include/gc_alloc.h { return *(void **)p; }
p 206 gc/include/gc_alloc.h static void deallocate(void *p, size_t n)
p 212 gc/include/gc_alloc.h GC_free(p);
p 215 gc/include/gc_alloc.h GC_obj_link(p) = *flh;
p 216 gc/include/gc_alloc.h memset((char *)p + GC_bytes_per_word, 0,
p 218 gc/include/gc_alloc.h *flh = p;
p 222 gc/include/gc_alloc.h static void ptr_free_deallocate(void *p, size_t n)
p 228 gc/include/gc_alloc.h GC_free(p);
p 231 gc/include/gc_alloc.h GC_obj_link(p) = *flh;
p 232 gc/include/gc_alloc.h *flh = p;
p 274 gc/include/gc_alloc.h static void deallocate(void *p, size_t n)
p 280 gc/include/gc_alloc.h GC_free(p);
p 283 gc/include/gc_alloc.h GC_obj_link(p) = *flh;
p 284 gc/include/gc_alloc.h *flh = p;
p 288 gc/include/gc_alloc.h static void ptr_free_deallocate(void *p, size_t n)
p 294 gc/include/gc_alloc.h GC_free(p);
p 297 gc/include/gc_alloc.h GC_obj_link(p) = *flh;
p 298 gc/include/gc_alloc.h *flh = p;
p 324 gc/include/gc_alloc.h static void deallocate(void *p, size_t) { GC_free(p); }
p 325 gc/include/gc_alloc.h static void ptr_free_deallocate(void *p, size_t) { GC_free(p); }
p 345 gc/include/gc_alloc.h static void deallocate(T *p, size_t n) \
p 346 gc/include/gc_alloc.h { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
p 347 gc/include/gc_alloc.h static void deallocate(T *p) \
p 348 gc/include/gc_alloc.h { alloc::ptr_free_deallocate(p, sizeof (T)); } \
p 169 gc/include/gc_cpp.h inline void* operator new( size_t size, void *p );
p 180 gc/include/gc_cpp.h inline void* operator new[]( size_t size, void *p );
p 285 gc/include/gc_cpp.h return p;}
p 302 gc/include/gc_cpp.h inline void* gc::operator new[]( size_t size, void *p ) {
p 303 gc/include/gc_cpp.h return p;}
p 149 gc/include/gc_mark.h #define GC_USR_PTR_FROM_BASE(p) ((GC_PTR)((char *)(p) + GC_debug_header_size))
p 5 gc/include/leak_detector.h #define free(p) GC_FREE(p)
p 6 gc/include/leak_detector.h #define realloc(p,n) GC_REALLOC((p),(n))
p 112 gc/include/new_gc_alloc.h { return *reinterpret_cast<void **>(p); }
p 221 gc/include/new_gc_alloc.h static void deallocate(void *p, size_t n)
p 227 gc/include/new_gc_alloc.h GC_free(p);
p 230 gc/include/new_gc_alloc.h GC_obj_link(p) = *flh;
p 231 gc/include/new_gc_alloc.h memset(reinterpret_cast<char *>(p) + GC_bytes_per_word, 0,
p 233 gc/include/new_gc_alloc.h *flh = p;
p 237 gc/include/new_gc_alloc.h static void ptr_free_deallocate(void *p, size_t n)
p 243 gc/include/new_gc_alloc.h GC_free(p);
p 246 gc/include/new_gc_alloc.h GC_obj_link(p) = *flh;
p 247 gc/include/new_gc_alloc.h *flh = p;
p 289 gc/include/new_gc_alloc.h static void deallocate(void *p, size_t n)
p 295 gc/include/new_gc_alloc.h GC_free(p);
p 298 gc/include/new_gc_alloc.h GC_obj_link(p) = *flh;
p 299 gc/include/new_gc_alloc.h *flh = p;
p 303 gc/include/new_gc_alloc.h static void ptr_free_deallocate(void *p, size_t n)
p 309 gc/include/new_gc_alloc.h GC_free(p);
p 312 gc/include/new_gc_alloc.h GC_obj_link(p) = *flh;
p 313 gc/include/new_gc_alloc.h *flh = p;
p 339 gc/include/new_gc_alloc.h static void deallocate(void *p, size_t) { GC_free(p); }
p 340 gc/include/new_gc_alloc.h static void ptr_free_deallocate(void *p, size_t) { GC_free(p); }
p 358 gc/include/new_gc_alloc.h static void deallocate(T *p, size_t n) \
p 359 gc/include/new_gc_alloc.h { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
p 360 gc/include/new_gc_alloc.h static void deallocate(T *p) \
p 361 gc/include/new_gc_alloc.h { alloc::ptr_free_deallocate(p, sizeof (T)); } \
p 86 gc/include/private/cord_pos.h (((p)[0].cur_end != 0)? \
p 87 gc/include/private/cord_pos.h (p)[0].cur_leaf[(p)[0].cur_pos - (p)[0].cur_start] \
p 88 gc/include/private/cord_pos.h : CORD__pos_fetch(p))
p 91 gc/include/private/cord_pos.h (((p)[0].cur_pos + 1 < (p)[0].cur_end)? \
p 92 gc/include/private/cord_pos.h (p)[0].cur_pos++ \
p 93 gc/include/private/cord_pos.h : (CORD__next(p), 0))
p 96 gc/include/private/cord_pos.h (((p)[0].cur_end != 0 && (p)[0].cur_pos > (p)[0].cur_start)? \
p 97 gc/include/private/cord_pos.h (p)[0].cur_pos-- \
p 98 gc/include/private/cord_pos.h : (CORD__prev(p), 0))
p 100 gc/include/private/cord_pos.h #define CORD_pos_to_index(p) ((p)[0].cur_pos)
p 102 gc/include/private/cord_pos.h #define CORD_pos_to_cord(p) ((p)[0].path[0].pe_cord)
p 104 gc/include/private/cord_pos.h #define CORD_pos_valid(p) ((p)[0].path_len != CORD_POS_INVALID)
p 107 gc/include/private/cord_pos.h #define CORD_pos_chars_left(p) ((long)((p)[0].cur_end) - (long)((p)[0].cur_pos))
p 110 gc/include/private/cord_pos.h #define CORD_pos_advance(p,n) ((p)[0].cur_pos += (n) - 1, CORD_next(p))
p 115 gc/include/private/cord_pos.h (p)[0].cur_leaf + ((p)[0].cur_pos - (p)[0].cur_start)
p 40 gc/include/private/dbg_mlc.h # define HIDE_POINTER(p) (~(GC_hidden_pointer)(p))
p 41 gc/include/private/dbg_mlc.h # define REVEAL_POINTER(p) ((GC_PTR)(HIDE_POINTER(p)))
p 87 gc/include/private/dbg_mlc.h # define HIDE_BACK_PTR(p) HIDE_POINTER(~1 & (GC_word)(p))
p 89 gc/include/private/dbg_mlc.h # define HIDE_BACK_PTR(p) HIDE_POINTER(p)
p 166 gc/include/private/dbg_mlc.h ((*((word *)p) & 1) && GC_has_other_debug_info(p))
p 168 gc/include/private/dbg_mlc.h # define GC_HAS_DEBUG_INFO(p) GC_has_other_debug_info(p)
p 73 gc/include/private/gc_hdrs.h p = GC_find_start(p, hhdr, &new_hdr); \
p 115 gc/include/private/gc_hdrs.h hdr_cache_entry * hce = HCE(p); \
p 116 gc/include/private/gc_hdrs.h if (HCE_VALID_FOR(hce, p)) { \
p 121 gc/include/private/gc_hdrs.h GET_HDR(p, hhdr); \
p 123 gc/include/private/gc_hdrs.h ADVANCE(p, hhdr, source); \
p 125 gc/include/private/gc_hdrs.h hce -> block_addr = (word)(p) >> LOG_HBLKSIZE; \
p 139 gc/include/private/gc_hdrs.h GET_HDR(p, hhdr); \
p 141 gc/include/private/gc_hdrs.h ADVANCE(p, hhdr, source); \
p 184 gc/include/private/gc_hdrs.h ((bi)->index[((word)(p) >> LOG_HBLKSIZE) & (BOTTOM_SZ - 1)])
p 187 gc/include/private/gc_hdrs.h [(word)(p) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE)])
p 188 gc/include/private/gc_hdrs.h # define HDR_INNER(p) HDR_FROM_BI(BI(p),p)
p 190 gc/include/private/gc_hdrs.h # define HDR(p) GC_find_header((ptr_t)(p))
p 192 gc/include/private/gc_hdrs.h # define HDR(p) HDR_INNER(p)
p 194 gc/include/private/gc_hdrs.h # define GET_BI(p, bottom_indx) (bottom_indx) = BI(p)
p 195 gc/include/private/gc_hdrs.h # define GET_HDR(p, hhdr) (hhdr) = HDR(p)
p 196 gc/include/private/gc_hdrs.h # define SET_HDR(p, hhdr) HDR_INNER(p) = (hhdr)
p 197 gc/include/private/gc_hdrs.h # define GET_HDR_ADDR(p, ha) (ha) = &(HDR_INNER(p))
p 205 gc/include/private/gc_hdrs.h (word)(p) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE); \
p 216 gc/include/private/gc_hdrs.h GET_BI(p, bi); \
p 217 gc/include/private/gc_hdrs.h (ha) = &(HDR_FROM_BI(bi, p)); \
p 219 gc/include/private/gc_hdrs.h # define GET_HDR(p, hhdr) { register hdr ** _ha; GET_HDR_ADDR(p, _ha); \
p 221 gc/include/private/gc_hdrs.h # define SET_HDR(p, hhdr) { register hdr ** _ha; GET_HDR_ADDR(p, _ha); \
p 223 gc/include/private/gc_hdrs.h # define HDR(p) GC_find_header((ptr_t)(p))
p 271 gc/include/private/gc_pmark.h GC_mark_and_push_stack(p, (ptr_t)(source))
p 274 gc/include/private/gc_pmark.h GC_mark_and_push_stack(p)
p 288 gc/include/private/gc_pmark.h if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \
p 289 gc/include/private/gc_pmark.h && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
p 290 gc/include/private/gc_pmark.h PUSH_ONE_CHECKED_STACK(p, source); \
p 292 gc/include/private/gc_pmark.h FIXUP_POINTER(p); \
p 293 gc/include/private/gc_pmark.h if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \
p 294 gc/include/private/gc_pmark.h && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
p 295 gc/include/private/gc_pmark.h PUSH_ONE_CHECKED_STACK(p, source); \
p 299 gc/include/private/gc_pmark.h if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \
p 300 gc/include/private/gc_pmark.h && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
p 301 gc/include/private/gc_pmark.h PUSH_ONE_CHECKED_STACK(p, source); \
p 311 gc/include/private/gc_pmark.h FIXUP_POINTER(p); \
p 312 gc/include/private/gc_pmark.h if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \
p 313 gc/include/private/gc_pmark.h && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
p 315 gc/include/private/gc_pmark.h (GC_PTR)(p), GC_mark_stack_top, \
p 558 gc/include/private/gc_priv.h # define HBLK_PTR_DIFF(p,q) divHBLKSZ((ptr_t)p - (ptr_t)q)
p 747 gc/include/private/gc_priv.h # define obj_link(p) (*(ptr_t *)(p))
p 2190 gc/include/private/gcconfig.h # define FIXUP_POINTER(p) (p) = ((p) & (POINTER_MASK) << POINTER_SHIFT)
p 401 gc/malloc.c if (p == 0) return;
p 403 gc/malloc.c h = HBLKPTR(p);
p 405 gc/malloc.c GC_ASSERT(GC_base(p) == p);
p 431 gc/malloc.c BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
p 434 gc/malloc.c obj_link(p) = *flh;
p 435 gc/malloc.c *flh = (ptr_t)p;
p 465 gc/malloc.c h = HBLKPTR(p);
p 474 gc/malloc.c BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
p 477 gc/malloc.c obj_link(p) = *flh;
p 478 gc/malloc.c *flh = (ptr_t)p;
p 499 gc/malloc.c REDIRECT_FREE(p);
p 85 gc/mallocx.c if (p == 0) return(GC_malloc(lb)); /* Required by ANSI */
p 86 gc/mallocx.c h = HBLKPTR(p);
p 108 gc/mallocx.c if (obj_kind == STUBBORN) GC_change_stubborn(p);
p 114 gc/mallocx.c BZERO(((ptr_t)p) + lb, orig_sz - lb);
p 116 gc/mallocx.c return(p);
p 125 gc/mallocx.c BCOPY(p, result, lb);
p 127 gc/mallocx.c GC_free(p);
p 137 gc/mallocx.c BCOPY(p, result, sz);
p 139 gc/mallocx.c GC_free(p);
p 158 gc/mallocx.c GC_debug_realloc(p, lb, RA "unknown", 0)
p 168 gc/mallocx.c return(REDIRECT_REALLOC(p, lb));
p 352 gc/mallocx.c ptr_t p;
p 423 gc/mallocx.c for (p = op; p != 0; p = obj_link(p)) {
p 470 gc/mallocx.c for (p = op; p != 0; p = obj_link(p)) {
p 473 gc/mallocx.c *opp = obj_link(p);
p 474 gc/mallocx.c obj_link(p) = 0;
p 185 gc/mark.c register struct hblk *h = HBLKPTR(p);
p 187 gc/mark.c register int word_no = (word *)p - (word *)h;
p 195 gc/mark.c register struct hblk *h = HBLKPTR(p);
p 197 gc/mark.c register int word_no = (word *)p - (word *)h;
p 205 gc/mark.c register struct hblk *h = HBLKPTR(p);
p 207 gc/mark.c register int word_no = (word *)p - (word *)h;
p 833 gc/mark.c mse *p;
p 844 gc/mark.c for (p = low; p <= high && i <= max; ++p) {
p 845 gc/mark.c word descr = *(volatile word *) &(p -> mse_descr);
p 855 gc/mark.c *(volatile word *) &(p -> mse_descr) = 0;
p 860 gc/mark.c top -> mse_start = p -> mse_start;
p 870 gc/mark.c *next = p;
p 941 gc/mark.c mse * p;
p 1312 gc/mark.c GC_PUSH_ONE_STACK(p, MARKED_FROM_REGISTER);
p 1328 gc/mark.c # define BASE(p) (word)GC_base((void *)(p))
p 1330 gc/mark.c # define BASE(p) (word)GC_base((char *)(p))
p 1353 gc/mark.c GET_HDR(p, hhdr);
p 1356 gc/mark.c r = BASE(p);
p 1363 gc/mark.c displ = HBLKDISPL(p);
p 1367 gc/mark.c r = BASE(p);
p 1377 gc/mark.c r = (word)((word *)(HBLKPTR(p)) + displ);
p 1384 gc/mark.c GC_add_to_black_list_stack(p, source);
p 1386 gc/mark.c GC_add_to_black_list_stack(p);
p 1427 gc/mark.c struct trace_entry *p;
p 1432 gc/mark.c p = GC_trace_buf + i;
p 1433 gc/mark.c if (p -> gc_no < gc_no || p -> kind == 0) return;
p 1435 gc/mark.c p -> kind, p -> gc_no, p -> words_allocd,
p 1436 gc/mark.c (p -> arg1) ^ 0x80000000, (p -> arg2) ^ 0x80000000);
p 1455 gc/mark.c register word *p;
p 1467 gc/mark.c for (p = b; p <= lim; p = (word *)(((char *)p) + ALIGNMENT)) {
p 1468 gc/mark.c q = *p;
p 1469 gc/mark.c GC_PUSH_ONE_STACK(q, p);
p 1533 gc/mark.c register word *p;
p 1547 gc/mark.c p = (word *)(h->hb_body);
p 1551 gc/mark.c while( p < plim ) {
p 1556 gc/mark.c q = p[i];
p 1557 gc/mark.c GC_PUSH_ONE_HEAP(q, p + i);
p 1562 gc/mark.c p += WORDSZ;
p 1581 gc/mark.c register word *p;
p 1595 gc/mark.c p = (word *)(h->hb_body);
p 1599 gc/mark.c while( p < plim ) {
p 1604 gc/mark.c q = p[i];
p 1605 gc/mark.c GC_PUSH_ONE_HEAP(q, p + i);
p 1606 gc/mark.c q = p[i+1];
p 1607 gc/mark.c GC_PUSH_ONE_HEAP(q, p + i);
p 1612 gc/mark.c p += WORDSZ;
p 1630 gc/mark.c register word *p;
p 1644 gc/mark.c p = (word *)(h->hb_body);
p 1648 gc/mark.c while( p < plim ) {
p 1653 gc/mark.c q = p[i];
p 1654 gc/mark.c GC_PUSH_ONE_HEAP(q, p + i);
p 1655 gc/mark.c q = p[i+1];
p 1656 gc/mark.c GC_PUSH_ONE_HEAP(q, p + i + 1);
p 1657 gc/mark.c q = p[i+2];
p 1658 gc/mark.c GC_PUSH_ONE_HEAP(q, p + i + 2);
p 1659 gc/mark.c q = p[i+3];
p 1660 gc/mark.c GC_PUSH_ONE_HEAP(q, p + i + 3);
p 1665 gc/mark.c p += WORDSZ;
p 1685 gc/mark.c register word * p;
p 1719 gc/mark.c for (p = (word *)h, word_no = 0; p <= lim; p += sz, word_no += sz) {
p 1722 gc/mark.c PUSH_OBJ((word *)p, hhdr, GC_mark_stack_top_reg, mark_stack_limit);
p 1745 gc/mark.c register ptr_t p = (ptr_t)h;
p 1747 gc/mark.c while (p < (ptr_t)h + sz) {
p 1748 gc/mark.c if (GC_page_was_dirty((struct hblk *)p)) return(TRUE);
p 1749 gc/mark.c p += HBLKSIZE;
p 78 gc/mark_rts.c && p >= GC_static_roots[last_root_set].r_start
p 79 gc/mark_rts.c && p < GC_static_roots[last_root_set].r_end) return(TRUE);
p 81 gc/mark_rts.c if (p >= GC_static_roots[i].r_start
p 82 gc/mark_rts.c && p < GC_static_roots[i].r_end) {
p 123 gc/mark_rts.c register struct roots *p = GC_root_index[h];
p 125 gc/mark_rts.c while (p != 0) {
p 126 gc/mark_rts.c if (p -> r_start == (ptr_t)b) return(p);
p 127 gc/mark_rts.c p = p -> r_next;
p 136 gc/mark_rts.c register int h = rt_hash(p -> r_start);
p 138 gc/mark_rts.c p -> r_next = GC_root_index[h];
p 139 gc/mark_rts.c GC_root_index[h] = p;
p 355 gc/mark_rts.c && p >= GC_static_roots[last_root_set].r_start
p 356 gc/mark_rts.c && p < GC_static_roots[last_root_set].r_end)
p 359 gc/mark_rts.c if (p >= GC_static_roots[i].r_start
p 360 gc/mark_rts.c && p < GC_static_roots[i].r_end) {
p 395 gc/misc.c r = (word)p;
p 426 gc/misc.c if ((word)p >= limit) return(0);
p 443 gc/misc.c register hdr * hhdr = HDR(p);
p 1038 gc/misc.c GC_current_warn_proc = p;
p 34 gc/new_hblk.c register word * p = h -> hb_body;
p 37 gc/new_hblk.c p[0] = (word)ofl;
p 38 gc/new_hblk.c p[1] = (word)(p);
p 39 gc/new_hblk.c p[2] = (word)(p+1);
p 40 gc/new_hblk.c p[3] = (word)(p+2);
p 41 gc/new_hblk.c p += 4;
p 42 gc/new_hblk.c for (; p < lim; p += 4) {
p 43 gc/new_hblk.c p[0] = (word)(p-1);
p 44 gc/new_hblk.c p[1] = (word)(p);
p 45 gc/new_hblk.c p[2] = (word)(p+1);
p 46 gc/new_hblk.c p[3] = (word)(p+2);
p 48 gc/new_hblk.c return((ptr_t)(p-1));
p 56 gc/new_hblk.c register word * p = h -> hb_body;
p 59 gc/new_hblk.c p[0] = (word)ofl;
p 60 gc/new_hblk.c p[1] = 0;
p 61 gc/new_hblk.c p[2] = (word)p;
p 62 gc/new_hblk.c p[3] = 0;
p 63 gc/new_hblk.c p += 4;
p 64 gc/new_hblk.c for (; p < lim; p += 4) {
p 65 gc/new_hblk.c p[0] = (word)(p-2);
p 66 gc/new_hblk.c p[1] = 0;
p 67 gc/new_hblk.c p[2] = (word)p;
p 68 gc/new_hblk.c p[3] = 0;
p 70 gc/new_hblk.c return((ptr_t)(p-2));
p 78 gc/new_hblk.c register word * p = h -> hb_body;
p 81 gc/new_hblk.c p[0] = (word)ofl;
p 82 gc/new_hblk.c p[1] = 0;
p 83 gc/new_hblk.c p[2] = 0;
p 84 gc/new_hblk.c p += 3;
p 85 gc/new_hblk.c for (; p < lim; p += 3) {
p 86 gc/new_hblk.c p[0] = (word)(p-3);
p 87 gc/new_hblk.c p[1] = 0;
p 88 gc/new_hblk.c p[2] = 0;
p 90 gc/new_hblk.c return((ptr_t)(p-3));
p 98 gc/new_hblk.c register word * p = h -> hb_body;
p 101 gc/new_hblk.c p[0] = (word)ofl;
p 102 gc/new_hblk.c p[1] = 0;
p 103 gc/new_hblk.c p[2] = 0;
p 104 gc/new_hblk.c p[3] = 0;
p 105 gc/new_hblk.c p += 4;
p 106 gc/new_hblk.c for (; p < lim; p += 4) {
p 107 gc/new_hblk.c PREFETCH_FOR_WRITE((ptr_t)(p+64));
p 108 gc/new_hblk.c p[0] = (word)(p-4);
p 109 gc/new_hblk.c p[1] = 0;
p 110 gc/new_hblk.c CLEAR_DOUBLE(p+2);
p 112 gc/new_hblk.c return((ptr_t)(p-4));
p 120 gc/new_hblk.c register word * p = h -> hb_body;
p 123 gc/new_hblk.c p[0] = (word)ofl;
p 124 gc/new_hblk.c p[2] = (word)p;
p 125 gc/new_hblk.c p += 4;
p 126 gc/new_hblk.c for (; p < lim; p += 4) {
p 127 gc/new_hblk.c p[0] = (word)(p-2);
p 128 gc/new_hblk.c p[2] = (word)p;
p 130 gc/new_hblk.c return((ptr_t)(p-2));
p 138 gc/new_hblk.c register word * p = h -> hb_body;
p 141 gc/new_hblk.c p[0] = (word)ofl;
p 142 gc/new_hblk.c p[4] = (word)p;
p 143 gc/new_hblk.c p += 8;
p 144 gc/new_hblk.c for (; p < lim; p += 8) {
p 145 gc/new_hblk.c PREFETCH_FOR_WRITE((ptr_t)(p+64));
p 146 gc/new_hblk.c p[0] = (word)(p-4);
p 147 gc/new_hblk.c p[4] = (word)p;
p 149 gc/new_hblk.c return((ptr_t)(p-4));
p 167 gc/new_hblk.c word *p, *prev;
p 208 gc/new_hblk.c p = &(h -> hb_body[sz]); /* second object in *h */
p 215 gc/new_hblk.c while (p <= last_object) {
p 217 gc/new_hblk.c obj_link(p) = (ptr_t)prev;
p 218 gc/new_hblk.c prev = p;
p 219 gc/new_hblk.c p += sz;
p 221 gc/new_hblk.c p -= sz; /* p now points to last object */
p 228 gc/new_hblk.c return ((ptr_t)p);
p 373 gc/os_dep.c void *p = brk;
p 383 gc/os_dep.c return p;
p 634 gc/os_dep.c result = VirtualQuery(p, &buf, sizeof(buf));
p 805 gc/os_dep.c result = (ptr_t)(((word)(p))
p 1206 gc/os_dep.c ptr_t p;
p 1210 gc/os_dep.c p = (ptr_t)((word)start & ~(GC_page_size - 1));
p 1212 gc/os_dep.c q = (LPVOID)(p - GC_page_size);
p 1213 gc/os_dep.c if ((ptr_t)q > (ptr_t)p /* underflow */ || q < limit) break;
p 1216 gc/os_dep.c p = (ptr_t)(buf.AllocationBase);
p 1218 gc/os_dep.c return(p);
p 1245 gc/os_dep.c if (q -> allocation_base == p) return TRUE;
p 1254 gc/os_dep.c DWORD result = VirtualQuery(p, &buf, sizeof(buf));
p 1274 gc/os_dep.c void *p = malloc(req_size);
p 1275 gc/os_dep.c if (0 == p) { free(new_l); return; }
p 1276 gc/os_dep.c candidate = GC_get_allocation_base(p);
p 1277 gc/os_dep.c free(p);
p 1311 gc/os_dep.c if (GC_is_malloc_heap_base(p)) return TRUE;
p 1314 gc/os_dep.c if (GC_heap_bases[i] == p) return TRUE;
p 1325 gc/os_dep.c LPVOID p;
p 1330 gc/os_dep.c p = base = limit = GC_least_described_address(static_root);
p 1331 gc/os_dep.c while (p < GC_sysinfo.lpMaximumApplicationAddress) {
p 1332 gc/os_dep.c result = VirtualQuery(p, &buf, sizeof(buf));
p 1335 gc/os_dep.c new_limit = (char *)p + buf.RegionSize;
p 1339 gc/os_dep.c if ((char *)p == limit) {
p 1343 gc/os_dep.c base = p;
p 1347 gc/os_dep.c if (p > (LPVOID)new_limit /* overflow */) break;
p 1348 gc/os_dep.c p = (LPVOID)new_limit;
p 1979 gc/os_dep.c GC_push_all_stack((ptr_t)p, (ptr_t)p + size);
p 2031 gc/os_dep.c word q = *p;
p 2033 gc/os_dep.c GC_PUSH_ONE_STACK(q, p);
p 62 gc/pcr_interface.c PCR_ERes (*ed_proc)(void *p, size_t size, PCR_Any data);
p 74 gc/pcr_interface.c word *p;
p 83 gc/pcr_interface.c p = (word *)h;
p 87 gc/pcr_interface.c (*(ed -> ed_proc))(p, WORDS_TO_BYTES(sz), ed -> ed_client_data);
p 88 gc/pcr_interface.c p+= sz;
p 89 gc/pcr_interface.c } while (p <= lim);
p 233 gc/pthread_stop_world.c GC_thread p;
p 244 gc/pthread_stop_world.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 245 gc/pthread_stop_world.c if (p -> flags & FINISHED) continue;
p 246 gc/pthread_stop_world.c if (pthread_equal(p -> id, me)) {
p 255 gc/pthread_stop_world.c lo = p -> stop_info.stack_ptr;
p 256 gc/pthread_stop_world.c IF_IA64(bs_hi = p -> backing_store_ptr;)
p 258 gc/pthread_stop_world.c if ((p -> flags & MAIN_THREAD) == 0) {
p 259 gc/pthread_stop_world.c hi = p -> stack_end;
p 260 gc/pthread_stop_world.c IF_IA64(bs_lo = p -> backing_store_end);
p 268 gc/pthread_stop_world.c (unsigned long) p -> id,
p 281 gc/pthread_stop_world.c (unsigned long) p -> id,
p 284 gc/pthread_stop_world.c if (pthread_equal(p -> id, me)) {
p 308 gc/pthread_stop_world.c GC_thread p;
p 315 gc/pthread_stop_world.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 316 gc/pthread_stop_world.c if (p -> id != my_thread) {
p 317 gc/pthread_stop_world.c if (p -> flags & FINISHED) continue;
p 318 gc/pthread_stop_world.c if (p -> stop_info.last_stop_count == GC_stop_count) continue;
p 319 gc/pthread_stop_world.c if (p -> thread_blocked) /* Will wait */ continue;
p 322 gc/pthread_stop_world.c GC_printf1("Sending suspend signal to 0x%lx\n", p -> id);
p 325 gc/pthread_stop_world.c result = pthread_kill(p -> id, SIG_SUSPEND);
p 417 gc/pthread_stop_world.c register GC_thread p;
p 426 gc/pthread_stop_world.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 427 gc/pthread_stop_world.c if (p -> id != my_thread) {
p 428 gc/pthread_stop_world.c if (p -> flags & FINISHED) continue;
p 429 gc/pthread_stop_world.c if (p -> thread_blocked) continue;
p 432 gc/pthread_stop_world.c GC_printf1("Sending restart signal to 0x%lx\n", p -> id);
p 435 gc/pthread_stop_world.c result = pthread_kill(p -> id, SIG_THR_RESTART);
p 228 gc/pthread_support.c if (0 != GC_setspecific(GC_thread_key, p)) {
p 232 gc/pthread_support.c p -> ptrfree_freelists[i] = (ptr_t)1;
p 233 gc/pthread_support.c p -> normal_freelists[i] = (ptr_t)1;
p 235 gc/pthread_support.c p -> gcj_freelists[i] = (ptr_t)1;
p 239 gc/pthread_support.c p -> ptrfree_freelists[0] = (ptr_t)(&size_zero_object);
p 240 gc/pthread_support.c p -> normal_freelists[0] = (ptr_t)(&size_zero_object);
p 242 gc/pthread_support.c p -> gcj_freelists[0] = (ptr_t)(-1);
p 256 gc/pthread_support.c GC_ASSERT(GC_getspecific(GC_thread_key) == (void *)p);
p 258 gc/pthread_support.c return_freelists(p -> ptrfree_freelists, GC_aobjfreelist);
p 259 gc/pthread_support.c return_freelists(p -> normal_freelists, GC_objfreelist);
p 261 gc/pthread_support.c return_freelists(p -> gcj_freelists, GC_gcjobjfreelist);
p 534 gc/pthread_support.c GC_thread p;
p 538 gc/pthread_support.c for (p = GC_threads[i]; 0 != p; p = p -> next) {
p 540 gc/pthread_support.c q = p -> ptrfree_freelists[j];
p 542 gc/pthread_support.c q = p -> normal_freelists[j];
p 545 gc/pthread_support.c q = p -> gcj_freelists[j];
p 585 gc/pthread_support.c register GC_thread p = GC_threads[hv];
p 588 gc/pthread_support.c while (!pthread_equal(p -> id, id)) {
p 589 gc/pthread_support.c prev = p;
p 590 gc/pthread_support.c p = p -> next;
p 593 gc/pthread_support.c GC_threads[hv] = p -> next;
p 595 gc/pthread_support.c prev -> next = p -> next;
p 597 gc/pthread_support.c GC_INTERNAL_FREE(p);
p 607 gc/pthread_support.c register GC_thread p = GC_threads[hv];
p 610 gc/pthread_support.c while (p != gc_id) {
p 611 gc/pthread_support.c prev = p;
p 612 gc/pthread_support.c p = p -> next;
p 615 gc/pthread_support.c GC_threads[hv] = p -> next;
p 617 gc/pthread_support.c prev -> next = p -> next;
p 619 gc/pthread_support.c GC_INTERNAL_FREE(p);
p 631 gc/pthread_support.c register GC_thread p = GC_threads[hv];
p 633 gc/pthread_support.c while (p != 0 && !pthread_equal(p -> id, id)) p = p -> next;
p 634 gc/pthread_support.c return(p);
p 646 gc/pthread_support.c GC_thread p, next, me;
p 650 gc/pthread_support.c for (p = GC_threads[hv]; 0 != p; p = next) {
p 651 gc/pthread_support.c next = p -> next;
p 652 gc/pthread_support.c if (p -> id == self) {
p 653 gc/pthread_support.c me = p;
p 654 gc/pthread_support.c p -> next = 0;
p 657 gc/pthread_support.c if (!(p -> flags & FINISHED)) {
p 658 gc/pthread_support.c GC_destroy_thread_local(p);
p 661 gc/pthread_support.c if (p != &first_thread) GC_INTERNAL_FREE(p);
p 673 gc/pthread_support.c GC_thread p;
p 681 gc/pthread_support.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 682 gc/pthread_support.c if (0 != p -> stack_end) {
p 684 gc/pthread_support.c if (p -> stack_end >= lo && p -> stack_end < hi) return 1;
p 686 gc/pthread_support.c if (p -> stack_end > lo && p -> stack_end <= hi) return 1;
p 29 gc/ptr_chck.c (unsigned long)p, (unsigned long)q);
p 58 gc/ptr_chck.c hhdr = HDR((word)p);
p 60 gc/ptr_chck.c if (divHBLKSZ((word)p) != divHBLKSZ((word)q)
p 64 gc/ptr_chck.c return(p);
p 69 gc/ptr_chck.c h = HBLKPTR(p) - (word)hhdr;
p 76 gc/ptr_chck.c if ((ptr_t)p >= limit || (ptr_t)q >= limit || (ptr_t)q < (ptr_t)h ) {
p 79 gc/ptr_chck.c return(p);
p 83 gc/ptr_chck.c base = (ptr_t)HBLKPTR(p);
p 85 gc/ptr_chck.c if ((ptr_t)p >= limit) {
p 90 gc/ptr_chck.c register int pdispl = HBLKDISPL(p);
p 95 gc/ptr_chck.c if (HBLKPTR(p) != HBLKPTR(q)) goto fail;
p 100 gc/ptr_chck.c base = (char *)((word)p & ~(WORDS_TO_BYTES(1) - 1));
p 111 gc/ptr_chck.c return(p);
p 113 gc/ptr_chck.c (*GC_same_obj_print_proc)((ptr_t)p, (ptr_t)q);
p 114 gc/ptr_chck.c return(p);
p 125 gc/ptr_chck.c (unsigned long)p);
p 152 gc/ptr_chck.c hhdr = HDR((word)p);
p 153 gc/ptr_chck.c if (hhdr == 0) return(p);
p 154 gc/ptr_chck.c h = HBLKPTR(p);
p 165 gc/ptr_chck.c pdispl = HBLKDISPL(p);
p 168 gc/ptr_chck.c || sz > MAXOBJBYTES && (ptr_t)p >= (ptr_t)h + sz) {
p 171 gc/ptr_chck.c return(p);
p 173 gc/ptr_chck.c (*GC_is_valid_displacement_print_proc)((ptr_t)p);
p 174 gc/ptr_chck.c return(p);
p 185 gc/ptr_chck.c (unsigned long)p);
p 201 gc/ptr_chck.c if ((ptr_t)p >= (ptr_t)(&dummy) && (ptr_t)p < GC_stackbottom ) {
p 205 gc/ptr_chck.c if ((ptr_t)p <= (ptr_t)(&dummy) && (ptr_t)p > GC_stackbottom ) {
p 230 gc/ptr_chck.c if ((word)p & (ALIGNMENT - 1)) goto fail;
p 233 gc/ptr_chck.c hhdr = HDR((word)p);
p 234 gc/ptr_chck.c if (hhdr != 0 && GC_base(p) == 0) {
p 238 gc/ptr_chck.c return(p);
p 242 gc/ptr_chck.c if (GC_on_stack(p)) return(p);
p 243 gc/ptr_chck.c hhdr = HDR((word)p);
p 247 gc/ptr_chck.c if (GC_is_static_root(p)) return(p);
p 254 gc/ptr_chck.c result = GC_is_static_root(p);
p 256 gc/ptr_chck.c if (result) return(p);
p 262 gc/ptr_chck.c ptr_t base = GC_base(p); /* Should be manually inlined? */
p 265 gc/ptr_chck.c if (HBLKPTR(base) != HBLKPTR(p)) hhdr = HDR((word)p);
p 270 gc/ptr_chck.c if ((word)((ptr_t)p - (ptr_t)base) > (word)descr) goto fail;
p 273 gc/ptr_chck.c if ((ptr_t)p - (ptr_t)base
p 275 gc/ptr_chck.c || ((word)p & (sizeof(word) - 1))) goto fail;
p 276 gc/ptr_chck.c if (!((1 << (WORDSZ - ((ptr_t)p - (ptr_t)base) - 1))
p 294 gc/ptr_chck.c return(p);
p 298 gc/ptr_chck.c (*GC_is_visible_print_proc)((ptr_t)p);
p 299 gc/ptr_chck.c return(p);
p 307 gc/ptr_chck.c GC_PTR initial = *p;
p 313 gc/ptr_chck.c return (*p = result);
p 320 gc/ptr_chck.c GC_PTR initial = *p;
p 326 gc/ptr_chck.c *p = result;
p 66 gc/reclaim.c ptr_t p = GC_leaked[i];
p 67 gc/reclaim.c if (HDR(p) -> hb_obj_kind == PTRFREE) {
p 72 gc/reclaim.c GC_print_heap_obj(p);
p 74 gc/reclaim.c GC_free(p);
p 105 gc/reclaim.c register word *p = (word *)(&(hhdr -> hb_marks[0]));
p 108 gc/reclaim.c while (p < plim) {
p 109 gc/reclaim.c if (*p++) return(FALSE);
p 141 gc/reclaim.c register word *p = (word *)(&(hhdr -> hb_marks[0]));
p 146 gc/reclaim.c while (p < plim) {
p 147 gc/reclaim.c sum_vector += *p;
p 148 gc/reclaim.c ++p;
p 318 gc/reclaim.c register word *p, *q, *plim;
p 322 gc/reclaim.c p = (word *)(hbp->hb_body);
p 328 gc/reclaim.c while( p <= plim ) {
p 330 gc/reclaim.c p += sz;
p 334 gc/reclaim.c obj_link(p) = list;
p 335 gc/reclaim.c list = ((ptr_t)p);
p 337 gc/reclaim.c q = p + sz;
p 340 gc/reclaim.c && !((word)p & (2 * sizeof(word) - 1)));
p 341 gc/reclaim.c p[1] = 0;
p 342 gc/reclaim.c p += 2;
p 343 gc/reclaim.c while (p < q) {
p 344 gc/reclaim.c CLEAR_DOUBLE(p);
p 345 gc/reclaim.c p += 2;
p 348 gc/reclaim.c p++; /* Skip link field */
p 349 gc/reclaim.c while (p < q) {
p 350 gc/reclaim.c *p++ = 0;
p 373 gc/reclaim.c register word *p, *plim;
p 379 gc/reclaim.c p[start_displ] = (word)list; \
p 380 gc/reclaim.c list = (ptr_t)(p+start_displ); \
p 381 gc/reclaim.c p[start_displ+1] = 0; \
p 385 gc/reclaim.c p = (word *)(hbp->hb_body);
p 389 gc/reclaim.c while( p < plim ) {
p 396 gc/reclaim.c p += 8;
p 416 gc/reclaim.c register word *p, *plim;
p 421 gc/reclaim.c p[start_displ] = (word)list; \
p 422 gc/reclaim.c list = (ptr_t)(p+start_displ); \
p 423 gc/reclaim.c p[start_displ+1] = 0; \
p 424 gc/reclaim.c CLEAR_DOUBLE(p + start_displ + 2); \
p 428 gc/reclaim.c p = (word *)(hbp->hb_body);
p 432 gc/reclaim.c while( p < plim ) {
p 452 gc/reclaim.c p += WORDSZ;
p 471 gc/reclaim.c register word *p, *plim;
p 474 gc/reclaim.c p = (word *)(hbp->hb_body);
p 479 gc/reclaim.c while( p <= plim ) {
p 483 gc/reclaim.c obj_link(p) = list;
p 484 gc/reclaim.c list = ((ptr_t)p);
p 486 gc/reclaim.c p += sz;
p 501 gc/reclaim.c register word *p, *plim;
p 506 gc/reclaim.c p = (word *)(hbp->hb_body);
p 511 gc/reclaim.c while( p <= plim ) {
p 515 gc/reclaim.c p += sz;
p 532 gc/reclaim.c register word *p, *plim;
p 538 gc/reclaim.c p[start_displ] = (word)list; \
p 539 gc/reclaim.c list = (ptr_t)(p+start_displ); \
p 543 gc/reclaim.c p = (word *)(hbp->hb_body);
p 547 gc/reclaim.c while( p < plim ) {
p 554 gc/reclaim.c p += 8;
p 574 gc/reclaim.c register word *p, *plim;
p 579 gc/reclaim.c p[start_displ] = (word)list; \
p 580 gc/reclaim.c list = (ptr_t)(p+start_displ); \
p 584 gc/reclaim.c p = (word *)(hbp->hb_body);
p 588 gc/reclaim.c while( p < plim ) {
p 608 gc/reclaim.c p += WORDSZ;
p 624 gc/reclaim.c register word *p, *plim;
p 630 gc/reclaim.c p[start_displ] = (word)list; \
p 631 gc/reclaim.c list = (ptr_t)(p+start_displ); \
p 635 gc/reclaim.c p = (word *)(hbp->hb_body);
p 639 gc/reclaim.c while( p < plim ) {
p 646 gc/reclaim.c p += 4;
p 534 gc/solaris_threads.c register ptr_t p;
p 542 gc/solaris_threads.c p = s->base;
p 543 gc/solaris_threads.c h = (struct hblk *)(((word)p + HBLKSIZE-1) & ~(HBLKSIZE-1));
p 544 gc/solaris_threads.c if ((ptr_t)h == p) {
p 545 gc/solaris_threads.c GC_is_fresh((struct hblk *)p, divHBLKSZ(sz));
p 547 gc/solaris_threads.c GC_is_fresh((struct hblk *)p, divHBLKSZ(sz) - 1);
p 548 gc/solaris_threads.c BZERO(p, (ptr_t)h - p);
p 601 gc/solaris_threads.c register GC_thread p = GC_threads[hv];
p 604 gc/solaris_threads.c while (p -> id != id) {
p 605 gc/solaris_threads.c prev = p;
p 606 gc/solaris_threads.c p = p -> next;
p 609 gc/solaris_threads.c GC_threads[hv] = p -> next;
p 611 gc/solaris_threads.c prev -> next = p -> next;
p 621 gc/solaris_threads.c register GC_thread p = GC_threads[hv];
p 623 gc/solaris_threads.c while (p != 0 && p -> id != id) p = p -> next;
p 624 gc/solaris_threads.c return(p);
p 688 gc/solaris_threads.c register GC_thread p;
p 704 gc/solaris_threads.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 705 gc/solaris_threads.c if (p -> stack_size != 0) {
p 706 gc/solaris_threads.c bottom = p -> stack;
p 707 gc/solaris_threads.c top = p -> stack + p -> stack_size;
p 723 gc/solaris_threads.c register GC_thread p;
p 727 gc/solaris_threads.c for (p = GC_threads[i]; p != 0; p = p -> next) {
p 728 gc/solaris_threads.c if (p -> stack_size != 0) {
p 729 gc/solaris_threads.c if (p -> stack <= addr &&
p 730 gc/solaris_threads.c addr < p -> stack + p -> stack_size)
p 84 gc/stubborn.c register GC_PTR *p, *q;
p 92 gc/stubborn.c for (p = GC_changing_list_start; p < GC_changing_list_limit; p++) {
p 93 gc/stubborn.c if (*p != 0) count++;
p 105 gc/stubborn.c for (p = GC_changing_list_start; p < GC_changing_list_limit; p++) {
p 106 gc/stubborn.c if (*p != 0) *q++ = *p;
p 117 gc/stubborn.c register struct hblk * h = HBLKPTR(p); \
p 124 gc/stubborn.c if (!GC_compact_changing_list()) (p) = 0; \
p 126 gc/stubborn.c *GC_changing_list_current = p;
p 135 gc/stubborn.c ADD_CHANGING(p);
p 151 gc/stubborn.c if (*my_current == p) {
p 172 gc/stubborn.c if (*my_current == p) {
p 181 gc/stubborn.c (unsigned long)p);
p 243 gc/stubborn.c register GC_PTR * p = GC_changing_list_start;
p 248 gc/stubborn.c if (p == 0) /* initializing */ return;
p 252 gc/stubborn.c for (; p <= GC_changing_list_current; p++) {
p 253 gc/stubborn.c if ((q = *p) != 0) {
p 273 gc/stubborn.c register GC_PTR * p = GC_changing_list_start;
p 279 gc/stubborn.c if (p == 0) /* initializing */ return;
p 280 gc/stubborn.c for (; p <= GC_changing_list_current; p++) {
p 281 gc/stubborn.c if ((q = *p) != 0) {
p 285 gc/stubborn.c *p = 0;
p 4 gc/tests/leak_test.c int *p[10];
p 9 gc/tests/leak_test.c p[i] = malloc(sizeof(int)+i);
p 13 gc/tests/leak_test.c free(p[i]);
p 16 gc/tests/leak_test.c p[i] = malloc(sizeof(int)+i);
p 174 gc/tests/test.c register int *p;
p 183 gc/tests/test.c for (p = (int *)r;
p 184 gc/tests/test.c ((char *)p) < ((char *)r) + my_extra + sizeof(struct SEXPR); p++) {
p 185 gc/tests/test.c if (*p) {
p 187 gc/tests/test.c (unsigned long)p);
p 190 gc/tests/test.c *p = 13;
p 259 gc/tests/test.c register int *p;
p 276 gc/tests/test.c for (p = (int *)r;
p 277 gc/tests/test.c ((char *)p) < ((char *)r) + my_extra + sizeof(struct SEXPR); p++) {
p 278 gc/tests/test.c if (*p) {
p 280 gc/tests/test.c (unsigned long)p);
p 283 gc/tests/test.c *p = 13;
p 1177 gc/tests/test.c q[n++] = p;
p 1178 gc/tests/test.c va_start(a,p);
p 1475 gc/tests/test.c GC_printf1(msg, (unsigned long)p);
p 170 gc/tests/test_cpp.cc return ~ (long) p;}
p 7 gc/tests/thread_leak_test.c int *p[10];
p 12 gc/tests/thread_leak_test.c p[i] = malloc(sizeof(int)+i);
p 16 gc/tests/thread_leak_test.c free(p[i]);
p 70 src/char.c const char *p = *cs;
p 72 src/char.c for (;*p && *q; p++, q++) {
p 73 src/char.c if (tolower(*p) != tolower(*q)) break;
p 75 src/char.c if (*p == '\0' && *q == '\0') return TRUE;
p 490 src/char.c struct ScmCharSetRange *r, *p;
p 494 src/char.c for (p = NULL, r = cs->ranges; r; p = r, r = r->next) {
p 505 src/char.c if (!p) cs->ranges = newrange(last, SCM_CHAR_MAX, NULL);
p 506 src/char.c else p->next = newrange(last, SCM_CHAR_MAX, NULL);
p 543 src/class.c ScmClass **p;
p 557 src/class.c for (p = klass->cpa; *p; p++) {
p 558 src/class.c if ((*p)->allocate) {
p 559 src/class.c if ((*p)->allocate != Scm_ObjectAllocate) {
p 560 src/class.c if (klass->allocate && klass->allocate != (*p)->allocate) {
p 563 src/class.c klass->allocate = (*p)->allocate;
p 564 src/class.c klass->coreSize = (*p)->coreSize;
p 569 src/class.c if ((*p)->flags & SCM_CLASS_APPLICABLE) {
p 812 src/class.c ScmClass **p;
p 815 src/class.c p = sub->cpa;
p 816 src/class.c while (*p) {
p 817 src/class.c if (*p++ == type) return TRUE;
p 991 src/class.c ScmObj p = Scm_Cons(SCM_OBJ(sub), SCM_NIL);
p 995 src/class.c SCM_SET_CDR(p, super->directSubclasses);
p 996 src/class.c super->directSubclasses = p;
p 1017 src/class.c ScmObj p = Scm_Cons(SCM_OBJ(m), SCM_NIL);
p 1021 src/class.c SCM_SET_CDR(p, super->directMethods);
p 1022 src/class.c super->directMethods = p;
p 1241 src/class.c ScmObj p = Scm_Assq(slot, klass->accessors);
p 1242 src/class.c if (!SCM_PAIRP(p)) return NULL;
p 1243 src/class.c if (!SCM_XTYPEP(SCM_CDR(p), SCM_CLASS_SLOT_ACCESSOR))
p 1246 src/class.c return SCM_SLOT_ACCESSOR(SCM_CDR(p));
p 1781 src/class.c sa->schemeGetter = p;
p 1792 src/class.c sa->schemeSetter = p;
p 1803 src/class.c sa->schemeBoundp = p;
p 2655 src/class.c ScmObj p = Scm_Assq(key, fp->attributes);
p 2656 src/class.c if (SCM_PAIRP(p)) return SCM_CDR(p);
p 2667 src/class.c ScmObj p = Scm_Assq(key, fp->attributes);
p 2668 src/class.c if (SCM_PAIRP(p)) return SCM_SET_CDR(p, value);
p 2749 src/class.c ScmClass **p;
p 2753 src/class.c for (p = klass->cpa; *p; p++) SCM_APPEND1(h, t, SCM_OBJ(*p));
p 2829 src/class.c ScmObj slot = SCM_CAR(sp), snam, p, a;
p 2832 src/class.c p = Scm_Assq(snam, slots);
p 2833 src/class.c if (SCM_FALSEP(p)) {
p 130 src/code.c ScmWord *p;
p 139 src/code.c p = cc->code;
p 142 src/code.c ScmWord insn = p[i];
p 167 src/code.c Scm_Printf(out, "%d", (ScmWord*)p[i+1] - cc->code);
p 171 src/code.c Scm_Printf(out, "%S", p[i+1]);
p 175 src/code.c Scm_Printf(out, "%S, %d", p[i+1], (ScmWord*)p[i+2] - cc->code);
p 180 src/code.c closures = Scm_Acons(SCM_OBJ(p[i+1]), SCM_MAKE_INT(clonum),
p 187 src/code.c SCM_FOR_EACH(cp, SCM_OBJ(p[i+1])) {
p 332 src/code.c ScmObj p = Scm_Assq(label, b->labelDefs);
p 333 src/code.c if (SCM_PAIRP(p)) {
p 334 src/code.c return SCM_INT_VALUE(SCM_CDR(p));
p 51 src/dl_win.c char buf[80], *p;
p 54 src/dl_win.c p = SCM_NEW_ATOMIC2(char *, strlen(buf)+1);
p 55 src/dl_win.c strcpy(p, buf);
p 56 src/dl_win.c return p;
p 809 src/error.c char *heading, *p;
p 815 src/error.c for (p=heading; *p; p++) {
p 816 src/error.c *p = toupper(*p);
p 935 src/extlib.c ScmString *p = NULL;
p 939 src/extlib.c p = SCM_STRING(prefix);
p 941 src/extlib.c SCM_RETURN(Scm_Gensym(p));
p 2986 src/extlib.c ScmPromise* p;
p 2992 src/extlib.c p = SCM_PROMISE(p_scm);
p 2996 src/extlib.c p->kind = obj;
p 3007 src/extlib.c ScmPromise* p;
p 3011 src/extlib.c p = SCM_PROMISE(p_scm);
p 3015 src/extlib.c SCM_RESULT = (p->kind);
p 3264 src/extlib.c if (SCM_PORT_DIR(p) == SCM_PORT_OUTPUT) {
p 3265 src/extlib.c ScmObj scmflusher = SCM_OBJ(p->src.buf.data);
p 3266 src/extlib.c int siz = (int)(p->src.buf.current - p->src.buf.buffer);
p 3267 src/extlib.c if (siz > 0) Scm_Apply(scmflusher, SCM_LIST1(Scm_MakeString(p->src.buf.buffer, siz, siz, SCM_MAKSTR_INCOMPLETE|SCM_MAKSTR_COPYING)));
p 3275 src/extlib.c scmfiller = SCM_OBJ(p->src.buf.data);
p 3286 src/extlib.c memcpy(p->src.buf.end, SCM_STRING_BODY_START(b), siz);
p 3324 src/extlib.c scmflusher = SCM_OBJ(p->src.buf.data);
p 3325 src/extlib.c s = Scm_MakeString(p->src.buf.buffer, cnt, cnt, SCM_MAKSTR_INCOMPLETE|SCM_MAKSTR_COPYING);
p 133 src/gauche-config.c char *p;
p 777 src/gauche.h for((p) = (list); SCM_PAIRP(p); (p) = SCM_CDR(p))
p 1307 src/gauche.h int (*filler)(ScmPort *p, int min);
p 1308 src/gauche.h int (*flusher)(ScmPort *p, int cnt, int forcep);
p 1309 src/gauche.h void (*closer)(ScmPort *p);
p 1310 src/gauche.h int (*ready)(ScmPort *p);
p 1311 src/gauche.h int (*filenum)(ScmPort *p);
p 1312 src/gauche.h off_t (*seeker)(ScmPort *p, off_t offset, int whence);
p 1319 src/gauche.h (int)((p)->src.buf.buffer+(p)->src.buf.size-(p)->src.buf.end)
p 1324 src/gauche.h (int)((p)->src.buf.current-(p)->src.buf.buffer)
p 1329 src/gauche.h int (*Getb)(ScmPort *p);
p 1330 src/gauche.h int (*Getc)(ScmPort *p);
p 1331 src/gauche.h int (*Getz)(char *buf, int buflen, ScmPort *p);
p 1332 src/gauche.h int (*Ready)(ScmPort *p, int charp);
p 1333 src/gauche.h void (*Putb)(ScmByte b, ScmPort *p);
p 1334 src/gauche.h void (*Putc)(ScmChar c, ScmPort *p);
p 1335 src/gauche.h void (*Putz)(const char *buf, int size, ScmPort *p);
p 1336 src/gauche.h void (*Puts)(ScmString *s, ScmPort *p);
p 1337 src/gauche.h void (*Flush)(ScmPort *p);
p 1338 src/gauche.h void (*Close)(ScmPort *p);
p 1339 src/gauche.h off_t (*Seek)(ScmPort *p, off_t off, int whence);
p 1555 src/gauche.h #define SCM_PUTB(b, p) Scm_Putb(b, SCM_PORT(p))
p 1556 src/gauche.h #define SCM_PUTC(c, p) Scm_Putc(c, SCM_PORT(p))
p 1557 src/gauche.h #define SCM_PUTZ(s, l, p) Scm_Putz(s, l, SCM_PORT(p))
p 1558 src/gauche.h #define SCM_PUTS(s, p) Scm_Puts(SCM_STRING(s), SCM_PORT(p))
p 1559 src/gauche.h #define SCM_FLUSH(p) Scm_Flush(SCM_PORT(p))
p 1560 src/gauche.h #define SCM_PUTNL(p) SCM_PUTC('\n', p)
p 1563 src/gauche.h #define SCM_GETB(b, p) (b = Scm_Getb(SCM_PORT(p)))
p 1564 src/gauche.h #define SCM_GETC(c, p) (c = Scm_Getc(SCM_PORT(p)))
p 68 src/gauche/memory.h p = (type)SCMMW__tmpptr; \
p 75 src/gauche/memory.h p = (type)SCMMW__tmpptr; \
p 81 src/gauche/memory.h SCM_MALLOC_WORDS(p, sizeof(ScmPair)/sizeof(GC_word), ScmPair *); \
p 82 src/gauche/memory.h SCM_SET_CLASS(p, SCM_CLASS_PAIR); \
p 83 src/gauche/memory.h SCM_SET_CAR(p, car_); \
p 84 src/gauche/memory.h SCM_SET_CDR(p, cdr_); \
p 88 src/gauche/memory.h SCM_NEW_PAIR(p, obj0, SCM_NIL)
p 94 src/gauche/memory.h SCM_NEW_PAIR(p, obj0, SCM_OBJ(SCML2__tmpptr)); \
p 102 src/gauche/memory.h SCM_NEW_PAIR(p, obj0, SCM_OBJ(SCML3__tmpptr1)); \
p 108 src/gauche/memory.h (p = (type)SCM_MALLOC(n * sizeof(GC_word)))
p 111 src/gauche/memory.h (p = (type)SCM_MALLOC_ATOMIC(n * sizeof(GC_word)))
p 113 src/gauche/memory.h #define SCM_NEW_PAIR(p, car_, cdr_) (p = (ScmPair*)Scm_Cons(car_, cdr_))
p 115 src/gauche/memory.h #define SCM_NEW_LIST1(p, obj0) (p = Scm_Cons(obj0, SCM_NIL))
p 117 src/gauche/memory.h (p = Scm_Cons(obj0, Scm_Cons(obj1, SCM_NIL))
p 119 src/gauche/memory.h (p = Scm_Cons(obj0, Scm_Cons(obj1, Scm_Cons(obj2, SCM_NIL))))
p 80 src/gauche/port.h if (!(p->flags&SCM_PORT_PRIVATE)) { \
p 81 src/gauche/port.h if (p->lockOwner != vm) { \
p 82 src/gauche/port.h (void)SCM_INTERNAL_MUTEX_LOCK(p->mutex); \
p 83 src/gauche/port.h while (p->lockOwner != NULL) { \
p 84 src/gauche/port.h if (p->lockOwner->state == SCM_VM_TERMINATED) { \
p 87 src/gauche/port.h (void)SCM_INTERNAL_COND_WAIT(p->cv, p->mutex); \
p 89 src/gauche/port.h p->lockOwner = vm; \
p 90 src/gauche/port.h p->lockCount = 0; /* for safety */ \
p 91 src/gauche/port.h (void)SCM_INTERNAL_MUTEX_UNLOCK(p->mutex); \
p 93 src/gauche/port.h p->lockCount++; \
p 101 src/gauche/port.h if (!(p->flags&SCM_PORT_PRIVATE)) { \
p 102 src/gauche/port.h if (--p->lockCount <= 0) { \
p 103 src/gauche/port.h p->lockOwner = NULL; \
p 104 src/gauche/port.h (void)SCM_INTERNAL_COND_SIGNAL(p->cv); \
p 111 src/gauche/port.h if (!(p->flags&SCM_PORT_PRIVATE)) { \
p 115 src/gauche/port.h PORT_UNLOCK(p); \
p 124 src/gauche/port.h (((p)->flags&SCM_PORT_PRIVATE)||((p)->lockOwner == (vm)))
p 132 src/gauche/port.h p->lockOwner = vm; \
p 133 src/gauche/port.h p->lockCount = 1; \
p 204 src/hash.c const char *p;
p 206 src/hash.c p = SCM_STRING_BODY_START(b);
p 207 src/hash.c STRING_HASH(hashval, p, SCM_STRING_BODY_SIZE(b));
p 215 src/hash.c const char *p;
p 217 src/hash.c p = SCM_STRING_BODY_START(b);
p 218 src/hash.c STRING_HASH(hashval, p, SCM_STRING_BODY_SIZE(b));
p 328 src/hash.c ScmHashEntry *e, *p;
p 333 src/hash.c for (e = table->buckets[index], p = NULL; e; p = e, e = e->next) {
p 336 src/hash.c if (mode == HASH_DELETE) return delete_entry(table, e, p, index);
p 389 src/hash.c ScmHashEntry *e, *p;
p 402 src/hash.c for (e = table->buckets[index], p = NULL; e; p = e, e = e->next) {
p 410 src/hash.c if (mode == HASH_DELETE) return delete_entry(table, e, p, index);
p 425 src/hash.c const char *p;
p 427 src/hash.c p = SCM_STRING_BODY_START(b);
p 428 src/hash.c STRING_HASH(hashval, p, SCM_STRING_BODY_SIZE(b));
p 454 src/hash.c ScmHashEntry *e, *p;
p 459 src/hash.c for (e = table->buckets[index], p = NULL; e; p = e, e = e->next) {
p 462 src/hash.c if (mode == HASH_DELETE) return delete_entry(table, e, p, index);
p 483 src/hash.c ScmHashEntry *e, *p;
p 488 src/hash.c for (e = table->buckets[index], p = NULL; e; p = e, e = e->next) {
p 491 src/hash.c if (mode == HASH_DELETE) return delete_entry(table, e, p, index);
p 334 src/list.c ScmPair *p;
p 338 src/list.c SCM_NEW_PAIR(p, SCM_NIL, SCM_NIL);
p 339 src/list.c result = SCM_OBJ(p);
p 342 src/list.c SCM_NEW_PAIR(p, SCM_NIL, result);
p 343 src/list.c result = SCM_OBJ(p);
p 531 src/list.c ScmObj start = SCM_NIL, last = SCM_NIL, cp, p, prev = alist;
p 538 src/list.c p = SCM_CAR(cp);
p 539 src/list.c if (SCM_PAIRP(p)) {
p 540 src/list.c if (Scm_EqualM(elt, SCM_CAR(p), cmpmode)) {
p 693 src/list.c ScmObj p;
p 698 src/list.c p = Scm_Assq(key, SCM_EXTENDED_PAIR(pair)->attributes);
p 699 src/list.c if (SCM_PAIRP(p)) return SCM_CDR(p);
p 709 src/list.c ScmObj p;
p 715 src/list.c p = Scm_Assq(key, SCM_EXTENDED_PAIR(pair)->attributes);
p 716 src/list.c if (SCM_PAIRP(p)) SCM_SET_CDR(p, value);
p 125 src/load.c struct load_packet *p = (struct load_packet *)data;
p 133 src/load.c Scm_GetStringConst(SCM_STRING(Scm_PortName(p->port))));
p 136 src/load.c Scm_ClosePort(p->port);
p 137 src/load.c PORT_UNLOCK(p->port);
p 138 src/load.c Scm_SelectModule(p->prev_module);
p 139 src/load.c vm->load_port = p->prev_port;
p 140 src/load.c vm->load_history = p->prev_history;
p 141 src/load.c vm->load_next = p->prev_next;
p 142 src/load.c vm->evalSituation = p->prev_situation;
p 149 src/load.c struct load_packet *p = (struct load_packet*)(data[0]);
p 150 src/load.c ScmObj expr = Scm_ReadWithContext(SCM_OBJ(p->port), &(p->ctx));
p 168 src/load.c struct load_packet *p;
p 184 src/load.c p = SCM_NEW(struct load_packet);
p 185 src/load.c p->port = port;
p 186 src/load.c p->prev_module = vm->module;
p 187 src/load.c p->prev_port = vm->load_port;
p 188 src/load.c p->prev_history = vm->load_history;
p 189 src/load.c p->prev_next = vm->load_next;
p 190 src/load.c p->prev_situation = vm->evalSituation;
p 192 src/load.c SCM_READ_CONTEXT_INIT(&(p->ctx));
p 193 src/load.c p->ctx.flags = SCM_READ_LITERAL_IMMUTABLE | SCM_READ_SOURCE_INFO;
p 195 src/load.c p->ctx.flags |= SCM_READ_CASE_FOLD;
p 202 src/load.c if (SCM_PORTP(p->prev_port)) {
p 203 src/load.c port_info = SCM_LIST2(p->prev_port,
p 204 src/load.c Scm_MakeInteger(Scm_PortLine(SCM_PORT(p->prev_port))));
p 211 src/load.c return Scm_VMDynamicWindC(NULL, load_body, load_after, p);
p 623 src/load.c char *p = SCM_NEW_ATOMIC2(char*, (end-start+1));
p 624 src/load.c memcpy(p, start, (end-start));
p 625 src/load.c p[end-start] = '\0';
p 626 src/load.c return (const char*)p;
p 828 src/load.c ScmObj provided, providing, p, q;
p 843 src/load.c p = providing;
p 844 src/load.c SCM_ASSERT(SCM_PAIRP(p));
p 845 src/load.c if (SCM_CDR(p) == SCM_OBJ(vm)) {
p 851 src/load.c q = Scm_Assoc(SCM_CDR(p), ldinfo.waiting, SCM_CMP_EQ);
p 854 src/load.c p = Scm_Assoc(SCM_CDR(q), ldinfo.providing, SCM_CMP_EQUAL);
p 855 src/load.c SCM_ASSERT(SCM_PAIRP(p));
p 856 src/load.c if (SCM_CDR(p) == SCM_OBJ(vm)) {
p 110 src/macro.c ScmSyntaxPattern *p = SCM_NEW(ScmSyntaxPattern);
p 111 src/macro.c SCM_SET_CLASS(p, SCM_CLASS_SYNTAX_PATTERN);
p 112 src/macro.c p->pattern = SCM_NIL;
p 113 src/macro.c p->vars = SCM_NIL;
p 114 src/macro.c p->level = level;
p 115 src/macro.c p->repeat = repeat;
p 116 src/macro.c return p;
p 845 src/macro.c ScmObj p = Scm_Assq(template, *idlist);
p 846 src/macro.c if (SCM_PAIRP(p)) return SCM_CDR(p);
p 357 src/main.c ScmObj p = SCM_CAR(cp);
p 358 src/main.c ScmObj v = SCM_CDR(p);
p 359 src/main.c switch (SCM_CHAR_VALUE(SCM_CAR(p))) {
p 190 src/module.c ScmObj p, mp;
p 213 src/module.c SCM_FOR_EACH(p, module->imported) {
p 214 src/module.c SCM_ASSERT(SCM_MODULEP(SCM_CAR(p)));
p 215 src/module.c SCM_FOR_EACH(mp, SCM_MODULE(SCM_CAR(p))->mpl) {
p 527 src/module.c char *p = buf, *e = buf + SCM_STRING_BODY_SIZE(b);
p 529 src/module.c while (p < e) {
p 530 src/module.c int n = SCM_CHAR_NFOLLOWS(*p);
p 531 src/module.c if (*p == '.') *p++ = '/';
p 532 src/module.c else p += n+1;
p 543 src/module.c char *p = buf, *e = buf + SCM_STRING_BODY_SIZE(b);
p 545 src/module.c while (p < e) {
p 546 src/module.c int n = SCM_CHAR_NFOLLOWS(*p);
p 547 src/module.c if (*p == '/') *p++ = '.';
p 548 src/module.c else if (*p == '.') Scm_Error("bad pathname for module path: %S", path);
p 549 src/module.c else p += n+1;
p 2135 src/number.c ScmObj p = Scm_MakeOutputStringPort(TRUE);
p 2137 src/number.c SCM_PUTZ(buf, -1, SCM_PORT(p));
p 2139 src/number.c SCM_PUTZ(buf, -1, SCM_PORT(p));
p 2140 src/number.c SCM_PUTC('i', SCM_PORT(p));
p 2141 src/number.c r = Scm_GetOutputString(SCM_PORT(p));
p 2687 src/number.c const char *p = Scm_GetStringContent(str, &size, &len, NULL);
p 2692 src/number.c return read_number(p, size, radix, strict);
p 101 src/parameter.c ScmVMParameterTable *p = &(vm->parameters);
p 102 src/parameter.c if (p->numParameters == p->numAllocated) {
p 103 src/parameter.c int i, newsiz = p->numAllocated + PARAMETER_GROW;
p 107 src/parameter.c for (i=0; i<p->numParameters; i++) {
p 108 src/parameter.c newvec[i] = p->vector[i];
p 109 src/parameter.c p->vector[i] = SCM_FALSE; /*GC friendly*/
p 110 src/parameter.c newids[i] = p->ids[i];
p 112 src/parameter.c p->vector = newvec;
p 113 src/parameter.c p->ids = newids;
p 114 src/parameter.c p->numAllocated += PARAMETER_GROW;
p 116 src/parameter.c p->vector[p->numParameters] = SCM_UNDEFINED;
p 118 src/parameter.c p->ids[p->numParameters] = *newid = next_parameter_id++;
p 120 src/parameter.c return p->numParameters++;
p 129 src/parameter.c ScmVMParameterTable *p = &(vm->parameters);
p 131 src/parameter.c if (index >= p->numParameters || p->ids[index] != id) {
p 135 src/parameter.c SCM_ASSERT(p->vector[index] != NULL);
p 136 src/parameter.c return p->vector[index];
p 141 src/parameter.c ScmVMParameterTable *p = &(vm->parameters);
p 143 src/parameter.c if (index >= p->numParameters || p->ids[index] != id) {
p 147 src/parameter.c p->vector[index] = value;
p 178 src/port.c ScmPort *p = (ScmPort*)data;
p 180 src/port.c PORT_LOCK(p, vm);
p 186 src/port.c ScmPort *p = (ScmPort*)data;
p 187 src/port.c PORT_UNLOCK(p);
p 441 src/port.c ScmPort *p;
p 447 src/port.c p = make_port(klass, dir, SCM_PORT_FILE);
p 448 src/port.c p->name = name;
p 449 src/port.c p->ownerp = ownerp;
p 450 src/port.c p->src.buf.buffer = buf;
p 452 src/port.c p->src.buf.current = p->src.buf.buffer;
p 453 src/port.c p->src.buf.end = p->src.buf.buffer;
p 455 src/port.c p->src.buf.current = p->src.buf.buffer;
p 456 src/port.c p->src.buf.end = p->src.buf.buffer + size;
p 458 src/port.c p->src.buf.size = size;
p 459 src/port.c p->src.buf.mode = bufrec->mode;
p 460 src/port.c p->src.buf.filler = bufrec->filler;
p 461 src/port.c p->src.buf.flusher = bufrec->flusher;
p 462 src/port.c p->src.buf.closer = bufrec->closer;
p 463 src/port.c p->src.buf.ready = bufrec->ready;
p 464 src/port.c p->src.buf.filenum = bufrec->filenum;
p 465 src/port.c p->src.buf.seeker = bufrec->seeker;
p 466 src/port.c p->src.buf.data = bufrec->data;
p 467 src/port.c if (dir == SCM_PORT_OUTPUT) register_buffered_port(p);
p 468 src/port.c return SCM_OBJ(p);
p 477 src/port.c int cursiz = SCM_PORT_BUFFER_AVAIL(p);
p 482 src/port.c nwrote = p->src.buf.flusher(p, cnt, forcep);
p 484 src/port.c p->src.buf.current = p->src.buf.buffer; /* for safety */
p 485 src/port.c p->error = TRUE;
p 488 src/port.c Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
p 489 src/port.c "Couldn't flush port %S due to an error", p);
p 492 src/port.c memmove(p->src.buf.buffer, p->src.buf.buffer+nwrote,
p 494 src/port.c p->src.buf.current -= nwrote;
p 496 src/port.c p->src.buf.current = p->src.buf.buffer;
p 505 src/port.c int room = (int)(p->src.buf.end - p->src.buf.current);
p 507 src/port.c memcpy(p->src.buf.current, src, siz);
p 508 src/port.c p->src.buf.current += siz;
p 511 src/port.c memcpy(p->src.buf.current, src, room);
p 512 src/port.c p->src.buf.current += room;
p 515 src/port.c bufport_flush(p, 0, FALSE);
p 527 src/port.c int cursiz = (int)(p->src.buf.end - p->src.buf.current);
p 530 src/port.c memmove(p->src.buf.buffer, p->src.buf.current, cursiz);
p 531 src/port.c p->src.buf.current = p->src.buf.buffer;
p 532 src/port.c p->src.buf.end = p->src.buf.current + cursiz;
p 534 src/port.c p->src.buf.current = p->src.buf.end = p->src.buf.buffer;
p 536 src/port.c if (min <= 0) min = SCM_PORT_BUFFER_ROOM(p);
p 537 src/port.c if (p->src.buf.mode != SCM_PORT_BUFFER_NONE) {
p 538 src/port.c toread = SCM_PORT_BUFFER_ROOM(p);
p 544 src/port.c int r = p->src.buf.filler(p, toread-nread);
p 547 src/port.c p->src.buf.end += r;
p 566 src/port.c int avail = (int)(p->src.buf.end - p->src.buf.current);
p 570 src/port.c memcpy(dst, p->src.buf.current, req);
p 571 src/port.c p->src.buf.current += req;
p 577 src/port.c req = MIN(siz, p->src.buf.size);
p 578 src/port.c r = bufport_fill(p, req, TRUE);
p 581 src/port.c memcpy(dst, p->src.buf.current, siz);
p 582 src/port.c p->src.buf.current += siz;
p 586 src/port.c memcpy(dst, p->src.buf.current, r);
p 587 src/port.c p->src.buf.current += r;
p 592 src/port.c if (p->src.buf.mode != SCM_PORT_BUFFER_FULL) {
p 594 src/port.c if (p->src.buf.ready
p 595 src/port.c && p->src.buf.ready(p) == SCM_FD_WOULDBLOCK) {
p 644 src/port.c ScmObj p;
p 650 src/port.c p = Scm_WeakVectorRef(active_buffered_ports.ports, i, SCM_FALSE);
p 651 src/port.c if (!SCM_FALSEP(p) && SCM_EQ(SCM_OBJ(port), p)) {
p 672 src/port.c ScmObj p = SCM_FALSE;
p 681 src/port.c p = Scm_WeakVectorRef(ports, i, SCM_FALSE);
p 682 src/port.c if (!SCM_FALSEP(p)) {
p 683 src/port.c Scm_WeakVectorSet(save, i, p);
p 690 src/port.c if (!SCM_FALSEP(p)) {
p 691 src/port.c SCM_ASSERT(SCM_PORTP(p) && SCM_PORT_TYPE(p)==SCM_PORT_FILE);
p 692 src/port.c if (!SCM_PORT_ERROR_OCCURRED_P(SCM_PORT(p))) {
p 693 src/port.c bufport_flush(SCM_PORT(p), 0, TRUE);
p 700 src/port.c p = Scm_WeakVectorRef(save, i, SCM_FALSE);
p 701 src/port.c if (!SCM_FALSEP(p)) Scm_WeakVectorSet(ports, i, p);
p 765 src/port.c int fd = (int)p->src.buf.data;
p 766 src/port.c char *datptr = p->src.buf.end;
p 772 src/port.c p->error = TRUE;
p 773 src/port.c Scm_SysError("read failed on %S", p);
p 788 src/port.c int datsiz = SCM_PORT_BUFFER_AVAIL(p);
p 789 src/port.c int fd = (int)p->src.buf.data;
p 790 src/port.c char *datptr = p->src.buf.buffer;
p 798 src/port.c p->error = TRUE;
p 799 src/port.c Scm_SysError("write failed on %S", p);
p 810 src/port.c int fd = (int)p->src.buf.data;
p 817 src/port.c int fd = (int)p->src.buf.data;
p 819 src/port.c return Scm_FdReady(fd, SCM_PORT_DIR(p));
p 824 src/port.c return (int)p->src.buf.data;
p 829 src/port.c return lseek((int)p->src.buf.data, offset, whence);
p 835 src/port.c ScmObj p;
p 862 src/port.c p = Scm_MakeBufferedPort(SCM_CLASS_PORT, SCM_MAKE_STR_COPYING(path),
p 864 src/port.c return p;
p 877 src/port.c ScmObj p;
p 891 src/port.c p = Scm_MakeBufferedPort(SCM_CLASS_PORT, name, direction, ownerp, &bufrec);
p 892 src/port.c return p;
p 901 src/port.c ScmPort *p = make_port(SCM_CLASS_PORT, SCM_PORT_INPUT, SCM_PORT_ISTR);
p 904 src/port.c p->src.istr.start = s;
p 905 src/port.c p->src.istr.current = s;
p 906 src/port.c p->src.istr.end = s + size;
p 907 src/port.c SCM_PORT(p)->name = SCM_MAKE_STR("(input string port)");
p 908 src/port.c if (privatep) PORT_PRELOCK(p, Scm_VM());
p 909 src/port.c return SCM_OBJ(p);
p 914 src/port.c ScmPort *p = make_port(SCM_CLASS_PORT, SCM_PORT_OUTPUT, SCM_PORT_OSTR);
p 915 src/port.c Scm_DStringInit(&p->src.ostr);
p 916 src/port.c SCM_PORT(p)->name = SCM_MAKE_STR("(output string port)");
p 917 src/port.c if (privatep) PORT_PRELOCK(p, Scm_VM());
p 918 src/port.c return SCM_OBJ(p);
p 1016 src/port.c ScmPort *p = make_port(klass, direction, SCM_PORT_PROC);
p 1019 src/port.c p->src.vt = *vtable;
p 1020 src/port.c if (!p->src.vt.Getb) p->src.vt.Getb = null_getb;
p 1021 src/port.c if (!p->src.vt.Getc) p->src.vt.Getc = null_getc;
p 1022 src/port.c if (!p->src.vt.Getz) p->src.vt.Getz = null_getz;
p 1023 src/port.c if (!p->src.vt.Ready) p->src.vt.Ready = null_ready;
p 1024 src/port.c if (!p->src.vt.Putb) p->src.vt.Putb = null_putb;
p 1025 src/port.c if (!p->src.vt.Putc) p->src.vt.Putc = null_putc;
p 1026 src/port.c if (!p->src.vt.Putz) p->src.vt.Putz = null_putz;
p 1027 src/port.c if (!p->src.vt.Puts) p->src.vt.Puts = null_puts;
p 1028 src/port.c if (!p->src.vt.Flush) p->src.vt.Flush = null_flush;
p 1030 src/port.c return SCM_OBJ(p);
p 1182 src/port.c coding_port_data *data = (coding_port_data*)p->src.buf.data;
p 1183 src/port.c char *datptr = p->src.buf.end;
p 1193 src/port.c coding_port_recognize_encoding(p, data);
p 1220 src/port.c coding_port_data *data = (coding_port_data*)p->src.buf.data;
p 1229 src/port.c coding_port_data *data = (coding_port_data*)p->src.buf.data;
p 1234 src/port.c return Scm_ByteReadyUnsafe(p);
p 1240 src/port.c coding_port_data *data = (coding_port_data*)p->src.buf.data;
p 1247 src/port.c ScmObj p;
p 1270 src/port.c p = Scm_MakeBufferedPort(SCM_CLASS_CODING_AWARE_PORT,
p 1273 src/port.c return p;
p 1288 src/port.c struct with_port_packet *p = (struct with_port_packet*)data;
p 1292 src/port.c if (p->mask & SCM_PORT_CURIN) {
p 1294 src/port.c SCM_CURIN = p->origport[pcnt++];
p 1295 src/port.c if (p->closep) Scm_ClosePort(curport);
p 1297 src/port.c if (p->mask & SCM_PORT_CUROUT) {
p 1299 src/port.c SCM_CUROUT = p->origport[pcnt++];
p 1300 src/port.c if (p->closep) Scm_ClosePort(curport);
p 1302 src/port.c if (p->mask & SCM_PORT_CURERR) {
p 1304 src/port.c SCM_CURERR = p->origport[pcnt++];
p 1305 src/port.c if (p->closep) Scm_ClosePort(curport);
p 67 src/portapi.c #define LOCK(p) PORT_LOCK(p, vm)
p 68 src/portapi.c #define UNLOCK(p) PORT_UNLOCK(p)
p 69 src/portapi.c #define SAFE_CALL(p, exp) PORT_SAFE_CALL(p, exp)
p 71 src/portapi.c do { if (PORT_LOCKED(p, vm)) { unsafe; }} while (0)
p 86 src/portapi.c UNLOCK(p); \
p 104 src/portapi.c SHORTCUT(p, Scm_PutbUnsafe(b, p); return);
p 105 src/portapi.c LOCK(p);
p 106 src/portapi.c CLOSE_CHECK(p);
p 108 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 110 src/portapi.c if (p->src.buf.current >= p->src.buf.end) {
p 111 src/portapi.c SAFE_CALL(p, bufport_flush(p, p->src.buf.current - p->src.buf.buffer, FALSE));
p 113 src/portapi.c SCM_ASSERT(p->src.buf.current < p->src.buf.end);
p 114 src/portapi.c *p->src.buf.current++ = b;
p 115 src/portapi.c if (p->src.buf.mode == SCM_PORT_BUFFER_NONE) {
p 116 src/portapi.c SAFE_CALL(p, bufport_flush(p, 1, FALSE));
p 118 src/portapi.c UNLOCK(p);
p 121 src/portapi.c SCM_DSTRING_PUTB(&p->src.ostr, b);
p 122 src/portapi.c UNLOCK(p);
p 125 src/portapi.c SAFE_CALL(p, p->src.vt.Putb(b, p));
p 126 src/portapi.c UNLOCK(p);
p 129 src/portapi.c UNLOCK(p);
p 130 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
p 131 src/portapi.c "bad port type for output: %S", p);
p 147 src/portapi.c SHORTCUT(p, Scm_PutcUnsafe(c, p); return);
p 148 src/portapi.c LOCK(p);
p 149 src/portapi.c CLOSE_CHECK(p);
p 151 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 154 src/portapi.c if (p->src.buf.current+nb > p->src.buf.end) {
p 155 src/portapi.c SAFE_CALL(p, bufport_flush(p, p->src.buf.current - p->src.buf.buffer, FALSE));
p 157 src/portapi.c SCM_ASSERT(p->src.buf.current+nb <= p->src.buf.end);
p 158 src/portapi.c SCM_CHAR_PUT(p->src.buf.current, c);
p 159 src/portapi.c p->src.buf.current += nb;
p 160 src/portapi.c if (p->src.buf.mode == SCM_PORT_BUFFER_LINE) {
p 162 src/portapi.c SAFE_CALL(p, bufport_flush(p, nb, FALSE));
p 164 src/portapi.c } else if (p->src.buf.mode == SCM_PORT_BUFFER_NONE) {
p 165 src/portapi.c SAFE_CALL(p, bufport_flush(p, nb, FALSE));
p 167 src/portapi.c UNLOCK(p);
p 170 src/portapi.c SCM_DSTRING_PUTC(&p->src.ostr, c);
p 171 src/portapi.c UNLOCK(p);
p 174 src/portapi.c PORT_SAFE_CALL(p, p->src.vt.Putc(c, p));
p 175 src/portapi.c UNLOCK(p);
p 178 src/portapi.c UNLOCK(p);
p 179 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
p 180 src/portapi.c "bad port type for output: %S", p);
p 195 src/portapi.c SHORTCUT(p, Scm_PutsUnsafe(s, p); return);
p 196 src/portapi.c LOCK(p);
p 197 src/portapi.c CLOSE_CHECK(p);
p 199 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 203 src/portapi.c SAFE_CALL(p, bufport_write(p, ss, size));
p 205 src/portapi.c if (p->src.buf.mode == SCM_PORT_BUFFER_LINE) {
p 206 src/portapi.c const char *cp = p->src.buf.current;
p 207 src/portapi.c while (cp-- > p->src.buf.buffer) {
p 209 src/portapi.c SAFE_CALL(p, bufport_flush(p, (int)(cp - p->src.buf.current), FALSE));
p 213 src/portapi.c } else if (p->src.buf.mode == SCM_PORT_BUFFER_NONE) {
p 214 src/portapi.c SAFE_CALL(p, bufport_flush(p, 0, TRUE));
p 216 src/portapi.c UNLOCK(p);
p 220 src/portapi.c Scm_DStringAdd(&p->src.ostr, s);
p 221 src/portapi.c UNLOCK(p);
p 224 src/portapi.c SAFE_CALL(p, p->src.vt.Puts(s, p));
p 225 src/portapi.c UNLOCK(p);
p 228 src/portapi.c UNLOCK(p);
p 229 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
p 230 src/portapi.c "bad port type for output: %S", p);
p 245 src/portapi.c SHORTCUT(p, Scm_PutzUnsafe(s, siz, p); return);
p 246 src/portapi.c LOCK(p);
p 247 src/portapi.c CLOSE_CHECK(p);
p 249 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 251 src/portapi.c SAFE_CALL(p, bufport_write(p, s, siz));
p 252 src/portapi.c if (p->src.buf.mode == SCM_PORT_BUFFER_LINE) {
p 253 src/portapi.c const char *cp = p->src.buf.current;
p 254 src/portapi.c while (cp-- > p->src.buf.buffer) {
p 256 src/portapi.c SAFE_CALL(p, bufport_flush(p, (int)(cp - p->src.buf.current), FALSE));
p 260 src/portapi.c } else if (p->src.buf.mode == SCM_PORT_BUFFER_NONE) {
p 261 src/portapi.c SAFE_CALL(p, bufport_flush(p, 0, TRUE));
p 263 src/portapi.c UNLOCK(p);
p 266 src/portapi.c Scm_DStringPutz(&p->src.ostr, s, siz);
p 267 src/portapi.c UNLOCK(p);
p 270 src/portapi.c SAFE_CALL(p, p->src.vt.Putz(s, siz, p));
p 271 src/portapi.c UNLOCK(p);
p 274 src/portapi.c UNLOCK(p);
p 275 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
p 276 src/portapi.c "bad port type for output: %S", p);
p 291 src/portapi.c SHORTCUT(p, Scm_FlushUnsafe(p); return);
p 292 src/portapi.c LOCK(p);
p 293 src/portapi.c CLOSE_CHECK(p);
p 294 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 296 src/portapi.c SAFE_CALL(p, bufport_flush(p, 0, TRUE));
p 297 src/portapi.c UNLOCK(p);
p 300 src/portapi.c UNLOCK(p);
p 303 src/portapi.c SAFE_CALL(p, p->src.vt.Flush(p));
p 304 src/portapi.c UNLOCK(p);
p 307 src/portapi.c UNLOCK(p);
p 308 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_OUTPUT,
p 309 src/portapi.c "bad port type for output: %S", p);
p 324 src/portapi.c SHORTCUT(p, Scm_UngetcUnsafe(c, p); return);
p 325 src/portapi.c LOCK(p);
p 326 src/portapi.c if (p->ungotten != SCM_CHAR_INVALID
p 327 src/portapi.c || p->scrcnt != 0) {
p 328 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_INPUT,
p 329 src/portapi.c "pushback buffer overflow on port %S", p);
p 331 src/portapi.c p->ungotten = c;
p 332 src/portapi.c UNLOCK(p);
p 343 src/portapi.c SHORTCUT(p, return Scm_PeekcUnsafe(p));
p 344 src/portapi.c LOCK(p);
p 345 src/portapi.c if ((ch = p->ungotten) == SCM_CHAR_INVALID) {
p 346 src/portapi.c ch = Scm_GetcUnsafe(p);
p 347 src/portapi.c p->ungotten = ch;
p 349 src/portapi.c UNLOCK(p);
p 364 src/portapi.c SHORTCUT(p, Scm_UngetbUnsafe(b, p); return);
p 365 src/portapi.c LOCK(p);
p 366 src/portapi.c if (p->ungotten != SCM_CHAR_INVALID
p 367 src/portapi.c || p->scrcnt >= SCM_CHAR_MAX_BYTES) {
p 368 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_INPUT,
p 369 src/portapi.c "pushback buffer overflow on port %S", p);
p 371 src/portapi.c p->scratch[p->scrcnt++] = b;
p 372 src/portapi.c UNLOCK(p);
p 383 src/portapi.c SHORTCUT(p, return Scm_PeekbUnsafe(p));
p 384 src/portapi.c LOCK(p);
p 385 src/portapi.c if (p->scrcnt > 0) {
p 386 src/portapi.c b = (unsigned char)p->scratch[0];
p 388 src/portapi.c SCM_GETB(b, p);
p 390 src/portapi.c if (p->scrcnt > 0) {
p 393 src/portapi.c SCM_ASSERT(p->scrcnt < SCM_CHAR_MAX_BYTES);
p 394 src/portapi.c for (i=p->scrcnt; i>0; i--) {
p 395 src/portapi.c p->scratch[i] = p->scratch[i-1];
p 397 src/portapi.c p->scratch[0] = b;
p 398 src/portapi.c p->scrcnt++;
p 400 src/portapi.c p->scratch[0] = b;
p 401 src/portapi.c p->scrcnt = 1;
p 405 src/portapi.c UNLOCK(p);
p 420 src/portapi.c for (i=0; i<p->scrcnt; i++) {
p 421 src/portapi.c p->scratch[i] = p->scratch[i+off];
p 428 src/portapi.c int b = (unsigned char)p->scratch[0];
p 429 src/portapi.c p->scrcnt--;
p 430 src/portapi.c shift_scratch(p, 1);
p 437 src/portapi.c SCM_CHAR_PUT(p->scratch, p->ungotten);
p 438 src/portapi.c p->scrcnt = SCM_CHAR_NBYTES(p->ungotten);
p 439 src/portapi.c p->ungotten = SCM_CHAR_INVALID;
p 440 src/portapi.c return getb_scratch(p);
p 453 src/portapi.c SHORTCUT(p, return Scm_GetbUnsafe(p));
p 454 src/portapi.c LOCK(p);
p 455 src/portapi.c CLOSE_CHECK(p);
p 458 src/portapi.c if (p->scrcnt) {
p 459 src/portapi.c b = getb_scratch(p);
p 460 src/portapi.c } else if (p->ungotten != SCM_CHAR_INVALID) {
p 461 src/portapi.c b = getb_ungotten(p);
p 463 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 465 src/portapi.c if (p->src.buf.current >= p->src.buf.end) {
p 466 src/portapi.c SAFE_CALL(p, r = bufport_fill(p, 1, FALSE));
p 468 src/portapi.c UNLOCK(p);
p 472 src/portapi.c b = (unsigned char)*p->src.buf.current++;
p 475 src/portapi.c if (p->src.istr.current >= p->src.istr.end) b = EOF;
p 476 src/portapi.c else b = (unsigned char)*p->src.istr.current++;
p 479 src/portapi.c SAFE_CALL(p, b = p->src.vt.Getb(p));
p 482 src/portapi.c UNLOCK(p);
p 483 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_INPUT,
p 484 src/portapi.c "bad port type for input: %S", p);
p 487 src/portapi.c UNLOCK(p);
p 505 src/portapi.c int nb = SCM_CHAR_NFOLLOWS(p->scratch[0]), ch, i, curr = p->scrcnt;
p 508 src/portapi.c memcpy(tbuf, p->scratch, curr);
p 509 src/portapi.c p->scrcnt = 0;
p 511 src/portapi.c SAFE_CALL(p, r = Scm_Getb(p));
p 513 src/portapi.c UNLOCK(p);
p 514 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_INPUT,
p 515 src/portapi.c "encountered EOF in middle of a multibyte character from port %S", p);
p 532 src/portapi.c SHORTCUT(p, return Scm_GetcUnsafe(p));
p 533 src/portapi.c LOCK(p);
p 534 src/portapi.c CLOSE_CHECK(p);
p 535 src/portapi.c if (p->scrcnt > 0) {
p 536 src/portapi.c r = GETC_SCRATCH(p);
p 537 src/portapi.c UNLOCK(p);
p 540 src/portapi.c if (p->ungotten != SCM_CHAR_INVALID) {
p 541 src/portapi.c c = p->ungotten;
p 542 src/portapi.c p->ungotten = SCM_CHAR_INVALID;
p 543 src/portapi.c UNLOCK(p);
p 547 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 549 src/portapi.c if (p->src.buf.current >= p->src.buf.end) {
p 550 src/portapi.c SAFE_CALL(p, r = bufport_fill(p, 1, FALSE));
p 552 src/portapi.c UNLOCK(p);
p 556 src/portapi.c first = (unsigned char)*p->src.buf.current++;
p 559 src/portapi.c if (p->src.buf.current + nb > p->src.buf.end) {
p 564 src/portapi.c p->scrcnt = (unsigned char)(p->src.buf.end - p->src.buf.current + 1);
p 565 src/portapi.c memcpy(p->scratch, p->src.buf.current-1, p->scrcnt);
p 566 src/portapi.c p->src.buf.current = p->src.buf.end;
p 567 src/portapi.c rest = nb + 1 - p->scrcnt;
p 569 src/portapi.c SAFE_CALL(p, filled = bufport_fill(p, rest, FALSE));
p 572 src/portapi.c UNLOCK(p);
p 573 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_INPUT,
p 574 src/portapi.c "encountered EOF in middle of a multibyte character from port %S", p);
p 577 src/portapi.c memcpy(p->scratch+p->scrcnt, p->src.buf.current, rest);
p 578 src/portapi.c p->scrcnt += rest;
p 579 src/portapi.c p->src.buf.current += rest;
p 582 src/portapi.c memcpy(p->scratch+p->scrcnt, p->src.buf.current, filled);
p 583 src/portapi.c p->scrcnt += filled;
p 584 src/portapi.c p->src.buf.current = p->src.buf.end;
p 588 src/portapi.c SCM_CHAR_GET(p->scratch, c);
p 589 src/portapi.c p->scrcnt = 0;
p 591 src/portapi.c SCM_CHAR_GET(p->src.buf.current-1, c);
p 592 src/portapi.c p->src.buf.current += nb;
p 596 src/portapi.c if (c == '\n') p->line++;
p 598 src/portapi.c UNLOCK(p);
p 601 src/portapi.c if (p->src.istr.current >= p->src.istr.end) {
p 602 src/portapi.c UNLOCK(p);
p 605 src/portapi.c first = (unsigned char)*p->src.istr.current++;
p 608 src/portapi.c if (p->src.istr.current + nb > p->src.istr.end) {
p 610 src/portapi.c UNLOCK(p);
p 611 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_INPUT,
p 612 src/portapi.c "encountered EOF in middle of a multibyte character from port %S", p);
p 614 src/portapi.c SCM_CHAR_GET(p->src.istr.current-1, c);
p 615 src/portapi.c p->src.istr.current += nb;
p 618 src/portapi.c if (c == '\n') p->line++;
p 620 src/portapi.c UNLOCK(p);
p 623 src/portapi.c SAFE_CALL(p, c = p->src.vt.Getc(p));
p 624 src/portapi.c if (c == '\n') p->line++;
p 625 src/portapi.c UNLOCK(p);
p 628 src/portapi.c UNLOCK(p);
p 629 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_INPUT,
p 630 src/portapi.c "bad port type for input: %S", p);
p 653 src/portapi.c if (p->scrcnt >= buflen) {
p 654 src/portapi.c memcpy(buf, p->scratch, buflen);
p 655 src/portapi.c p->scrcnt -= buflen;
p 656 src/portapi.c shift_scratch(p, buflen);
p 659 src/portapi.c memcpy(buf, p->scratch, p->scrcnt);
p 660 src/portapi.c i = p->scrcnt;
p 661 src/portapi.c p->scrcnt = 0;
p 662 src/portapi.c SAFE_CALL(p, n = Scm_Getz(buf+i, buflen-i, p));
p 672 src/portapi.c if (p->src.istr.current + buflen >= p->src.istr.end) {
p 673 src/portapi.c if (p->src.istr.current >= p->src.istr.end) return EOF;
p 674 src/portapi.c siz = (int)(p->src.istr.end - p->src.istr.current);
p 675 src/portapi.c memcpy(buf, p->src.istr.current, siz);
p 676 src/portapi.c p->src.istr.current = p->src.istr.end;
p 679 src/portapi.c memcpy(buf, p->src.istr.current, buflen);
p 680 src/portapi.c p->src.istr.current += buflen;
p 694 src/portapi.c SHORTCUT(p, return Scm_GetzUnsafe(buf, buflen, p));
p 695 src/portapi.c LOCK(p);
p 696 src/portapi.c CLOSE_CHECK(p);
p 698 src/portapi.c if (p->scrcnt) {
p 699 src/portapi.c r = GETZ_SCRATCH(buf, buflen, p);
p 700 src/portapi.c UNLOCK(p);
p 703 src/portapi.c if (p->ungotten != SCM_CHAR_INVALID) {
p 704 src/portapi.c p->scrcnt = SCM_CHAR_NBYTES(p->ungotten);
p 705 src/portapi.c SCM_CHAR_PUT(p->scratch, p->ungotten);
p 706 src/portapi.c p->ungotten = SCM_CHAR_INVALID;
p 707 src/portapi.c r = GETZ_SCRATCH(buf, buflen, p);
p 708 src/portapi.c UNLOCK(p);
p 712 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 714 src/portapi.c SAFE_CALL(p, siz = bufport_read(p, buf, buflen));
p 715 src/portapi.c UNLOCK(p);
p 719 src/portapi.c r = GETZ_ISTR(p, buf, buflen);
p 720 src/portapi.c UNLOCK(p);
p 723 src/portapi.c SAFE_CALL(p, r = p->src.vt.Getz(buf, buflen, p));
p 724 src/portapi.c UNLOCK(p);
p 727 src/portapi.c UNLOCK(p);
p 728 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_INPUT,
p 729 src/portapi.c "bad port type for input: %S", p);
p 763 src/portapi.c b1 = Scm_GetbUnsafe(p);
p 769 src/portapi.c b2 = Scm_GetbUnsafe(p);
p 771 src/portapi.c Scm_UngetbUnsafe(b2, p);
p 775 src/portapi.c b1 = Scm_GetbUnsafe(p);
p 777 src/portapi.c p->line++;
p 790 src/portapi.c SHORTCUT(p, return Scm_ReadLineUnsafe(p));
p 792 src/portapi.c LOCK(p);
p 793 src/portapi.c SAFE_CALL(p, r = readline_body(p));
p 794 src/portapi.c UNLOCK(p);
p 810 src/portapi.c SHORTCUT(p, return Scm_ByteReadyUnsafe(p));
p 811 src/portapi.c if (!SCM_IPORTP(p)) Scm_Error("input port required, but got %S", p);
p 812 src/portapi.c LOCK(p);
p 813 src/portapi.c if (p->ungotten != SCM_CHAR_INVALID
p 814 src/portapi.c || p->scrcnt > 0) {
p 817 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 819 src/portapi.c if (p->src.buf.current < p->src.buf.end) r = TRUE;
p 820 src/portapi.c else if (p->src.buf.ready == NULL) r = TRUE;
p 822 src/portapi.c SAFE_CALL(p, r = (p->src.buf.ready(p) != SCM_FD_WOULDBLOCK));
p 826 src/portapi.c SAFE_CALL(p, r = p->src.vt.Ready(p, FALSE));
p 832 src/portapi.c UNLOCK(p);
p 848 src/portapi.c SHORTCUT(p, return Scm_CharReadyUnsafe(p));
p 849 src/portapi.c if (!SCM_IPORTP(p)) Scm_Error("input port required, but got %S", p);
p 850 src/portapi.c LOCK(p);
p 851 src/portapi.c if (p->ungotten != SCM_CHAR_INVALID) r = TRUE;
p 853 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 855 src/portapi.c if (p->src.buf.current < p->src.buf.end) r = TRUE;
p 856 src/portapi.c else if (p->src.buf.ready == NULL) r = TRUE;
p 858 src/portapi.c SAFE_CALL(p, r = (p->src.buf.ready(p) != SCM_FD_WOULDBLOCK));
p 862 src/portapi.c SAFE_CALL(p, r = p->src.vt.Ready(p, TRUE));
p 868 src/portapi.c UNLOCK(p);
p 882 src/portapi.c r = (off_t)(p->src.istr.current - p->src.istr.start);
p 886 src/portapi.c z += (long)(p->src.istr.current - p->src.istr.start);
p 888 src/portapi.c z += (long)(p->src.istr.end - p->src.istr.start);
p 890 src/portapi.c if (z < 0 || z > (long)(p->src.istr.end - p->src.istr.start)) {
p 893 src/portapi.c p->src.istr.current = p->src.istr.start + z;
p 894 src/portapi.c r = (off_t)(p->src.istr.current - p->src.istr.start);
p 896 src/portapi.c p->ungotten = SCM_CHAR_INVALID;
p 911 src/portapi.c SHORTCUT(p, return Scm_PortSeekUnsafe(p, off, whence));
p 912 src/portapi.c if (SCM_PORT_CLOSED_P(p)) {
p 913 src/portapi.c Scm_PortError(p, SCM_PORT_ERROR_CLOSED,
p 914 src/portapi.c "attempt to seek on closed port: %S", p);
p 916 src/portapi.c LOCK(p);
p 917 src/portapi.c switch (SCM_PORT_TYPE(p)) {
p 925 src/portapi.c if (!p->src.buf.seeker) break;
p 927 src/portapi.c SAFE_CALL(p, r = p->src.buf.seeker(p, 0, SEEK_CUR));
p 928 src/portapi.c if (SCM_PORT_DIR(p)&SCM_PORT_INPUT) {
p 929 src/portapi.c r -= (off_t)(p->src.buf.end - p->src.buf.current);
p 931 src/portapi.c r += (off_t)(p->src.buf.current - p->src.buf.buffer);
p 936 src/portapi.c if (SCM_PORT_DIR(p)&SCM_PORT_INPUT) {
p 938 src/portapi.c o -= (off_t)(p->src.buf.end - p->src.buf.current);
p 940 src/portapi.c p->src.buf.current = p->src.buf.end; /* invalidate buffer */
p 941 src/portapi.c SAFE_CALL(p, r = p->src.buf.seeker(p, o, whence));
p 943 src/portapi.c SAFE_CALL(p, bufport_flush(p, 0, TRUE));
p 944 src/portapi.c SAFE_CALL(p, r = p->src.buf.seeker(p, o, whence));
p 947 src/portapi.c p->ungotten = SCM_CHAR_INVALID;
p 951 src/portapi.c r = SEEK_ISTR(p, o, whence, nomove);
p 955 src/portapi.c r = (off_t)Scm_DStringSize(&(p->src.ostr));
p 962 src/portapi.c if (p->src.vt.Seek) {
p 963 src/portapi.c SAFE_CALL(p, r = p->src.vt.Seek(p, o, whence));
p 967 src/portapi.c UNLOCK(p);
p 352 src/proc.c return SCM_MAKE_INT(p->required);
p 357 src/proc.c return SCM_MAKE_BOOL(p->optional);
p 362 src/proc.c return SCM_MAKE_BOOL(p->locked);
p 367 src/proc.c return p->info;
p 372 src/proc.c return p->setter;
p 81 src/promise.c ScmPromise *p = (ScmPromise*)obj;
p 82 src/promise.c const char *forced = p->content->forced? " (forced)" : "";
p 83 src/promise.c if (SCM_FALSEP(p->kind)) {
p 84 src/promise.c Scm_Printf(port, "#<promise %p%s>", p, forced);
p 86 src/promise.c Scm_Printf(port, "#<promise(%S) %p%s>", p->kind, p, forced);
p 98 src/promise.c ScmPromise *p = SCM_NEW(ScmPromise);
p 100 src/promise.c SCM_SET_CLASS(p, SCM_CLASS_PROMISE);
p 103 src/promise.c p->content = c;
p 104 src/promise.c p->kind = SCM_FALSE;
p 105 src/promise.c return SCM_OBJ(p);
p 114 src/promise.c ScmPromise *p = (ScmPromise*)data[0];
p 118 src/promise.c if (!p->content->forced) {
p 122 src/promise.c p->content->forced = SCM_PROMISE(result)->content->forced;
p 123 src/promise.c p->content->code = SCM_PROMISE(result)->content->code;
p 124 src/promise.c SCM_PROMISE(result)->content = p->content;
p 129 src/promise.c p->content->forced = TRUE;
p 130 src/promise.c p->content->code = result;
p 133 src/promise.c SCM_RETURN(Scm_Force(SCM_OBJ(p)));
p 141 src/promise.c ScmPromise *p = (ScmPromise*)obj;
p 142 src/promise.c if (p->content->forced) SCM_RETURN(p->content->code);
p 144 src/promise.c Scm_VMPushCC(force_cc, (void**)&p, 1);
p 145 src/promise.c SCM_RETURN(Scm_VMApply0(p->content->code));
p 3483 src/stdlib.c ScmObj p;
p 3486 src/stdlib.c p = (p_scm);
p 3490 src/stdlib.c SCM_RESULT = Scm_Force(p);
p 69 src/string.c s->initialBody.start = p;
p 78 src/string.c b->start = p;
p 92 src/string.c const char *p = SCM_STRING_BODY_START(b);
p 96 src/string.c int n = SCM_CHAR_NFOLLOWS(*p) + 1;
p 97 src/string.c for (; n > 0 && s > 0; p++, n--, s--, i++) {
p 98 src/string.c putc(*p, out);
p 120 src/string.c const char *p = str;
p 122 src/string.c while ((c = *p++) != 0) {
p 127 src/string.c if (!*p++) { len = -1; goto eos; }
p 191 src/string.c char *p;
p 194 src/string.c for (i=0, p=ptr; i<len; i++, p+=size) {
p 195 src/string.c SCM_CHAR_PUT(p, fill);
p 230 src/string.c char *p;
p 234 src/string.c p = SCM_NEW_ATOMIC2(char *, size+1);
p 235 src/string.c memcpy(p, SCM_STRING_BODY_START(b), size);
p 236 src/string.c p[size] = '\0';
p 237 src/string.c return p;
p 248 src/string.c char *p = SCM_NEW_ATOMIC2(char *, size+1);
p 249 src/string.c memcpy(p, SCM_STRING_BODY_START(b), size);
p 250 src/string.c p[size] = '\0';
p 253 src/string.c ((ScmStringBody*)b)->start = p; /* discard const qualifier */
p 254 src/string.c return p;
p 484 src/string.c const char *p = forward_pos(SCM_STRING_BODY_START(b), pos);
p 486 src/string.c SCM_CHAR_GET(p, c);
p 538 src/string.c char *p = SCM_NEW_ATOMIC2(char *,sizex + sizey + 1);
p 540 src/string.c memcpy(p, xb->start, sizex);
p 541 src/string.c memcpy(p+sizex, yb->start, sizey);
p 542 src/string.c p[sizex + sizey] = '\0';
p 547 src/string.c return SCM_OBJ(make_str(lenx+leny, sizex+sizey, p, flags));
p 555 src/string.c char *p;
p 560 src/string.c p = SCM_NEW_ATOMIC2(char *, sizex + sizey + 1);
p 561 src/string.c memcpy(p, xb->start, sizex);
p 562 src/string.c memcpy(p+sizex, str, sizey);
p 563 src/string.c p[sizex+sizey] = '\0';
p 568 src/string.c return SCM_OBJ(make_str(lenx + leny, sizex + sizey, p, flags));
p 709 src/string.c char *p;
p 720 src/string.c p = SCM_NEW_ATOMIC2(char *, sizez+1);
p 721 src/string.c if (start > 0) memcpy(p, SCM_STRING_BODY_START(xb), start);
p 722 src/string.c memcpy(p+start, str, sizey);
p 723 src/string.c memcpy(p+start+sizey, SCM_STRING_BODY_START(xb)+end, sizex-end);
p 724 src/string.c p[sizez] = '\0';
p 731 src/string.c p = SCM_NEW_ATOMIC2(char *, sizez+1);
p 733 src/string.c memcpy(p, SCM_STRING_BODY_START(xb), s - SCM_STRING_BODY_START(xb));
p 735 src/string.c memcpy(p + (s - SCM_STRING_BODY_START(xb)), str, sizey);
p 736 src/string.c memcpy(p + (s - SCM_STRING_BODY_START(xb)) + sizey, e,
p 738 src/string.c p[sizez] = '\0';
p 746 src/string.c p, /* start */
p 782 src/string.c char *p;
p 786 src/string.c p = SCM_NEW_ATOMIC2(char *, size+1);
p 787 src/string.c memcpy(p, xb->start, size);
p 788 src/string.c p[size] = '\0';
p 789 src/string.c p[k] = (char)b;
p 792 src/string.c x->body = make_str_body(size, size, p, SCM_STRING_INCOMPLETE);
p 864 src/string.c const char *s = SCM_STRING_BODY_START(strb), *p = s, *e = s + size;
p 872 src/string.c while (p < e) {
p 876 src/string.c SCM_CHAR_GET(p, cc);
p 881 src/string.c p += ncc;
p 882 src/string.c s = p;
p 884 src/string.c p += ncc;
p 1084 src/string.c char *newstr, *p;
p 1123 src/string.c p = newstr = SCM_NEW_ATOMIC2(char *,
p 1125 src/string.c memcpy(p, SCM_STRING_BODY_START(strb), prelen);
p 1126 src/string.c p += prelen;
p 1128 src/string.c SCM_CHAR_PUT(p, ch);
p 1129 src/string.c p += chlen;
p 1131 src/string.c memcpy(p, SCM_STRING_BODY_START(strb) + prelen + midlen, postlen);
p 1132 src/string.c p[postlen] = '\0'; /* be friendly to C */
p 128 src/symbol.c const char *p = SCM_STRING_BODY_START(b), *q;
p 138 src/symbol.c if (siz == 1 && (*p == '+' || *p == '-')) {
p 139 src/symbol.c SCM_PUTC((unsigned)*p, port);
p 142 src/symbol.c if ((unsigned int)*p < 128 && (special[(unsigned int)*p]&1)) {
p 145 src/symbol.c for (i=0, q=p; i<siz; i++, q++) {
p 155 src/symbol.c for (q=p; q<p+siz; ) {
p 830 src/syslib.c struct passwd *p = getpwuid(uid);
p 831 src/syslib.c if (p == NULL) { Scm_SigCheck(Scm_VM()); SCM_RETURN(SCM_FALSE); }
p 832 src/syslib.c else SCM_RETURN(SCM_MAKE_STR_COPYING(p->pw_name));
p 848 src/syslib.c struct passwd *p = getpwnam(Scm_GetStringConst(name));
p 849 src/syslib.c if (p == NULL) { Scm_SigCheck(Scm_VM()); SCM_RETURN(SCM_FALSE); }
p 850 src/syslib.c else SCM_RETURN(Scm_MakeInteger(p->pw_uid));
p 2002 src/syslib.c char p[GETCWD_PATH_MAX];
p 2003 src/syslib.c if (getcwd(p, GETCWD_PATH_MAX-1) == NULL) {
p 2006 src/syslib.c SCM_RESULT = p;
p 269 src/system.c const char *p = path;
p 270 src/system.c while (p < end) {
p 271 src/system.c if (*p == '/' || *p == '\\') return p;
p 272 src/system.c p += SCM_CHAR_NFOLLOWS(*p)+1;
p 281 src/system.c const char *p = path, *last = NULL;
p 282 src/system.c while (p < end) {
p 283 src/system.c if (*p == '/' || *p == '\\') last = p;
p 284 src/system.c p += SCM_CHAR_NFOLLOWS(*p)+1;
p 291 src/system.c while (p < end) {
p 292 src/system.c if (*p != '/' && *p != '\\') break;
p 293 src/system.c p += SCM_CHAR_NFOLLOWS(*p)+1;
p 295 src/system.c return p;
p 302 src/system.c const char *p = get_first_separator(path, end), *q;
p 303 src/system.c if (p == NULL) return end;
p 305 src/system.c q = skip_separators(p, end);
p 306 src/system.c if (q == end) return p;
p 307 src/system.c p = get_first_separator(q, end);
p 308 src/system.c if (p == NULL) return end;
p 369 src/system.c char p[GETCWD_PATH_MAX];
p 370 src/system.c if (getcwd(p, GETCWD_PATH_MAX-1) == NULL) {
p 374 src/system.c dirlen = strlen(p);
p 375 src/system.c Scm_DStringPutz(dst, p, dirlen);
p 376 src/system.c if (p[dirlen-1] != '/' && p[dirlen-1] != '\\') {
p 465 src/system.c const char *p;
p 468 src/system.c p = get_first_separator(srcp, endp);
p 469 src/system.c if (p == NULL) {
p 471 src/system.c p = endp;
p 474 src/system.c if (p == srcp+1 && *srcp == '.') {
p 476 src/system.c } else if (p == srcp+2 && srcp[0] == '.' && srcp[1] == '.') {
p 487 src/system.c comps = Scm_Cons(Scm_MakeString(srcp, p-srcp, -1, 0), comps);
p 498 src/system.c srcp = skip_separators(p, endp);
p 990 src/system.c ScmObj head = SCM_NIL, tail = SCM_NIL, p;
p 1003 src/system.c p = SCM_MAKE_STR_COPYING(*memp);
p 1004 src/system.c SCM_APPEND1(head, tail, p);
p 1117 src/system.c static ScmObj SCM_CPP_CAT3(pwd_, name, _get)(ScmSysPasswd *p) \
p 1118 src/system.c { return p->name; }
p 667 src/vm.c ScmObj p = SCM_NIL, a; \
p 672 src/vm.c p = Scm_Cons(a, p); \
p 675 src/vm.c PUSH_ARG(p); \
p 2621 src/vm.c ScmObj *p;
p 2637 src/vm.c for (p = vm->sp; p < vm->stackEnd; p++) *p = NULL;
p 3396 src/vm.c ScmObj h = SCM_NIL, t = SCM_NIL, p;
p 3398 src/vm.c SCM_FOR_EACH(p, current) {
p 3399 src/vm.c SCM_ASSERT(SCM_PAIRP(SCM_CAR(p)));
p 3400 src/vm.c if (!SCM_FALSEP(Scm_Memq(SCM_CAR(p), target))) break;
p 3402 src/vm.c SCM_APPEND1(h, t, SCM_CDAR(p));
p 3404 src/vm.c SCM_FOR_EACH(p, target) {
p 3405 src/vm.c SCM_ASSERT(SCM_PAIRP(SCM_CAR(p)));
p 3406 src/vm.c if (!SCM_FALSEP(Scm_Memq(SCM_CAR(p), current))) continue;
p 3408 src/vm.c SCM_APPEND1(h, t, SCM_CAAR(p));
p 3757 src/vm.c ScmObj p = SCM_CAR(ip);
p 3758 src/vm.c if (!SCM_PAIRP(p) || !SCM_INTP(SCM_CAR(p))) continue;
p 3759 src/vm.c if (SCM_INT_VALUE(SCM_CAR(p)) < off) {
p 3760 src/vm.c return SCM_CDR(p);
p 3771 src/vm.c ScmObj p = Scm_Assq(SCM_SYM_SOURCE_INFO, info);
p 3772 src/vm.c if (SCM_PAIRP(p)) return SCM_CDR(p);
p 3781 src/vm.c ScmObj p = Scm_Assq(SCM_SYM_BIND_INFO, info);
p 3782 src/vm.c if (SCM_PAIRP(p)) return SCM_CDR(p);
p 70 src/weak.c ScmObj *p = (ScmObj*)v->pointers;
p 72 src/weak.c if (p[i]==NULL || SCM_PTRP(p[i])) {
p 73 src/weak.c GC_unregister_disappearing_link((GC_PTR*)&p[i]);
p 75 src/weak.c p[i] = SCM_FALSE; /* safety */
p 86 src/weak.c ScmObj *p;
p 93 src/weak.c p = SCM_NEW_ATOMIC2(ScmObj*, size * sizeof(ScmObj));
p 94 src/weak.c for (i=0; i<size; i++) p[i] = SCM_FALSE;
p 95 src/weak.c v->pointers = (void*)p;
p 102 src/weak.c ScmObj *p;
p 110 src/weak.c p = (ScmObj*)v->pointers;
p 111 src/weak.c if (p[index] == NULL) {
p 115 src/weak.c return p[index];
p 121 src/weak.c ScmObj *p;
p 125 src/weak.c p = (ScmObj*)v->pointers;
p 128 src/weak.c if (p[index] == NULL || SCM_PTRP(p[index])) {
p 129 src/weak.c GC_unregister_disappearing_link((GC_PTR*)&p[index]);
p 132 src/weak.c p[index] = value;
p 135 src/weak.c GC_general_register_disappearing_link((GC_PTR*)&p[index], (GC_PTR)value);
p 136 src/write.c if (!SCM_OPORTP(p)) {
p 137 src/write.c Scm_Error("output port required, but got %S", p);
p 139 src/write.c port = SCM_PORT(p);