Annotation of OpenXM_contrib2/asir2000/gc/cord/cordxtra.c, Revision 1.1
1.1 ! noro 1: /*
! 2: * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved.
! 3: *
! 4: * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
! 5: * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
! 6: *
! 7: * Permission is hereby granted to use or copy this program
! 8: * for any purpose, provided the above notices are retained on all copies.
! 9: * Permission to modify the code and to distribute modified code is granted,
! 10: * provided the above notices are retained, and a notice that the code was
! 11: * modified is included with the above copyright notice.
! 12: *
! 13: * Author: Hans-J. Boehm (boehm@parc.xerox.com)
! 14: */
! 15: /*
! 16: * These are functions on cords that do not need to understand their
! 17: * implementation. They serve also serve as example client code for
! 18: * cord_basics.
! 19: */
! 20: /* Boehm, December 8, 1995 1:53 pm PST */
! 21: # include <stdio.h>
! 22: # include <string.h>
! 23: # include <stdlib.h>
! 24: # include <stdarg.h>
! 25: # include "cord.h"
! 26: # include "ec.h"
! 27: # define I_HIDE_POINTERS /* So we get access to allocation lock. */
! 28: /* We use this for lazy file reading, */
! 29: /* so that we remain independent */
! 30: /* of the threads primitives. */
! 31: # include "gc.h"
! 32:
! 33: /* For now we assume that pointer reads and writes are atomic, */
! 34: /* i.e. another thread always sees the state before or after */
! 35: /* a write. This might be false on a Motorola M68K with */
! 36: /* pointers that are not 32-bit aligned. But there probably */
! 37: /* aren't too many threads packages running on those. */
! 38: # define ATOMIC_WRITE(x,y) (x) = (y)
! 39: # define ATOMIC_READ(x) (*(x))
! 40:
! 41: /* The standard says these are in stdio.h, but they aren't always: */
! 42: # ifndef SEEK_SET
! 43: # define SEEK_SET 0
! 44: # endif
! 45: # ifndef SEEK_END
! 46: # define SEEK_END 2
! 47: # endif
! 48:
! 49: # define BUFSZ 2048 /* Size of stack allocated buffers when */
! 50: /* we want large buffers. */
! 51:
! 52: typedef void (* oom_fn)(void);
! 53:
! 54: # define OUT_OF_MEMORY { if (CORD_oom_fn != (oom_fn) 0) (*CORD_oom_fn)(); \
! 55: ABORT("Out of memory\n"); }
! 56: # define ABORT(msg) { fprintf(stderr, "%s\n", msg); abort(); }
! 57:
! 58: CORD CORD_cat_char(CORD x, char c)
! 59: {
! 60: register char * string;
! 61:
! 62: if (c == '\0') return(CORD_cat(x, CORD_nul(1)));
! 63: string = GC_MALLOC_ATOMIC(2);
! 64: if (string == 0) OUT_OF_MEMORY;
! 65: string[0] = c;
! 66: string[1] = '\0';
! 67: return(CORD_cat_char_star(x, string, 1));
! 68: }
! 69:
! 70: CORD CORD_catn(int nargs, ...)
! 71: {
! 72: register CORD result = CORD_EMPTY;
! 73: va_list args;
! 74: register int i;
! 75:
! 76: va_start(args, nargs);
! 77: for (i = 0; i < nargs; i++) {
! 78: register CORD next = va_arg(args, CORD);
! 79: result = CORD_cat(result, next);
! 80: }
! 81: va_end(args);
! 82: return(result);
! 83: }
! 84:
! 85: typedef struct {
! 86: size_t len;
! 87: size_t count;
! 88: char * buf;
! 89: } CORD_fill_data;
! 90:
! 91: int CORD_fill_proc(char c, void * client_data)
! 92: {
! 93: register CORD_fill_data * d = (CORD_fill_data *)client_data;
! 94: register size_t count = d -> count;
! 95:
! 96: (d -> buf)[count] = c;
! 97: d -> count = ++count;
! 98: if (count >= d -> len) {
! 99: return(1);
! 100: } else {
! 101: return(0);
! 102: }
! 103: }
! 104:
! 105: int CORD_batched_fill_proc(const char * s, void * client_data)
! 106: {
! 107: register CORD_fill_data * d = (CORD_fill_data *)client_data;
! 108: register size_t count = d -> count;
! 109: register size_t max = d -> len;
! 110: register char * buf = d -> buf;
! 111: register const char * t = s;
! 112:
! 113: while((buf[count] = *t++) != '\0') {
! 114: count++;
! 115: if (count >= max) {
! 116: d -> count = count;
! 117: return(1);
! 118: }
! 119: }
! 120: d -> count = count;
! 121: return(0);
! 122: }
! 123:
! 124: /* Fill buf with len characters starting at i. */
! 125: /* Assumes len characters are available. */
! 126: void CORD_fill_buf(CORD x, size_t i, size_t len, char * buf)
! 127: {
! 128: CORD_fill_data fd;
! 129:
! 130: fd.len = len;
! 131: fd.buf = buf;
! 132: fd.count = 0;
! 133: (void)CORD_iter5(x, i, CORD_fill_proc, CORD_batched_fill_proc, &fd);
! 134: }
! 135:
! 136: int CORD_cmp(CORD x, CORD y)
! 137: {
! 138: CORD_pos xpos;
! 139: CORD_pos ypos;
! 140: register size_t avail, yavail;
! 141:
! 142: if (y == CORD_EMPTY) return(x != CORD_EMPTY);
! 143: if (x == CORD_EMPTY) return(-1);
! 144: if (CORD_IS_STRING(y) && CORD_IS_STRING(x)) return(strcmp(x,y));
! 145: CORD_set_pos(xpos, x, 0);
! 146: CORD_set_pos(ypos, y, 0);
! 147: for(;;) {
! 148: if (!CORD_pos_valid(xpos)) {
! 149: if (CORD_pos_valid(ypos)) {
! 150: return(-1);
! 151: } else {
! 152: return(0);
! 153: }
! 154: }
! 155: if (!CORD_pos_valid(ypos)) {
! 156: return(1);
! 157: }
! 158: if ((avail = CORD_pos_chars_left(xpos)) <= 0
! 159: || (yavail = CORD_pos_chars_left(ypos)) <= 0) {
! 160: register char xcurrent = CORD_pos_fetch(xpos);
! 161: register char ycurrent = CORD_pos_fetch(ypos);
! 162: if (xcurrent != ycurrent) return(xcurrent - ycurrent);
! 163: CORD_next(xpos);
! 164: CORD_next(ypos);
! 165: } else {
! 166: /* process as many characters as we can */
! 167: register int result;
! 168:
! 169: if (avail > yavail) avail = yavail;
! 170: result = strncmp(CORD_pos_cur_char_addr(xpos),
! 171: CORD_pos_cur_char_addr(ypos), avail);
! 172: if (result != 0) return(result);
! 173: CORD_pos_advance(xpos, avail);
! 174: CORD_pos_advance(ypos, avail);
! 175: }
! 176: }
! 177: }
! 178:
! 179: int CORD_ncmp(CORD x, size_t x_start, CORD y, size_t y_start, size_t len)
! 180: {
! 181: CORD_pos xpos;
! 182: CORD_pos ypos;
! 183: register size_t count;
! 184: register long avail, yavail;
! 185:
! 186: CORD_set_pos(xpos, x, x_start);
! 187: CORD_set_pos(ypos, y, y_start);
! 188: for(count = 0; count < len;) {
! 189: if (!CORD_pos_valid(xpos)) {
! 190: if (CORD_pos_valid(ypos)) {
! 191: return(-1);
! 192: } else {
! 193: return(0);
! 194: }
! 195: }
! 196: if (!CORD_pos_valid(ypos)) {
! 197: return(1);
! 198: }
! 199: if ((avail = CORD_pos_chars_left(xpos)) <= 0
! 200: || (yavail = CORD_pos_chars_left(ypos)) <= 0) {
! 201: register char xcurrent = CORD_pos_fetch(xpos);
! 202: register char ycurrent = CORD_pos_fetch(ypos);
! 203: if (xcurrent != ycurrent) return(xcurrent - ycurrent);
! 204: CORD_next(xpos);
! 205: CORD_next(ypos);
! 206: count++;
! 207: } else {
! 208: /* process as many characters as we can */
! 209: register int result;
! 210:
! 211: if (avail > yavail) avail = yavail;
! 212: count += avail;
! 213: if (count > len) avail -= (count - len);
! 214: result = strncmp(CORD_pos_cur_char_addr(xpos),
! 215: CORD_pos_cur_char_addr(ypos), (size_t)avail);
! 216: if (result != 0) return(result);
! 217: CORD_pos_advance(xpos, (size_t)avail);
! 218: CORD_pos_advance(ypos, (size_t)avail);
! 219: }
! 220: }
! 221: return(0);
! 222: }
! 223:
! 224: char * CORD_to_char_star(CORD x)
! 225: {
! 226: register size_t len = CORD_len(x);
! 227: char * result = GC_MALLOC_ATOMIC(len + 1);
! 228:
! 229: if (result == 0) OUT_OF_MEMORY;
! 230: CORD_fill_buf(x, 0, len, result);
! 231: result[len] = '\0';
! 232: return(result);
! 233: }
! 234:
! 235: CORD CORD_from_char_star(const char *s)
! 236: {
! 237: char * result;
! 238: size_t len = strlen(s);
! 239:
! 240: if (0 == len) return(CORD_EMPTY);
! 241: result = GC_MALLOC_ATOMIC(len + 1);
! 242: if (result == 0) OUT_OF_MEMORY;
! 243: memcpy(result, s, len+1);
! 244: return(result);
! 245: }
! 246:
! 247: const char * CORD_to_const_char_star(CORD x)
! 248: {
! 249: if (x == 0) return("");
! 250: if (CORD_IS_STRING(x)) return((const char *)x);
! 251: return(CORD_to_char_star(x));
! 252: }
! 253:
! 254: char CORD_fetch(CORD x, size_t i)
! 255: {
! 256: CORD_pos xpos;
! 257:
! 258: CORD_set_pos(xpos, x, i);
! 259: if (!CORD_pos_valid(xpos)) ABORT("bad index?");
! 260: return(CORD_pos_fetch(xpos));
! 261: }
! 262:
! 263:
! 264: int CORD_put_proc(char c, void * client_data)
! 265: {
! 266: register FILE * f = (FILE *)client_data;
! 267:
! 268: return(putc(c, f) == EOF);
! 269: }
! 270:
! 271: int CORD_batched_put_proc(const char * s, void * client_data)
! 272: {
! 273: register FILE * f = (FILE *)client_data;
! 274:
! 275: return(fputs(s, f) == EOF);
! 276: }
! 277:
! 278:
! 279: int CORD_put(CORD x, FILE * f)
! 280: {
! 281: if (CORD_iter5(x, 0, CORD_put_proc, CORD_batched_put_proc, f)) {
! 282: return(EOF);
! 283: } else {
! 284: return(1);
! 285: }
! 286: }
! 287:
! 288: typedef struct {
! 289: size_t pos; /* Current position in the cord */
! 290: char target; /* Character we're looking for */
! 291: } chr_data;
! 292:
! 293: int CORD_chr_proc(char c, void * client_data)
! 294: {
! 295: register chr_data * d = (chr_data *)client_data;
! 296:
! 297: if (c == d -> target) return(1);
! 298: (d -> pos) ++;
! 299: return(0);
! 300: }
! 301:
! 302: int CORD_rchr_proc(char c, void * client_data)
! 303: {
! 304: register chr_data * d = (chr_data *)client_data;
! 305:
! 306: if (c == d -> target) return(1);
! 307: (d -> pos) --;
! 308: return(0);
! 309: }
! 310:
! 311: int CORD_batched_chr_proc(const char *s, void * client_data)
! 312: {
! 313: register chr_data * d = (chr_data *)client_data;
! 314: register char * occ = strchr(s, d -> target);
! 315:
! 316: if (occ == 0) {
! 317: d -> pos += strlen(s);
! 318: return(0);
! 319: } else {
! 320: d -> pos += occ - s;
! 321: return(1);
! 322: }
! 323: }
! 324:
! 325: size_t CORD_chr(CORD x, size_t i, int c)
! 326: {
! 327: chr_data d;
! 328:
! 329: d.pos = i;
! 330: d.target = c;
! 331: if (CORD_iter5(x, i, CORD_chr_proc, CORD_batched_chr_proc, &d)) {
! 332: return(d.pos);
! 333: } else {
! 334: return(CORD_NOT_FOUND);
! 335: }
! 336: }
! 337:
! 338: size_t CORD_rchr(CORD x, size_t i, int c)
! 339: {
! 340: chr_data d;
! 341:
! 342: d.pos = i;
! 343: d.target = c;
! 344: if (CORD_riter4(x, i, CORD_rchr_proc, &d)) {
! 345: return(d.pos);
! 346: } else {
! 347: return(CORD_NOT_FOUND);
! 348: }
! 349: }
! 350:
! 351: /* Find the first occurrence of s in x at position start or later. */
! 352: /* This uses an asymptotically poor algorithm, which should typically */
! 353: /* perform acceptably. We compare the first few characters directly, */
! 354: /* and call CORD_ncmp whenever there is a partial match. */
! 355: /* This has the advantage that we allocate very little, or not at all. */
! 356: /* It's very fast if there are few close misses. */
! 357: size_t CORD_str(CORD x, size_t start, CORD s)
! 358: {
! 359: CORD_pos xpos;
! 360: size_t xlen = CORD_len(x);
! 361: size_t slen;
! 362: register size_t start_len;
! 363: const char * s_start;
! 364: unsigned long s_buf = 0; /* The first few characters of s */
! 365: unsigned long x_buf = 0; /* Start of candidate substring. */
! 366: /* Initialized only to make compilers */
! 367: /* happy. */
! 368: unsigned long mask = 0;
! 369: register size_t i;
! 370: register size_t match_pos;
! 371:
! 372: if (s == CORD_EMPTY) return(start);
! 373: if (CORD_IS_STRING(s)) {
! 374: s_start = s;
! 375: slen = strlen(s);
! 376: } else {
! 377: s_start = CORD_to_char_star(CORD_substr(s, 0, sizeof(unsigned long)));
! 378: slen = CORD_len(s);
! 379: }
! 380: if (xlen < start || xlen - start < slen) return(CORD_NOT_FOUND);
! 381: start_len = slen;
! 382: if (start_len > sizeof(unsigned long)) start_len = sizeof(unsigned long);
! 383: CORD_set_pos(xpos, x, start);
! 384: for (i = 0; i < start_len; i++) {
! 385: mask <<= 8;
! 386: mask |= 0xff;
! 387: s_buf <<= 8;
! 388: s_buf |= s_start[i];
! 389: x_buf <<= 8;
! 390: x_buf |= CORD_pos_fetch(xpos);
! 391: CORD_next(xpos);
! 392: }
! 393: for (match_pos = start; ; match_pos++) {
! 394: if ((x_buf & mask) == s_buf) {
! 395: if (slen == start_len ||
! 396: CORD_ncmp(x, match_pos + start_len,
! 397: s, start_len, slen - start_len) == 0) {
! 398: return(match_pos);
! 399: }
! 400: }
! 401: if ( match_pos == xlen - slen ) {
! 402: return(CORD_NOT_FOUND);
! 403: }
! 404: x_buf <<= 8;
! 405: x_buf |= CORD_pos_fetch(xpos);
! 406: CORD_next(xpos);
! 407: }
! 408: }
! 409:
! 410: void CORD_ec_flush_buf(CORD_ec x)
! 411: {
! 412: register size_t len = x[0].ec_bufptr - x[0].ec_buf;
! 413: char * s;
! 414:
! 415: if (len == 0) return;
! 416: s = GC_MALLOC_ATOMIC(len+1);
! 417: memcpy(s, x[0].ec_buf, len);
! 418: s[len] = '\0';
! 419: x[0].ec_cord = CORD_cat_char_star(x[0].ec_cord, s, len);
! 420: x[0].ec_bufptr = x[0].ec_buf;
! 421: }
! 422:
! 423: void CORD_ec_append_cord(CORD_ec x, CORD s)
! 424: {
! 425: CORD_ec_flush_buf(x);
! 426: x[0].ec_cord = CORD_cat(x[0].ec_cord, s);
! 427: }
! 428:
! 429: /*ARGSUSED*/
! 430: char CORD_nul_func(size_t i, void * client_data)
! 431: {
! 432: return((char)(unsigned long)client_data);
! 433: }
! 434:
! 435:
! 436: CORD CORD_chars(char c, size_t i)
! 437: {
! 438: return(CORD_from_fn(CORD_nul_func, (void *)(unsigned long)c, i));
! 439: }
! 440:
! 441: CORD CORD_from_file_eager(FILE * f)
! 442: {
! 443: register int c;
! 444: CORD_ec ecord;
! 445:
! 446: CORD_ec_init(ecord);
! 447: for(;;) {
! 448: c = getc(f);
! 449: if (c == 0) {
! 450: /* Append the right number of NULs */
! 451: /* Note that any string of NULs is rpresented in 4 words, */
! 452: /* independent of its length. */
! 453: register size_t count = 1;
! 454:
! 455: CORD_ec_flush_buf(ecord);
! 456: while ((c = getc(f)) == 0) count++;
! 457: ecord[0].ec_cord = CORD_cat(ecord[0].ec_cord, CORD_nul(count));
! 458: }
! 459: if (c == EOF) break;
! 460: CORD_ec_append(ecord, c);
! 461: }
! 462: (void) fclose(f);
! 463: return(CORD_balance(CORD_ec_to_cord(ecord)));
! 464: }
! 465:
! 466: /* The state maintained for a lazily read file consists primarily */
! 467: /* of a large direct-mapped cache of previously read values. */
! 468: /* We could rely more on stdio buffering. That would have 2 */
! 469: /* disadvantages: */
! 470: /* 1) Empirically, not all fseek implementations preserve the */
! 471: /* buffer whenever they could. */
! 472: /* 2) It would fail if 2 different sections of a long cord */
! 473: /* were being read alternately. */
! 474: /* We do use the stdio buffer for read ahead. */
! 475: /* To guarantee thread safety in the presence of atomic pointer */
! 476: /* writes, cache lines are always replaced, and never modified in */
! 477: /* place. */
! 478:
! 479: # define LOG_CACHE_SZ 14
! 480: # define CACHE_SZ (1 << LOG_CACHE_SZ)
! 481: # define LOG_LINE_SZ 9
! 482: # define LINE_SZ (1 << LOG_LINE_SZ)
! 483:
! 484: typedef struct {
! 485: size_t tag;
! 486: char data[LINE_SZ];
! 487: /* data[i%LINE_SZ] = ith char in file if tag = i/LINE_SZ */
! 488: } cache_line;
! 489:
! 490: typedef struct {
! 491: FILE * lf_file;
! 492: size_t lf_current; /* Current file pointer value */
! 493: cache_line * volatile lf_cache[CACHE_SZ/LINE_SZ];
! 494: } lf_state;
! 495:
! 496: # define MOD_CACHE_SZ(n) ((n) & (CACHE_SZ - 1))
! 497: # define DIV_CACHE_SZ(n) ((n) >> LOG_CACHE_SZ)
! 498: # define MOD_LINE_SZ(n) ((n) & (LINE_SZ - 1))
! 499: # define DIV_LINE_SZ(n) ((n) >> LOG_LINE_SZ)
! 500: # define LINE_START(n) ((n) & ~(LINE_SZ - 1))
! 501:
! 502: typedef struct {
! 503: lf_state * state;
! 504: size_t file_pos; /* Position of needed character. */
! 505: cache_line * new_cache;
! 506: } refill_data;
! 507:
! 508: /* Executed with allocation lock. */
! 509: static char refill_cache(client_data)
! 510: refill_data * client_data;
! 511: {
! 512: register lf_state * state = client_data -> state;
! 513: register size_t file_pos = client_data -> file_pos;
! 514: FILE *f = state -> lf_file;
! 515: size_t line_start = LINE_START(file_pos);
! 516: size_t line_no = DIV_LINE_SZ(MOD_CACHE_SZ(file_pos));
! 517: cache_line * new_cache = client_data -> new_cache;
! 518:
! 519: if (line_start != state -> lf_current
! 520: && fseek(f, line_start, SEEK_SET) != 0) {
! 521: ABORT("fseek failed");
! 522: }
! 523: if (fread(new_cache -> data, sizeof(char), LINE_SZ, f)
! 524: <= file_pos - line_start) {
! 525: ABORT("fread failed");
! 526: }
! 527: new_cache -> tag = DIV_LINE_SZ(file_pos);
! 528: /* Store barrier goes here. */
! 529: ATOMIC_WRITE(state -> lf_cache[line_no], new_cache);
! 530: state -> lf_current = line_start + LINE_SZ;
! 531: return(new_cache->data[MOD_LINE_SZ(file_pos)]);
! 532: }
! 533:
! 534: char CORD_lf_func(size_t i, void * client_data)
! 535: {
! 536: register lf_state * state = (lf_state *)client_data;
! 537: register cache_line * volatile * cl_addr =
! 538: &(state -> lf_cache[DIV_LINE_SZ(MOD_CACHE_SZ(i))]);
! 539: register cache_line * cl = (cache_line *)ATOMIC_READ(cl_addr);
! 540:
! 541: if (cl == 0 || cl -> tag != DIV_LINE_SZ(i)) {
! 542: /* Cache miss */
! 543: refill_data rd;
! 544:
! 545: rd.state = state;
! 546: rd.file_pos = i;
! 547: rd.new_cache = GC_NEW_ATOMIC(cache_line);
! 548: if (rd.new_cache == 0) OUT_OF_MEMORY;
! 549: return((char)(GC_word)
! 550: GC_call_with_alloc_lock((GC_fn_type) refill_cache, &rd));
! 551: }
! 552: return(cl -> data[MOD_LINE_SZ(i)]);
! 553: }
! 554:
! 555: /*ARGSUSED*/
! 556: void CORD_lf_close_proc(void * obj, void * client_data)
! 557: {
! 558: if (fclose(((lf_state *)obj) -> lf_file) != 0) {
! 559: ABORT("CORD_lf_close_proc: fclose failed");
! 560: }
! 561: }
! 562:
! 563: CORD CORD_from_file_lazy_inner(FILE * f, size_t len)
! 564: {
! 565: register lf_state * state = GC_NEW(lf_state);
! 566: register int i;
! 567:
! 568: if (state == 0) OUT_OF_MEMORY;
! 569: if (len != 0) {
! 570: /* Dummy read to force buffer allocation. */
! 571: /* This greatly increases the probability */
! 572: /* of avoiding deadlock if buffer allocation */
! 573: /* is redirected to GC_malloc and the */
! 574: /* world is multithreaded. */
! 575: char buf[1];
! 576:
! 577: (void) fread(buf, 1, 1, f);
! 578: rewind(f);
! 579: }
! 580: state -> lf_file = f;
! 581: for (i = 0; i < CACHE_SZ/LINE_SZ; i++) {
! 582: state -> lf_cache[i] = 0;
! 583: }
! 584: state -> lf_current = 0;
! 585: GC_REGISTER_FINALIZER(state, CORD_lf_close_proc, 0, 0, 0);
! 586: return(CORD_from_fn(CORD_lf_func, state, len));
! 587: }
! 588:
! 589: CORD CORD_from_file_lazy(FILE * f)
! 590: {
! 591: register long len;
! 592:
! 593: if (fseek(f, 0l, SEEK_END) != 0) {
! 594: ABORT("Bad fd argument - fseek failed");
! 595: }
! 596: if ((len = ftell(f)) < 0) {
! 597: ABORT("Bad fd argument - ftell failed");
! 598: }
! 599: rewind(f);
! 600: return(CORD_from_file_lazy_inner(f, (size_t)len));
! 601: }
! 602:
! 603: # define LAZY_THRESHOLD (128*1024 + 1)
! 604:
! 605: CORD CORD_from_file(FILE * f)
! 606: {
! 607: register long len;
! 608:
! 609: if (fseek(f, 0l, SEEK_END) != 0) {
! 610: ABORT("Bad fd argument - fseek failed");
! 611: }
! 612: if ((len = ftell(f)) < 0) {
! 613: ABORT("Bad fd argument - ftell failed");
! 614: }
! 615: rewind(f);
! 616: if (len < LAZY_THRESHOLD) {
! 617: return(CORD_from_file_eager(f));
! 618: } else {
! 619: return(CORD_from_file_lazy_inner(f, (size_t)len));
! 620: }
! 621: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cordxtra.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / gc / cord